Java基础00-继承17

1. 继承

1.1 继承概述

但是我们将相同的类提取出来就会变成这个样子

让他们之间产生一个继承的关系

 

 

1.2 继承的好处和弊端

IS-A、HAS-A和USE-A关系

苹果是水果的一种可以使用继承
猫是动物的一种可以使用继承
猫和狗不具备继承关系，不可以使用继承

1.3 继承中遍变量的访问特点

1.4 super

1.5 继承中构造构造方法的访问特点

子类中所有的构造方法默认都会访问父类中无参的构造方法。

每一个子类构造方法的第一条语句默认都是super()。

1.6 继承中成员方法的访问特点

1.7 super内存图

main方法加载到栈内存

Zi z 加载到main方法中

在堆内存中new一片空间，加载成员变量，Zi z指向001。

将Zi方法加载到栈内存中，然后执行Zi的构造方法，但是执行子类构造方法的时候默认方法中是带super()方法的，所以要先访问父类的构造方法。

 

父类，先将父类的成员变量（它是子类的父类所以它的地址也是001）加载到堆内存空间，然后将父类的构造方法加载到栈内存，执行构造方法，输出，执行完毕后从栈内存消失。

父类的构造方法访问完毕后，接着访问子类的构造方法，输出，然后在栈内存中消失。

接着是z.show()，调用show()方法，在栈内存中加载show，调用者是z(001)，this就是z(001)

int age = 30;.，在栈内存加载。

直接输出age

这次输出的是this.age，而this的地址值是001，所以输出的是20

super.age，同过调用者找到super（父类），从super（父类）找到age，所以输出40。show方法执行完毕从扎内存消失。

接着调用method();方法，但是在子类中并没有。

子类没有method方法，所以我们到父类中找，父类中有method()方法最所以我们调用父类的method方法。

所以执行的是父类的method方法，输出完毕后在栈内存中消失。

1.8 方法重写

方法形参不变，返回值类型可不同（<=小于父类）

1.9 方法重写注意事项

private、final修饰的方法不能被重写。

1.10 Java中继承的注意事项

 1.11 案例

1.11.1 老师和学生

public class Person {
    public String name;
    public int age;

    public Person(){
        System.out.println("父类的构造方法被调用");
    }
}

public class Student extends Person{
    public Student(){
        super();
        System.out.println("Student的构造方法被调用");
    }

    public void study(){
        System.out.println("好好学习");
    }
}

public class Teacher extends Person{
    public Teacher(){
        super();
        System.out.println("Teacher的构造方法被调用");
    }

    public void teach(){
        System.out.println("好好教书");
    }
}

public class TestTeaStu {
    public static void main(String[] args) {
        Teacher t = new Teacher();//父类的构造方法被调用
                                  //Teacher的构造方法被调用
        Student s = new Student();//父类的构造方法被调用
                                      //Student的构造方法被调用
        t.teach();//好好教书
        s.study();//好好学习
    }
}

1.11.2 猫和狗

        

public class Animals {
    private String name;
    private int age;

    public Animals(){
        System.out.println("Animals类的无参构造方法被调用");
    }

    public Animals(String name,int age){
        System.out.println("Animals类的有参构造方法被调用");
    }

    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 class Cat extends Animals {
    public Cat(){
        super();
        System.out.println("Cat类的无参构造方法被调用");
    }

    public Cat(String name,int age){
        super(name,age);
        System.out.println("Cat类的有参构造方法被调用");
    }

    public void getMouse(){
        System.out.println("猫抓老鼠");
    }

    public String toString(){
        return "猫的字符串";
    }
}

public class Dog extends Animals {
    public Dog(){
        super();
        System.out.println("Dog类的无参构造方法被调用");
    }

    public Dog(String name,int age){
        super(name,age);
        System.out.println("Dog类的有参构造方法被调用");
    }

    public void lookGuard(){
        System.out.println("狗看门");
    }
}

public class AnimalDemo{
    public static void main(String[] args) {
        //输出：Animals类的无参构造方法被调用 Cat类的无参构造方法被调用
        Cat c = new Cat();
        //Animals类的有参构造方法被调用
        //Dog类的有参构造方法被调用
        //输出：Animals类的有参构造方法被调用 Dog类的有参构造方法被调用
        Dog d = new Dog("ag",13);
        c.getMouse();//输出：猫抓老鼠
        d.lookGuard();//输出：狗看门
    }
}