[Java知识库]Java10 继承与多态

Super

public class Student extends Person{
    public Student() {
        super(); //隐藏代码，调用了父类的无参构造，且调用父类的构造器，必须要在子类构造器的第一行
        //当父类没有无参构造，子类无参构造需要显示的定义父类有参
    }


    private String name = "da";

    public void test(String name){
        System.out.println(name); //zhuang
        System.out.println(this.name); //da
        System.out.println(super.name); //wang
    }
}

重写

重写都是方法的重写，和属性无关。

重写：需要又继承关系，子类重写父类的方法！

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大： public > protected > default > private
4. 抛出的异常：范围 可以被缩小，但不能扩大； ClassNotFoundException --> Exception（大）

为什么要重写：父类的功能，子类不一定需要，或者不一定满足。

Alt + Insert ； override；

package com.wang.oop.demo07;
//重写都是方法的重写，和属性无关。
public class A extends B{
    //Override 重写
    @Override //注解：有功能的注释！
    public void test() {
        super.test();
    }
}

多态

动态编译：类型：可扩展性更强；

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

多态注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 （类型转换异常：ClassCastException！）
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();

有些方法不能重写：

1. static 方法，属于类 不属于实例
2. final 常量
3. private 方法

package com.wang.oop;

import com.wang.oop.demo08.Person;
import com.wang.oop.demo08.Student;

public class Application {

    public static void main(String[] args) {

        //一个对象的实际类型是确定的
        //可以指向的引用类型不确定：父类的引用指向子类

        //Student 能调用的方法都是自己的或者继承父类的！
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student(); //Object是所有子类的祖宗类

        // 对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
        s1.eat();
        ((Student)s2).eat(); //强制转换 子类重写了父类的方法，执行子类的方法

    }
}

instanceof 和类型转换

用来测试一个对象是否为一个类的实例，用法为：

boolean result = obj instanceof Class // obj必须是引用类型，不能是基本类型

当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。

注意：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错，如果不能确定类型，则通过编译，具体看运行时定。

package com.wang.oop;

import com.wang.oop.demo06.Teacher;
import com.wang.oop.demo08.Person;
import com.wang.oop.demo08.Student;

public class Application {

    public static void main(String[] args) {

        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student

        Object object = new Student();

        System.out.println(object instanceof Student); //true
        System.out.println(object instanceof Person); //true
        System.out.println(object instanceof Object); //true
        System.out.println(object instanceof Teacher); //false
        System.out.println(object instanceof String); //false

        System.out.println("=========================");
        Person person = new Student();
        System.out.println(person instanceof Student); //true
        System.out.println(person instanceof Person); //true
        System.out.println(person instanceof Object); //true
        // System.out.println(person instanceof String); //编译报错
        
    }
}

x instanceof y

编译能不能通过取决于x与y有没有父子关系；看x引用的左边

结果是true还是false看的是x的子类型是不是y的子类型；即看x引用的右边