多态

1 概述

• 同一方法可以根据发送对象的不同而采用不同的行为方式
• 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多

存在条件

• 有继承关系
• 子类重写父类方法
• 父类引用指向子类对象

PS：

• 多态是方法的多态，属性没有多态
• 多态存在条件，方法需要重写，否则没啥意义，都调用各自的方法还有啥多态

2 实例

2.1 例1-多态

package com.oop;

public class Main {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student()
        //new Person()

        //可以指向的引用类型就不确定了，父类引用指向子类
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();
        s1.run();
        s2.run();//子类重写了父类的方法,执行子类的方法

    }

}

PS：

• 不能随意指定 指向的引用类型，两者要有关系
• 父类引用：子类没有重写父类的方法，调用父类；子类重写，调用子类

2.2 例2

package com.oop;

public class Main {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student()
        //new Person()

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

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
        //s2.eat();//父类无法调用子类的方法
        s1.eat();

    }

}

3 总结

3.1 多态注意事项

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

3.2 无法被重写的方法

1. static 方法，属于类，它不属于实例
2. 被 final 修饰的方法
3. 被 private 修饰方法

4 类型转换

4.1 instanceof

instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

• 左边是对象，右边是类；当对象是右边类或子类所创建对象时，返回true；否则，返回false。

4.2 实例 1

Teacher 继承 Person 类，其余跟 例1 一致。

package com.oop;

public class Main {
    public static void main(String[] args) {
        //Object -> String
        //Object -> Person  ->  Teacher
        //Object -> String  ->  Student
        Object obj = new Student();

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

}

4.3 实例 2

package com.oop;

public class Main {
    public static void main(String[] args) {
        //Object -> String
        //Object -> Person  ->  Teacher
        //Object -> Person  ->  Student
        Object obj = new Student();

        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 Teacher);//false
        //System.out.println(person instanceof String);//编译报错

    }

}

PS：同级无法进行编译和转换的。如 String 和Person 就是同级

4.4 实例3

package com.oop;

public class Main {
    public static void main(String[] args) {
        //Object -> String
        //Object -> Person  ->  Teacher
        //Object -> Person  ->  Student
        
        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher);//编译报错
        //System.out.println(student instanceof String);//编译报错

    }

}

PS：能不能编译通过，是看是否有父子关系

4.5 强制类型转换

package com.oop;

public class Main {
    public static void main(String[] args) {
        //Object -> String
        //Object -> Person  ->  Teacher
        //Object -> Person  ->  Student

        //类型之间的转换：  父  ---  子

        //高-->低 ：强制转换   低--->高 : 自动转换
        Person person = new Student();
        //将 Student 对象 person 转换为Student类型，就可以使用Student类型的方法了

        Student student=(Student)person;//第一种转换方法-强制
        //((Student)person).eat();//第二种转换方法-强制
        student.eat();
    }

}

4.6 自动类型转换

子类转换父类，可能会丢失子类方法

package com.oop;

public class Main {
    public static void main(String[] args) {
        //Object -> String
        //Object -> Person  ->  Teacher
        //Object -> Person  ->  Student

        //类型之间的转换：  父  ---  子
        //低--->高 : 自动转换
        Student stu=new Student();
        stu.eat();
        Person person=stu;
        //person.eat();//编译报错，丢失子类方法
    }

}

5 总结-类型转换

1. 父类引用指向子类的对象
2. 将 子类转换为父类，向上转型 --> 自动转换
3. 将 父类转换为子类，向下转型 --> 强制转换

PS：

面向对象的本质：以类的方式组织代码，以对象的组织(封装)数据。