java里面存在很多套娃关系，这里对于基础的套娃做一个小小的总结
对象调用对象调用顾名思义就是new一个新的对象出来，在主程序中调用
设想一个场景，我要定义一个手机对象，里面有牌子，价格，和一些其他功能之类的
其中
成员变量
品牌（brand）
价格（price）
成员方法
打电话（call）
发短信（sendMessage）
对象程序
public class Phone {
//成员变量
String brand;
int price;
//成员方法
public void call(){
System.out.println("打电话");
}
public void sendMessage(){
System.out.println("发短信");
}
}
主程序
主程序需要一张门票去访问到这个对象，也就是new一个对象出来，调用对象里面的东西
这里的p.brand可以理解是一种重写
public class Phone2 {
public static void main(String[] args) {
Phone p=new Phone();
//输出门票的地址
System.out.println(p);
p.brand="小米";
p.price=2999;
System.out.println(p.brand+p.price);
p.call();
p.sendMessage();
}
}
继承
继承的思想在于可以定义一个大家都用的父类，之后在衍生出其子类重写具体的方法
比如定义一个person父类，teacher和student作为子类，在享用共有资源的同时又可以写自己特有的东西，是不是贼方便
private关键字起到保护数据的作用，主程序不可以直接调用
也就是不可以直接
String name=（）；
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
idea中写完private 可以直接alt+insert生成构造函数，get set方法，特别好用
子类public class Teacher extends Person {
//写无参的原因在于让无参数的创建对象方法可以访问到
public Teacher(){}
public Teacher(String name,int age){
//使用super访问到父类中的方法
super(name,age);
}
public void teach(){
System.out.println("好好教书");
}
}
主程序
主程序中实现所有的输入动作
public class PersonDemo {
public static void main(String[] args) {
Teacher t1=new Teacher();
t1.setName("Peter");
t1.setAge(12);
System.out.println(t1.getName()+t1.getAge());
t1.teach();
//创建对象直接带参数
Teacher t2=new Teacher("Betty",20);
System.out.println(t2.getName()+t2.getAge());
t2.teach();
}
}
多态
多态就是有很多的子类，很多的对象，主程序雨露均沾的一种思维
抽象类public abstract class Animal {
private String name;
private int age;
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//抽象方法的应用
public abstract void eat();
}
因为这里eat方法，猫吃鱼，狗吃肉是不一样的，需要抽象出来
Catpublic class Cat extends Animal {
public Cat() {
}
public Cat(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
注意！这里的抽象方法是需要重写的，否则无法调用
Dogpublic class Dog extends Animal{
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
主程序
public static void main(String[] args) {
//abstract方法必须有子类继承，并且复写抽象方法，才可以新建对象
Animal a=new Cat();
a=new Cat("加非",19);
System.out.println(a.getAge()+","+a.getName());
a.eat();
Animal b=new Dog();
b=new Dog("p",20);
System.out.println(b.getAge()+b.getName());
b.eat();
}
}
接口
接口不同于继承思维，接口是为了实现对象的差异化
这里放一个运动员案例问题，以及解决思路
案例：
说英语作为一个单独的功能，就可以用接口实现，使得乒乓球类和篮球类区分开
思路：
这里就单独对乒乓球运动员做一个支类放代码了
public interface English {
//接口内默认方法均为抽象方法
void speak();
}
运动员大类
public abstract class Person {
private String name;
private String age;
public Person() {
}
public Person(String name, String age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public abstract void eat();
}
乒乓球运动员类
public class PingpangPlayer extends Player implements English{
public PingpangPlayer() {
}
public PingpangPlayer(String name, String age) {
super(name, age);
}
@Override
public void study() {
System.out.println("学习发球");
}
@Override
public void eat() {
System.out.println("吃小米");
}
@Override
public void speak() {
System.out.println("学英语");
}
}
主程序
public class PersonDemo {
public PersonDemo() {
}
public static void main(String[] args) {
PingpangPlayer ppp=new PingpangPlayer();
//直接传入参数的方法
ppp=new PingpangPlayer("Betty","20");
System.out.println(ppp.getAge()+","+ppp.getName());
ppp.eat();
ppp.study();
ppp.speak();
System.out.println("--------------");
BasketcallPlayer bb=new BasketcallPlayer();
bb=new BasketcallPlayer("Jimmy","14");
System.out.println(bb.getAge()+bb.getName());
bb.eat();
bb.study();
}
}
匿名内部类
总述
匿名内部类前提是要有一个接口
Innerpublic interface Inter {
void show();
}
Outer
匿名内部类本质是类似一个new对象，相当于在调用对象的过程中做了一些批注，而且在某个类的内部只执行一次（偷懒用）
可以直接调用方法
public class Outer {
public void method(){
//类比 Inter i=new Inter() 所以最后要;
// 本质Inter是一个对象
new Inter(){
@Override
public void show() {
System.out.println("匿名内部类方法");
}
}.show();
//Inter.show();
}
}
主程序
public class OuterDemo {
public static void main(String[] args) {
Outer o=new Outer();
o.method();
}
}
成员内部类
在类中class一个类
Innerpublic class Outer {
private int sum=10;
public class Inner{
public void show(){
System.out.println(sum);
}
}
}
主程序
调用成员内部类的创建对象方法： Outer.Inner oi=new Outer().new Inner();
public class InnerDemo {
public static void main(String[] args) {
//调用成员内部类的创建对象方法： Outer.Inner oi=new Outer().new Inner();
Outer.Inner oi=new Outer().new Inner();
}
}
局部内部类
Inner
在成员方法内部class一个类
调用思路：
1.当前路径下new对象调用show方法
2.主程序中new对象调method方法
public class Outer {
private int sum = 20;
public void method() {
class Inner {
public void show() {
System.out.println(sum);
}
}
Inner i = new Inner();
i.show();
}
}
主程序
public class InnerDemo {
public static void main(String[] args) {
Outer o=new Outer();
o.method();
}
}
猫狗案例分析
灵魂在主程序，你看了就发现：真香
接口public interface Jumping {
void jump();
}
Cat实例化接口
public class JumpingOperator {
//接口调入
public void method(Jumping j){
j.jump();
}
}
Cat类
public class Cat implements Jumping{
@Override
public void jump() {
System.out.println("猫可以调高了");
}
}
主程序
public class JumpingDemo {
public static void main(String[] args) {
JumpingOperator jo=new JumpingOperator();
//Jumping j=new Cat()相当于子类父类继承思路, j为对象
Jumping j=new Cat();
jo.method(j);
jo.method(new Jumping() {
@Override
public void jump() {
System.out.println("mao");
}
});
//不需要创建对象，直接可以实现
jo.method(new Jumping() {
@Override
public void jump() {
System.out.println("gou");
}
});
}
}
这里在调用方法的时候可以直接用匿名内部类，里面写需要的方法，比起来方法重写，是不是方便很多
导包最后说一个很小的知识点，java导包
就是自己写好的程序怎么导包在另一个程序中使用
import 子类父类应用.Teacher;
public class 导包 {
public static void main(String[] args) {
Teacher t=new Teacher();
t.teach();
}
}
软件包.java名字 完成导包， 可以调用其程序
