java的套娃汇总（黑马程序员基础java总结）

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方法，猫吃鱼，狗吃肉是不一样的，需要抽象出来

Cat

public class Cat extends Animal {public Cat() {}public Cat(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("猫吃鱼");}
}

注意！这里的抽象方法是需要重写的，否则无法调用

Dog

public class Dog extends Animal{public Dog() {}public Dog(String name, int age) {super(name, age);}@Overridepublic 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);}@Overridepublic void study() {System.out.println("学习发球");}@Overridepublic void eat() {System.out.println("吃小米");}@Overridepublic 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();}
}

匿名内部类

总述

匿名内部类前提是要有一个接口

Inner

public interface Inter {void show();}

Outer

匿名内部类本质是类似一个new对象，相当于在调用对象的过程中做了一些批注，而且在某个类的内部只执行一次（偷懒用）
可以直接调用方法

public class Outer {public void method(){//类比 Inter i=new Inter()     所以最后要;// 本质Inter是一个对象new Inter(){@Overridepublic void show() {System.out.println("匿名内部类方法");}}.show();//Inter.show();}
}

主程序

public class OuterDemo {public static void main(String[] args) {Outer o=new Outer();o.method();}
}

成员内部类

在类中class一个类

Inner

public 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{@Overridepublic 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() {@Overridepublic void jump() {System.out.println("mao");}});//不需要创建对象，直接可以实现jo.method(new Jumping() {@Overridepublic void jump() {System.out.println("gou");}});}
}

这里在调用方法的时候可以直接用匿名内部类，里面写需要的方法，比起来方法重写，是不是方便很多

导包

最后说一个很小的知识点，java导包
就是自己写好的程序怎么导包在另一个程序中使用

import 子类父类应用.Teacher;
public class 导包 {public static void main(String[] args) {Teacher t=new Teacher();t.teach();}
}

软件包.java名字完成导包，可以调用其程序