java-多态（概念、扩展、转型、示例、多态中成员的特点、）

多态： 可以理解为事物存在的多种体现形态。
人： 男人，女人。
动物： 猫，狗。

猫 x=new 猫();

动物 x=new 猫();//实体类还可以具备其他类型，也就是事物的多种形态

多态如何应用？
 1.多态的体现

            父类的引用指向了自己的子类对象。

           父类的引用也可以接收自己的子类对象。
 2.多态的前提

            必须是类与类之间有关系，要么是继承、要么是实现。

           通常还有一个前提就是存在覆盖。
 3.多态的好处

            多态的出现大大地提高了代码的扩展性。

4.多态的弊端：

          提高了扩展性，但是只能使用父类的引用访问父类中的·成员。；；
 4.多态的应用

（二）：多态的扩展：

/*class Animal{void eat(){}}*/abstract class Animal//不确定动物吃什么，用抽象类{abstract void eat();}class Cat extends Animal{public void eat(){System.out.println("吃鱼");}public void catchMouse(){System.out.println("抓老鼠");}}class Dog extends Animal{public void eat(){System.out.println("吃骨头");}public void KanJia(){System.out.println("看家");}}public class aaaa {public static void main(String [] args){Cat c=new Cat();c.eat();Dog d=new Dog();d.eat();}} 

/*

控制台输出结果：

吃鱼
吃骨头

*/

/* * 动物：猫，狗。 *//*class Animal{void eat(){}}*/abstract class Animal//不确定动物吃什么，用抽象类{abstract void eat();}class Cat extends Animal{public void eat(){System.out.println("吃鱼");}public void catchMouse(){System.out.println("抓老鼠");}}class Dog extends Animal{public void eat(){System.out.println("吃骨头");}public void KanJia(){System.out.println("看家");}}public class aaaa {public static void main(String [] args){/*Cat c=new Cat();c.eat();Dog d=new Dog();d.eat();*/Cat c=new Cat();Cat c1=new Cat();fun(c1);//提高代码的复用性fun(new Dog());//不需要去修改，因为是“重载”。}public static void fun(Cat c){c.eat();}public static void fun(Dog d){d.eat();}} /*控制台输出结果：吃鱼吃骨头*/

/* * 动物：猫，狗。 *//*class Animal{void eat(){}}*/abstract class Animal//不确定动物吃什么，用抽象类{abstract void eat();}class Cat extends Animal{public void eat(){System.out.println("吃鱼");}public void catchMouse(){System.out.println("抓老鼠");}}class Dog extends Animal{public void eat(){System.out.println("吃骨头");}public void KanJia(){System.out.println("看家");}}class Pig extends Animal{public void eat(){System.out.println("饲料");}public void GongDi(){System.out.println("gongdi");}}public class aaaa {public static void main(String [] args){/*Cat c=new Cat();c.eat();Dog d=new Dog();d.eat();*/Cat c=new Cat();Cat c1=new Cat();fun(c1);//提高代码的复用性fun(new Dog());//不需要去修改，因为是“重载”。fun(new Pig());}public static void fun(Cat c){c.eat();}public static void fun(Dog d){d.eat();}public static void fun(Pig p){p.eat();}} 吃鱼吃骨头饲料

//多态的表现
Animal c=new Cat();
c.eat();

Cat d=new Cat();
d.eat();

abstract class Animal//不确定动物吃什么，用抽象类{abstract void eat();}class Cat extends Animal{public void eat(){System.out.println("吃鱼");}public void catchMouse(){System.out.println("抓老鼠");}}class Dog extends Animal{public void eat(){System.out.println("吃骨头");}public void KanJia(){System.out.println("看家");}}class Pig extends Animal{public void eat(){System.out.println("饲料");}public void GongDi(){System.out.println("gongdi");}}public class aaaa {public static void main(String [] args){/*Cat c=new Cat();c.eat();Dog d=new Dog();d.eat();*//*Cat c=new Cat();Cat c1=new Cat();fun(c1);//提高代码的复用性fun(new Dog());//不需要去修改，因为是“重载”。fun(new Pig());*///多态的表现//Animal c=new Cat();//c.eat();//Cat d=new Cat();//d.eat();function(new Cat());function(new Dog());}//提高代码的扩展性：public static void function(Animal a)//Animal a=new Cat();{a.eat();}/*public static void fun(Cat c){c.eat();}public static void fun(Dog d){d.eat();}public static void fun(Pig p){p.eat();}*/} 控制台输出结果：吃鱼吃骨头

（三）多态的转型：

abstract class Animal//不确定动物吃什么，用抽象类{abstract void eat();}class Cat extends Animal{public void eat(){System.out.println("吃鱼");}public void catchMouse(){System.out.println("抓老鼠");}}class Dog extends Animal{public void eat(){System.out.println("吃骨头");}public void KanJia(){System.out.println("看家");}}class Pig extends Animal{public void eat(){System.out.println("饲料");}public void GongDi(){System.out.println("gongdi");}}public class aaaa {public static void main(String [] args){Animal a=new Cat();//类型提升,把猫提升为了动物，也就是向上转型a.eat();//如果想要调用猫的特有方法是，如何提升？//强制将父类的引用，转成子类类型，向下转型Cat c=(Cat)a;c.catchMouse();}public static void function(Animal a)//Animal a=new Cat();{a.eat();}} 控制台输出结果：吃鱼抓老鼠

两种类型的类型转换：
（1）：向上类型转换（Upcast）：将子类型转换为父类型：
       对向上的类型转换，不需要显示指定，即不需要加上前面的小括号和父类类型名。
       //向上类型转换
        Cat cat = new Cat();
        Animal animal = cat;
        animal.sing();
（2）：向下类型转换（Downcast）:将父类型转换为子类型：
       对于向下的类型转换，必须要显式指定，即必须要使用强制类型转换。
       //向下类型转换
        Animal a = new Cat();
        Cat c = (Cat)a;
        c.sing();
        c.eat();
千万不要出现这样的情况，就是将父类对象转成子类类型。

我们能转换的是父类引用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。

多态自始至终都是子类对象在做着变化。

（四）多态的示例：

//多态示例代码public class aaaa{    public static void main(String[] args)    {                //向上类型转换        Cat cat = new Cat();        Animal animal = cat;        animal.sing();                        //向下类型转换        Animal a = new Cat();        Cat c = (Cat)a;        c.sing();        c.eat();        //编译错误        //用父类引用调用父类不存在的方法        //Animal a1 = new Cat();        //a1.eat();                //编译错误        //向下类型转换时只能转向指向的对象类型                //Animal a2 = new Cat();        //Cat c2 = (Dog)a2;    }}class Animal{    public void sing()    {        System.out.println("Animal is singing!");    }}class Dog extends Animal{    public void sing()    {        System.out.println("Dog is singing!");    }}class Cat extends Animal{    public void sing()    {        System.out.println("Cat is singing!");    }    public void eat()    {        System.out.println("Cat is eating!");    }}/*控制台输出结果：Cat is singing!Cat is singing!Cat is eating!*/