Java面向对象------《多态》

多态

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

例如：你的女盆友让你买点水果回来，不管买回来的是苹果还是西瓜，只要是水果就行，这个就是多态

---

• 多态存在的条件：
  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象

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

父类引用指向子类对象，如：Person p = new Student();

多态中，编译看左边，运行看右边

---

代码示例：

Application:

package com.oop;

import com.oop.Demo07.Person;
import com.oop.Demo07.Student;

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

//      一个对象的实际类型是确定的
//      new Student();例如：new 一个Student那就是Student  下Person同
//      new Person();

//        但可以指向的引用类型就不确定了---父类的引用指向子类

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

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        /*
        例如
        s2.eat()会报错，因为Person中没有eat的方法
        但是s1.eat不会报错
         */

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

Person：

package com.oop.Demo07;

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

Student：

package com.oop.Demo07;

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

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

运行结果：

son
son

多态注意事项

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 ， 类型转换异常！ ClassCastException!
3. 存在条件： 继承关系 ；方法需要重写 ；父类引用指向子类对象！

不能重写：

1. static 方法，属于类，它不属于实例
2. final 常量；
3. private方法；

instanceof 类型转换（引用类型）

判断一个对象是什么类型

	### 转换讲解代码：

Application：

package com.oop;


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

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

//        System.out.println(X instanceof 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);//编译报错，因为Person与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 com.oop.Demo07;

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

Student：

package com.oop.Demo07;

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

Teacher：

package com.oop.Demo07;

public class Teacher extends Person{

}

运行结果：

true
true
true
false
false
----------------
true
true
true
false
----------------
true
true
true

代码示例：

Application：

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

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

        //高                     低
        Person student = new Student();

        //student 将这个对象转换为Student类型，我们就可以使用Student类型的方法了！
        ((Student)student).go();//父亲不能直接拿儿子的方法，所以父亲得先装儿子才行，也就是向下转换，强制转换

        //子类转换为父类可能会丢失自己本来的一些方法
        Student student1 = new Student();
        student1.go();
        Person person = student;
//        person.go();//编译报错
    }
}

Person：

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

Student：

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

1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转换
3. 把父类转换为子类，向下转换：强制转换（子类可能会丢失自身的方法）
4. 方便方法的调用，减少重复的代码！简洁