多态和instanceof

package com.oop.demo06;

/**
 * @ClassName: Person
 * @Author: 南冥有猫不须铭
 * @Date: 2021/4/17-22:27
 * @Description: 多态
 */
public class Person {

    public void run(){
        System.out.println("run");
    }
}


/*
多态注意事项：
1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系    如果无联系强行转换(例：String转Person)会报错： 类型转换异常！ ClassCastException！
3. 存在的条件：继承关系，方法需要重写，父类引用指向子类对象！    Father f1 = new Son();

不能被重写的方法：
    1.static(静态)方法，属于类，它不属于实例
    2.final 常量
    3.private方法：属于私有方法


//一个对象的实际类型是确定的
    //new Student();
    //new Person();

    //可以指向的引用类型就不确定了：父类的引用(类型)指向子类(的对象)

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


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

                //子类有而父类没有的方法，父类的引用调用不了；子类和父类都有的情况下，若子类没有重写父类的方法，就调用父类的方法，而子类重写父类的方法之后，则调用子类方法
                //s2.eat(); //报错
                ((Student) s2).eat();//[alt+/:选eat()] 类型强制转换：把Person类型强制转换成Student类型（高转低）
                s1.eat(); // eat
 */

package com.oop.demo06;

/**
 * @ClassName: Student
 * @Author: 南冥有猫不须铭
 * @Date: 2021/4/17-22:28
 * @Description: 多态
 */
public class Student extends Person {

    @Override
    public void run() {     //方法重写
        System.out.println("son");
    }

    public void eat(){
        System.out.println("eat");
    }

    public void go(){
        System.out.println("go");
    }
}


/*
//System.out.println(X instanceof Y);//能不能编译通过！ 就是看X引用指向的对象是不是Y的子类

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

        System.out.println("=================================");
        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); //编译报错！
 */

package com.oop.demo06;

/**
 * @ClassName: Application
 * @Author: 南冥有猫不须铭
 * @Date: 2021/4/17-22:28
 * @Description: 测试 多态
 */
public class Application {
    public static void main(String[] args) {

        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了：父类的引用(类型)指向子类(的对象)

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


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

        //子类有而父类没有的方法，父类的引用调用不了；子类和父类都有的情况下，若子类没有重写父类的方法，就调用父类的方法，而子类重写父类的方法之后，则调用子类方法
        //s2.eat(); //报错
        ((Student) s2).eat();//[alt+/:选eat()] 类型强制转换：把Person类型强制转换成Student类型（高转低）
        s1.eat(); // eat
    }
}

package com.oop.demo06;

import java.sql.Struct;

/**
 * @ClassName: Application02
 * @Author: 南冥有猫不须铭
 * @Date: 2021/4/20-0:57
 * @Description: 测试 instanceof
 */
public class Application02 {
    public static void main(String[] args) {

        /*
        //System.out.println(X instanceof Y);//能不能编译通过！ 就是看X引用指向的对象是不是Y的子类

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

        System.out.println("=================================");
        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); //编译报错！
        */

        //类型之间的转换： 基本类型转换   （高低64 32 16 8）  /  父  子

        //高                   低
        Person obj = new Student();
        //student.go(); //报错 go()方法只在Student类型中，Person类中没有

        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法了！    高转低-->强制转换
        ((Student) obj).go();
        /*
        Student student = (Student) obj;// Person --> Student   高转低-->强制转换
        student.go();
         */

        //子类转换为父类，可能丢失自己本来的一些方法！
        Student student = new Student();
        student.go();
        Person person = student;// Student 转 Person     低转高，自动转换
        //Person.go(); //报错，go()方法走不了
    }
}

/*多态总结：
1. 父类的引用指向子类的对象（前提）
2. 把子类转换为父类，向上转型；（自动转换）可能丢失方法
3. 把父类转换为子类，向下转型；（强制转换）可能损失精度
4. 方便方法的调用，减少重复的代码！ 简洁

抽象：封装、继承、多态！  ---更抽象--->  抽象类，接口

 */