多态-＞java

多态

• 动态编译：类型：可扩展性

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

• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

🔴多态存在的条件：

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

注意：多态是方法的多态，属性没有多态性

• **instanceof ** （类型转换） 引用类型

instanceof 判断一个对象是什么类型

package OOP.Demo06;

/**
 * @author 吴某人
 * @PackageName:OOP.Demo06
 * @ClassName:Application
 * @Description:
 * @date 2020/9/10 0010 9:27
 */

public class Application {
    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.run();//子类重写了父类的方法，执行子类的方法
        s1.run();
        //s2.eat();父类不能调用子类独有的方法
        /*强制转换*/((Student) s2).eat();

        System.out.println("*****************************");

        //有继承关系才可以转换比较
        //System.out.println(x instanceof y); 能不能编译通过，取决于x和y有没有父子关系

        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);  编译报错！

        //类型之间的转化： 父             子

        //子类转换为父类，可能丢失之间的本来的一些方法
        Student student =  new Student();
        student.go();
        Person person1 = student;
    }
}
    /*
    1.父类引用指向子类的对象
    2.把子类转换为父类，向上转型
    3.把父类转换为子类，向下转型，强制转换，丢失子类独有的方法
    4.方便方法的调用，减少重复的代码！简洁

    抽象：封装，继承，多态！
     */



package OOP.Demo06;

/**
 * @author 吴某人
 * @PackageName:OOP.Demo06
 * @ClassName:Person
 * @Description:
 * @date 2020/9/10 0010 9:28
 */

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


package OOP.Demo06;

/**
 * @author 吴某人
 * @PackageName:OOP.Demo06
 * @ClassName:Student
 * @Description:
 * @date 2020/9/10 0010 9:29
 */

public class Student extends Person{
    @Override //重载
    public void run() {
        System.out.println("son");
    }

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

    public void go() {

    }
}

/*
    多态注意事项：
    1.多态是方法的多态，属性没有多态
    2.父类和子类,有联系 (类型转换异常！ClassCastException!)
    3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！ father f1 = new son();
       无法重写：
            static 方法，属于类，它不属于实例
            final   常量：
            private 方法：
 */



package OOP.Demo06;

/**
 * @author 吴某人
 * @PackageName:OOP.Demo06
 * @ClassName:Teacher
 * @Description:
 * @date 2020/9/10 0010 10:58
 */

public class Teacher extends Person{

}