day23 多态

多态

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方法。
• 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多。
• 多态存在的条件
  1. 有继承关系
  2. 子类重写父类方法
  3. 父类引用指向子类对象
• 注意：多态是方法的多态，属性没有多态性。

package com.oop.demo06;

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

package com.oop.demo06;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
}
/*
*多态注意事项：
* 1.多态是方法的多态，属性没有多态性（属性是静止的数据，方法是动态的行为）
* 2.父类和子类之间存在联系，否则出现类型转换异常（ClassCastException)
* 3.多态存在条件：要有继承关系，方法需要重写，父类引用指向子类对象！father f1=new son();
* 不能被重写的方法
* 1.static方法，静态方法，属于类，它不属于实例
* 2.final常量；
* 3.private方法
*  */

package com.oop;


import com.oop.demo06.Person;
import com.oop.demo06.Student;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的，new是谁就是谁
        //new Student();
        //new Person();
        //可以指向的引用类型不确定：父类的引用指向子类
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大

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

        s2.run();//son  子类重写了父类的方法，执行子类的方法
        s1.run();//son

    }
}

• instanceof（类型转换） 引用类型，判断一个对象是什么类型

package com.oop;


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

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

        //System.out.println(X instanceof Y);//能否编译通过！XY是否为父子关系


        System.out.println(object instanceof Student);//T
        System.out.println(object instanceof Person);//T
        System.out.println(object instanceof Object);//T
        System.out.println(object instanceof Teacher);//F
        System.out.println(object instanceof String);//F
        System.out.println("==========================================");
        Person person = new Student();
        System.out.println(person instanceof Student);//T
        System.out.println(person instanceof Person);//T
        System.out.println(person instanceof Object);//T
        System.out.println(person instanceof Teacher);//F
        //System.out.println(person instanceof String);//编译报错，因为person和teacher不存在关系
        System.out.println("==========================================");
        Student student= new Student();
        System.out.println(student instanceof Student);//T
        System.out.println(student instanceof Person);//T
        System.out.println(student instanceof Object);//T
        //System.out.println(student instanceof Teacher);//F
        //System.out.println(student instanceof String);//F




    }
}

多态总结

1.父类引用指向子类的对象

2.把子类转换为父类，向上转型，可能会丢失自己本来的方法

3.把父类转换为子类，向下转型；强制转换，可能损失精度

4.方便方法的调用，减少重复的代码，简洁

public class Student extends Person{
    public void go(){
        System.out.println("go");
    }

package com.oop;


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

public class Application {
    public static void main(String[] args) {
        //类型之间的转换：父           子

        //高                    低
       // Student obj = new Student();
        //obj将这个对象转换为Student类型，我们就可以使用Student类型的方法了！
       // ((Student)obj).go();//记住一句话，编译看左，运行看右

        //子类转父类可能会丢失一些方法
        Student student = new Student();
        student.go();
        Person person=student;
    }
}