7.java三大特征之一：多态

①封装

将属性和方法书写到类里面的操作就是封装

封装可以为属性和方法添加私有权限

②继承

子类默认继承父类的所有属性和方法

子类可以重写父类属性和方法

③多态

传入不同的对象，产生不同的结果

重写

package extend;
 
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.cry();
    }
 
}
class Animal{
    public Object cry() {
        System.out.println("动物叫");
        return null;
    }
}
class Dog extends Animal{
    public String cry() {
        System.out.println("狗叫");
        return null;
    }
}

重载与重写的区别

多态

对象的多态

引入代码

public class Test {
    public static void main(String[] args) {
        Master master = new Master();
        master.name = "ljw";
        Dog dog = new Dog();
        dog.name = "大黄";
        Bone bone = new Bone("骨头");
        master.feed(dog,bone);
        Cat cat = new Cat();
        cat.name = "tom";
        Fish fish = new Fish("带鱼");
        master.feed(cat,fish);
    }
 
}
class Master{
    String name;
    public void feed(Dog dog,Bone bone){
        System.out.println(name+"给  "+dog.name+" 吃 "+bone.name);
    }
    public void feed(Cat cat,Fish fish){
        System.out.println(name+" 给 "+cat.name+" 吃 "+fish.name);
    }
}
class Food{
    String name;
}
class Bone extends Food{
    String name;
    public Bone(String name){
        this.name = name;
    }
}
class Fish extends Food{
    String name;
    public Fish(String name){
        this.name = name;
    }
}
class Animal{
    String name;
    public Object cry() {
        System.out.println("动物叫");
        return null;
    }
}
class Dog extends Animal{
    public String cry() {
        System.out.println("狗叫");
        return null;
    }
}
class Cat extends Animal{
    public String cry() {
        System.out.println("猫叫");
        return null;
    }
}
 
 
 

编译时类型和运行时类型

Java的引用变量有两个类型，一个是编译时类型，一个是运行时类型，栈中存放的是一些引用和一些变量，而堆内存中存放的是对象。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。

Person p=new Women()(Women类继承自Person类)

假如p的属性修饰符为public 访问属性时得到的是Person类的属性还是Women类的属性，方法调用又是哪个类？

答案：会得到Person类的属性，调用Women类的方法。

编译时类型

编译时，JVM会在栈中静态创建基本数据变量，和引用数据变量的引用，回到刚刚那句代码，显然，p这个引用就是在编译时创建的，那么，p的编译时类型就是Person了。

编译时期可以理解为堆内存中还没有为该对象创建内存，只是在栈中创建了一些基本类型的变量和引用，所以编译时类型就是指在new该对象之前被加载到栈中的属性或方法。

运行时类型

当运行这句java代码时，JVM在堆中为p新建一块内存，对应new Women（）这句代码，所以p的运行时类型就是Women

运行时类型，是指new了一个对象出来，在栈中为该对象分配了内存，此时的运行时类型也就是栈中对象的属性或方法了。

Person person = new student();

这里就可以很好地理解编译时类型和运行时类型了。编译时类型是Person，当new了一个对象之后，堆内存中产生了一个Student对象，此时的类型就是运行时类型，也就是Student类型了。

如果编译时类型和运行时类型不一致，会出现所谓的多态。因为子类其实是一种特殊的父类，因此java允许把一个子类对象直接赋值给一个父类引用变量，无须任何类型转换，

或者被称为向上转型，由系统自动完成。

public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.cry();
    }
}
class Animal{
    public Object cry() {
        System.out.println("动物叫");
        return null;
    }
}
class Dog extends Animal{
    public String cry() {
        System.out.println("狗叫");
        return null;
    }
}

package extend;
 
public class Test {
    public static void main(String[] args) {
        Master master = new Master();
        master.name = "ljw";
        Animal dog = new Dog("大黄");
        Food bone = new Bone("骨头");
        master.feed(dog,bone);
        Animal cat = new Cat("tom");
        Food fish = new Fish("带鱼");
        master.feed(cat,fish);
    }
 
}
class Master{
    String name;
    public void feed(Animal animal,Food food){
        System.out.println(name+"给  "+animal.name+" 吃 "+food.name);
    }
}
class Food{
    String name;
}
class Bone extends Food{
    public Bone(String name){
        this.name = name;
    }
}
class Fish extends Food{
    public Fish(String name){
        this.name = name;
    }
}
class Animal{
    String name;
    public Object cry() {
        System.out.println("动物叫");
        return null;
    }
}
class Dog extends Animal{
    public Dog(String name){
        this.name = name;
    }
    public String cry() {
        System.out.println("狗叫");
        return null;
    }
}
class Cat extends Animal{
    public Cat(String name){
        this.name = name;
    }
    public String cry() {
        System.out.println("猫叫");
        return null;
    }
}
 

向上转型

父类 父类对象 = new 子类();

package extend;
 
public class Test {
    public static void main(String[] args) {
       Animal animal = new Dog();
       animal.cry();
//       animal.a();
    }
 
}
class Animal{
    public void cry() {
        System.out.println("动物叫");
    }
}
class Dog extends Animal{
    public void a() {
        System.out.println("狗叫");
    }
}

向下转型

public class Test {
    public static void main(String[] args) {
       Animal animal = new Dog();
       animal.cry();
       //！！要和         ^^^这个一样
       Dog dog = (Dog) animal;
       dog.a();
    }
 
}
class Animal{
    public void cry() {
        System.out.println("动物叫");
    }
}
class Dog extends Animal{
    public void a() {
        System.out.println("狗叫");
    }
}

java多态中 方法看运行类型 属性看编译类型 方法重写属性不重写

package extend;
 
public class Test {
    public static void main(String[] args) {
       Animal animal = new Dog();
       animal.cry();
       System.out.println(animal.age);
    }
}
class Animal{
    int age = 10;
    public void cry() {
        System.out.println("动物叫");
    }
}
class Dog extends Animal{
    int age = 111;
    public void cry() {
        System.out.println("狗叫");
    }
}

instanceof:看该对象的运行时类型是否为xx类型或他的子类型