java多态

多态

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

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

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

• 多态存在的条件

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

• 注意:多态是方法的多态，属性没有多态性。

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

• 当父类 被 final 修饰了 就不能被子类继承了

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

被以下修饰过的方法不能重写
  1. static静态方法，属于类，它不属于实例
  2. final 常量;
  3. private私有方法;

案例：Person父类

package oop.demo06;
//父类
public class Person {
    public void run(){
        System.out.println("run");
    }
}

案例：Student子类 调用 Person父类 的多态

package oop.demo06;
//子类
public class Student extends Person{

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

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

案例：Application类 测验 Student子类 调用 Person父类 的多态

package oop;
import oop.demo06.Person;
import oop.demo06.Student;

public class Application {
    public static void main(String[] args) {


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

        //可以指向的引用类型就不确定了:父类的引用指向子类
        //Student子类形 能调用的方法都是自己的或者继承父类的!
        Student s1 = new Student();
        //Person父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();//Person类里面有的东西 s2才能用  父类的引用指向子类 Person s2 = new Student();
        Object s3 = new Student();

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

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

被以下修饰过的方法不能重写
  1. static静态方法，属于类，它不属于实例
  2. final 常量;
  3. private私有方法;
  */

案例：instanceof 是否存在关系

Person 父类

package oop.demo06;
//父类
public class Person {
    public void run(){
        System.out.println("run");
    }
}

Student子类

package oop.demo06;
//子类
public class Student extends Person{
}

案例：Application类 验证 Person 与 Student 是否存在关系

package oop;

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

public class Application {
    public static void main(String[] args) {

        //0bject > String
        //0bject > Person > Teacher
        //0bject > Person > Student
        Object object = new Student();

        //System.out.println(X instanceof Y);//能不能编译通过  取决于 X 和 Y 之间是否存在关系  X的指向类型是否是Y的指向类型

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

    }
}

类型转换

Person父类

package oop.demo06;
//父类
public class Person {
    public void run(){
        System.out.println("run");
    }
}

Student子类

package oop.demo06;
//子类
public class Student extends Person{
    public void go(){
        System.out.println("go");
    }

}

子类

package oop.demo06;
//子类
public class Teacher extends Person {
}

案例：引用类型转换

package oop;

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

public class Application {
    public static void main(String[] args) {
        //类型之间的转换： 基本类型转换  高到低 64 32 16 8
        //引用类型转换： 父：高   子：低

        //高          转        低    需强制转换
        Person obj = new Student();
        //obj将这个对象转换为Student类型，我们就可以使student类型的方法了!

        //强制转换
//        Student student =(Student) obj;//(转换的类型)要转换的对象
//        student.go();//调用的方法
        ((Student)obj).go(); //将上面两句写成一句话  (转换的类型)要转换的对象
    }
}

案例：引用类型转换2

package oop;

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

public class Application {
    public static void main(String[] args) {
        //类型之间的转换： 基本类型转换  高到低 64 32 16 8
        //引用类型转换： 父：高   子：低

        Student student =new Student();
        student.go();
        //将student原本类型Student 转换为person类型  低转高 自动转过去了
        Person person = student;//将子类 转换为 父类 可能会丢失一些自己本来的方法  父类的引用指向子类的对象
        //person.go();//丢失go()方法 不能用

    }
}

/*
1.父类引用指向子类的对象
2.把子类转换为父类，向上转型; 自动转换
3.把父类转换为子类，向下转型: 强制转换
4.方便方法的调用，减少重复的代码!简介

 */