java多态

多态其实挺好理解的就是一种薛定谔的参数，他的本质是父类可以引用子类的参数来达到一种多形态的样子，举个例子

package com.polymorphism;

public class Animal
{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
class Cat extends Animal
{
    private String name;


    public Cat(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Dog extends Animal
{
    private String name;

    public Dog(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.polymorphism;

public class Food {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
class Fish extends Food
{
    private String name;

    public Fish(String name) {

        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }
}
class Bones extends Food
{
    private String name;

    public Bones(String name) {

        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }
}

​
package com.polymorphism;

public class Master {
    private String name;

    public Master(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String feed(Animal animal, Food food)
    {
        return "主人"+getName()+"给"+animal.getName()+"喂"+food.getName();
    }


}

​

package com.polymorphism;

public class poly01 {
    public static void main(String[] args)
    {
        Dog dog = new Dog("大黄");
        Bones bones = new Bones("猪骨");
        Cat cat = new Cat("小狗");
        Fish fish = new Fish("大鲤鱼");
        Master master = new Master("离不开");
        Pig pig = new Pig("佩奇");
        Rice rice = new Rice("东北大米");
        System.out.println(master.feed(dog,bones));
        System.out.println("======================");
        System.out.println(master.feed(cat,fish));
        System.out.println("======================");

        System.out.println(master.feed(pig,rice));

注意我这里时传的是父类，但这个方法会随着我传入参数调不同的值给出不同效果，这就是多态。

多态的类型

还有向上转型（对子类来说）和向下转型（从向上转回到向下）我不是很明白——为什么不直接new呢？

向上转型前提是有继承关系的

父类的引用指向了子类的运行类型，可以调子类的重写方法，但能调特有的方法，你想呀，我在创建一个鸟对象，写一个特有的飞行，你觉的多态能调用吗？我不可能说传个dog，来调用飞行吧？这非常不合理。

向下转型时子类 xx = （子类）父类引用，其实这些都是看的右边的类型升高还是降低，

注意的点

一—只能改父类引用的地址，里面的对象是改不了的，就相当于你只能改变他家门牌号，但是你无法是他们的水晶爆炸呀，

 

二-向下转型你只能时他只能你转为合适类，就像你String无法变成int类那是一样的，这下面的先向上转的animal他的运行本质时一直毛，现在我使他转成狗，肯定使不合适的，但是这个错误只有在运行使才会说calss ex

package com.Debug;

public class Text {
    public static void main(String[] args)
    {
        Animal animal = new Cat();
        System.out.println(animal.name);//out animal
        animal.run();//
       // animal.sayspring();报错了
        Cat cat = (Cat)animal;
        System.out.println(cat.name);//cat
        cat.sayspring();
        Dog dog = (Dog)animal;
    }
}
class Animal
{
    public String name = "animal";
    public void run()
    {
        System.out.println("animal is running");
    }

}

class Cat extends Animal
{
    public String name = "cat";
    public void run()
    {
        System.out.println("cat is running");
    }
    public void sayspring()
    {
        System.out.println("cat is fXXk");
    }
}

class Dog extends Animal
{
    private String name ="dog";
    public void run()
    {
        System.out.println("dog is running");
    }
    public void eatbonus()
    {
        System.out.println("dog is eating bonus");
    }
}

三—向下转型后，属于回归本质当然你可以使用他的所有，你如果创建一个父类，强行把他转为子类也会报错，所有向上转完向下转。

动态绑定机制就是当（多态的前提下）调用对象是，编译类型左边看属性，运行类型看右边及方法，他的意思是只要运行类型有的方法，你在后面调用时一定调的是运行类型的方法，属性你就不可以那么理解，哪里声明哪里用

举个例子

package com.kaige;

public class Sum {
    int i = 10;
    public int get()
    {
        return get1();//请问这个get1是谁；
    }
    public int get1()
    {
        return i+20;
    }
}

class Sum1 extends Sum
{
    int i = 100;
   /* public int get()//如果我把get删去，他就会找父类的get
    {
        return i+10;
    }*/
    public int get1()
    {
        return i+20;
    }

}

package com.kaige;

public class Text
{
    public static void main(String[] args)
    {
        Sum1 sum1 = new Sum1();
        System.out.println(sum1.get());
        System.out.println(sum1.get1());

    }
}

如果我不注销掉get方法所有人都会知道他调用的是sum1的方法，答案使

110

120

但是现在我调用了父类的get方法，它里面的get1方法是谁的呢？

答案就是还是子类的get方法因为，动态绑定机制——当调用对象方法使就会发生绑定，如果使对象有的，哪怕父类有重写的方法也会调对象。课属性就是那里声明哪里用。

多态的应用 

简单来说就是创建父类数组，然后根据你的需求来确定你要哪种子类，要父类也行

应用就是看我的idea里的polyarr，会用就行，不过初始化会麻烦一点点，也没啥好注意的。

我们常用instanceof来判断两个类的关系

具体用法如下

persons[k] instanceof Person;//会用就行

多态参数就是前面说的薛定谔的参数，跟第一个例子差不多。