多态

1、多态的含义：多态是指对象的不同状态，编译时是一种（父类）状态，运行时又是另外一种（子类）状态，多态具体实在在子类继承父类的这一过程中。

2、为什么要用多态：多态是当子类继承父类时，当父类要使用到子类的属性和方法时，就能体现多态的特性，父类可以借助子类拓展自己的属性和特征姿态

3、多态的前提： 类与类之间有继承关系，且父类需要调用子类的方法和属性

4、父类引用子类对象： father  f =  new son();

5、向上转型：当父类引用子类对象时，f 可以调用 father 类里的方法和属性，称为向上转型，且是自动转换

6、向下转型：当父类引用子类对象时，如果子类没有重写父类的方法，是自己独有的方法时，f 不可以调用 son 类里的方法，

　  f 必须向下转型成son类型，才能调用子类属性和方法，是强制转换， son s = （son）f;

a.案例一：向下转型

package src;

class father{
    int i ;
    public void fa()
    {
        System.out.println("I AM father!");
    }
}

class son extends father{
    int j ;
    public void a()
    {
        System.out.println("I AM son");
    }

    public void b()
    {
        System.out.println("I AM father,I can use my son method!");
    }

    //子类重写父类的fa方法
    @Override
    public void fa()
    {
        System.out.println("I AM override father fa() method!");
    }
}

public  class date4  {
   public static void main(String[] args){
       //定义一个父类（father）类型的 f 引用子类（son）对象
        father f = new son();
       //父类的引用可以调用父类的属性i和fa(),当子类重写父类的fa()方法,则调用的是子类的fa()方法
       System.out.println("我是父类属性"+":"+(f.i=20));
       //子类重写父类的fa()方法,父类的引用可以直接调用子类重写的fa()方法
       f.fa();
       //父类引用调用子类独有的的属性和方法前，需要强转成son类型
       son g = (son) f;
       System.out.println("我是父类调用子类属性，并赋值"+":"+(g.i=30));
       g.a();
       g.b();

   }
}

运行结果：

我是父类属性:20
I AM override father fa() method!
我是父类调用子类属性，并赋值:30
I AM son
I AM father,I can use my son method!

　　

b.案例二：利用多态的设计原理，定义一个主人类master、宠物类pet、喂养feed类，实现主人喂宠物的一个场景，其中宠物类有dog、cat、snake。

方法1：未使用多态实现

public class duotai {
    public static void main(String[] args) {
        master zhangsan = new master();
        dog zangAo = new dog();
        cat boSiMao = new cat();
        snake python  = new snake();
        zhangsan.feed(zangAo);
        zhangsan.feed(boSiMao);
        zhangsan.feed(python);

    }
}


class master
{

    public void feed (dog d)
    {
        d.eat();
    }

    public void feed (cat c)
    {
        c.eat();
    }

    public void feed (snake s)
    {
        s.eat();
    }
}

class dog {
    public void eat()
    {
        System.out.println("喂养狗狗吃骨头");
    }
}


class cat {
    public void eat()
    {
        System.out.println("喂养猫吃猫粮");
    }
}


class snake {
    public void eat()
    {
        System.out.println("喂养蛇吃青蛙");
    }
}

运行结果：
        喂养狗狗吃骨头
        喂养猫吃猫粮
        喂养蛇吃青蛙

                

方法2：利用多态

public class main {
    public void main(String[] args) {
        Master person = new Master();
        person.feed(new Dog());
        person.feed(new Cat());
        person.feed(new Snake());

    }
}

class Master {
    public void feed (Feed f ) {
        f.eat();
    }
}

interface Feed {//多态接口，宠物都有吃的行为
     void eat();
}

class Dog implements Feed  {
    @Override
    public void eat()
    {
        System.out.println("喂养狗狗吃骨头");
    }

}

class Cat implements Feed  {
    @Override
    public void eat()
    {
        System.out.println("喂养猫猫吃猫粮");
    }
}

class Snake implements Feed  {
    @Override
    public void eat()
    {
        System.out.println("喂养蛇吃青蛙");
    }
}

运行结果：

喂养狗狗吃骨头
喂养猫猫吃猫粮
喂养蛇吃青蛙