【JAVA】笔记（4）---继承；方法覆盖；多态机制；super；

继承（extends）：

1.作用：为方法覆盖和多态机制做准备；使代码得到复用（节省代码量）；

2.格式： class 子类 extends 父类

3.理解继承：子类继承父类，其实就相当于把父类的类体中的所有代码（除了构造方法）复制，粘贴到子类的类体里；

4.当一个类没有继承父类时，将默认继承object类，object类为Java语言提供的“ 祖宗 ”类 “；Java中所有类都会直接 / 间接继承object类，因为即使一个类继承了其他父类，但是它的父类或者父类的父类...总会默认继承object类吧；

5.super : 就一个有用的效果---在子类的构造方法中通过super调用上一个父类的构造来初始化属性；

注意：1）super只能出现在构造方法的第一行；

2）当第一行我们没有手动调用super时，系统会默认有一个“ super ( )  ”，目的是在调用子类构造方法时，先对父类属性进行初始化；

3）不管咱在子类构造方法中调不调用super，super总会出现并起作用的，所以父类的无参构造方法一定不能少（否则奖励报错）。在每一个类体中都把无参构造方法写进去也是一个程序员必不可少的习惯；

4）this ( ) 与super ( ) 会冲突，不用细扣，反正 this 就是用来区分同名的形参和实例变量的，你写在构造方法里干嘛，对吧；

辅助代码理解：

class Animal{
    int a;
    String b;
    public Animal() {
    }
    public Animal(int a, String b) {
        this.a = a;
        this.b = b;
    }
    public int getA() {
        return a;
    }
    public void setA(int a) {
        this.a = a;
    }
    public String getB() {
        return b;
    }
    public void setB(String b) {
        this.b = b;
    }
    public void put(){
        System.out.println(a+b);
    }
}

class Panda extends Animal {
//    int a;
//    String b;
    public Panda() {
    }
    public Panda(int a, String b) {
        super(a, b);
    }
//    public int getA() {
//        return a;
//    }
//    public void setA(int a) {
//        this.a = a;
//    }
//    public String getB() {
//        return b;
//    }
//    public void setB(String b) {
//        this.b = b;
//    }
//    public void put(){
//        System.out.println(a+b);
//    }
}

如上代码：因为Panda类继承了Animal类，所以Animal类中除构造方法以外的所有代码（在Panda类体中被注释的代码）都复制粘贴到了Panda的类体中( 隐藏了)，所以说Panda类中看似只有俩个构造方法的代码，但其实被注释掉的代码也相当于它的代码；

注意：

1）Java中只支持单继承，不支持多继承，eg： class A extends  S , Z ( 错误写法) ；

2）除构造方法以外，子类会继承父类中的所有代码；

3）当我们修改了父类类体中的代码（除构造方法外）时，那么直接继承 / 间接继承 它的类中的对应的代码也会发生改变；

4）object类体中有一个方法名为“ toString ”，返回值类型为“ String ”的方法，我们在主方法中创建一个对象后，再利用" System . out . print ( 引用 ) 就可以输出“ toString ”中的返回值；

方法覆盖；

1.作用对象；只会发生在有 直接继承 / 间接继承 关系的俩个类之间；

2.上面提到子类会将父类中除了构造方法以外的所有代码都复制粘贴到子类中，那么粘贴过来的方法可不可以进行重写呢？可以，但是注意：第一，访问权限不能降低，只能升高；第二，返回值类型不能改变；第三，方法名必须相同；第四，参数列表必须相同；

辅助理解代码：

class Animal{
    String a;
    public Animal() {
    }
    public Animal(String a) {
        this.a = a;
    }
    public void put(){
        System.out.println("父类方法执行！");
    }
    public String toString(){
        return "一种动物";
    }
}

class Panda extends Animal {
    public Panda() {
    }
    public Panda(String a) {
        super(a);
    }
    //对父类中的 put 方法进行方法覆盖
    public void put(){
        System.out.println("我就不执行父类方法！我就执行我重写的！");
    }
    //对父类中的 toString 方法进行方法覆盖
    public String toString(){
        return "一只熊猫";
    }
}
public class pra{
    public static void main(String[] args) {
        Animal an=new Animal();
        an.put();//调用此对象的 put 方法
        System.out.println(an.toString());//输出此对象的 toString 方法的返回值
        Panda pa=new Panda();
        pa.put();//调用此对象重写过的 put 方法
        System.out.println(pa.toString());//输出此对象重写之后的 toString 方法的返回值
    }
}

----------------------------------------------
输出结果；

父类方法执行！
一种动物
我就不执行父类方法！我就执行我重写的！
一只熊猫

Process finished with exit code 0

多态机制：

1.概念：使得同一个属性或方法在父类及其各个子类中具有不同的含义；代码体现：父类引用指向子类型对象；

2.Java程序分为编译阶段和运行阶段，就” 通过子类的构造方法创建对象，并用父类的引用数据变量保存对象地址 “谈谈：

编译阶段，编译器会到引用数据类型对应的父类中找（后面子类调用的）构造方法，找到了，静态绑定成功；运行阶段，由于在堆内存创建的是子类的对象，所以运行阶段绑定的是子类的构造方法，动态绑定成功；所以当用” 父类的引用 . “ 的方式调用方法时，实际执行的是子类中的（方法覆盖的）的方法，访问属性也是同理；

3.意义：提高程序的拓展性，降低耦合性；

辅助理解代码；

class Master{
    private String name;
    private Pet pet;
    public Master(){
    }
    public Master(String name){
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Pet getPet() {
        return pet;
    }
    public void setPet(Pet pet) {
        this.pet = pet;
    }
    public void feed(Pet pet){
        pet.eat();
    }
}
class Pet{
    public Pet(){
    }
    public void eat(){
        System.out.println("宠物在吃主人喂的食物");
    }
}
class Dog extends Pet{
    public Dog(){
    }
    public void eat(){
        System.out.println("狗在吃主人喂的狗粮");
    }
}
class Cat extends Pet{
    public Cat(){
    }
    public void eat(){
        System.out.println("猫在吃主人喂的猫粮");
    }
}
//以后张三又喜欢养其他的宠物了，就不需要修改张三的feed方法(多态机制的好处)，只需再添加一个新宠物子类即可
public class 主人喂宠物 {
    public static void main(String[] args){
        Master M=new Master("张三");//创建主人对象-张三
        Pet p1=new Dog();//创建宠物1(静态绑定) 狗(动态绑定)---真正的对象
        Pet p2=new Cat();//创建宠物2(静态绑定) 猫(动态绑定)---真正的对象
        M.setPet(p1);//将张三与小狗关联起来（所属关系）
        M.feed(p1);//通过调用张三的的feed方法来喂小狗
        M.setPet(p2);//将张三与小猫关联起来（现在不养小狗了，养小猫了）
        M.feed(p2);//通过调用张三的的feed方法来喂小猫
    }
}

------------------------------------
输出结果：

狗在吃主人喂的狗粮
猫在吃主人喂的猫粮

Process finished with exit code 0

随笔：

1.参数列表：参数的个数，参数的种类，参数的顺序（不以参数名为准），不包括参数名；

2.向上转型：指的是将子类引用数据类型转换为父类引用数据类型（类比自动类型转换）；

3.向下转型：指的是将父类引用数据类型转换为子类引用数据类型（类比强制类型转换）；

---

由于博主目前还没有将 Java-SE 的知识都学完，所以有些地方可能说的有些片面，若前辈们能够指点一二就更好了      （～￣(OO)￣)ブ