Java继承学习随记

Java继承多态学习随记

继承

1. 父类的private修饰无法调用

2. 子类构建时，先构建所继承的父类，再构建子类
   此处隐藏代码super();，默认调用父类的无参构建。此代码必须在构建器的任何一句代码前写。
   若想调用父类的有参构建，得在super();内写上参

3. 调用父类方法或参数使用super关键字，无此关键字遵循就近原则，子类没有向最近的一级父类上找

4. 调用自己类内的参数或方法，使用this关键字。

5. this和super不能同时出现在构建方法里

6. 静态方法：方法的调用只和定义的数据类型有关。
   重写：父类的功能子类不一定需要或不满足 Alt+insert @Override

• 非静态
• 非final
• 非私有
• 方法名、参数列表必须相同
• 修饰符范围可扩大但不能缩小

7. instance of
   A instance of B

• 首先判断A是否能强制转换为B。若真，则可编译。若假，则编译报错。
• 随后判断A是否是B的子类或同类。若真，则true。若假，则false。

多态

一个对象的实际类型是确定的，可以指向的引用类型不确定。父类的引用指向子类的类型，不能调用子类独有的方法，当二者都有这个方法时调用子类的方法。
引用类型指明能够使用哪些方法，而数据类型是确定的。

示例：
Person类

package Demo01;

public class Person {
    private String name;
    private int age;
    private String gender;
    private String address;

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public Person(){
        this.name="name";
        this.age=0;
        this.gender="gender";
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age<0||age>100) {
            System.out.println("Wrong age");
        }
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
    public void work(){
        System.out.println("Doing……");
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

Student类

package Demo01;

public class Student extends Person {
    private String name;
    private int age;
    private int id;
    private String gender;

    public Student() {
        this.name = "name";
        this.age = 0;
        this.id = 0;
        this.gender = "gender";
    }
    public Student(String name, int age, int id, String gender) {
        this.name = name;
        this.age = age;
        this.id = id;
        this.gender = gender;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public void work(){
        System.out.println("Studying……");
    }
}

主函数

package Demo01;

public class test01 {
    public static void main(String[] args) {
       Student s1 = new Student("Britta",18,73,"female");
       Person p1 = new Student("Yeast",18,76,"male");
       s1.setAddress("Nanjing");
       p1.setAddress("Grape");
       System.out.println(s1.getAddress());
       System.out.println(p1.getAddress());
       p1.work();
       s1.work();
    }
}

布丽塔作为一个学生出现，他默认是个人，人的属性都可以调用，但他是学生，所以学生的id也可以使用。
但酵母菌作为一个人，虽然他是学生。他有学生id，但不能被查看（他不愿意使用学生id)（什么）。他是个人，只能调用Person内部的方法，Person里是没有学生id的相关方法的，因而不能被调用，即使他拥有学生id。
这就是引用类型指明能够使用哪些方法，而数据类型是确定的。
也有办法对酵母菌的id进行查看，那就是将酵母菌的类型强制转换成学生。

强制转换

• 父类引用指向子类型的对象
• 子类转为父类，向上转换，没有问题，但可能会丢失一些自己的方法
• 父类转换为子类，需要强制转换
• 便于方法调用