6 Java基础 多态

/*

多态：可以理解为事物存在的多种体现形态

 

人：男人 女人 动物：猫 狗

 

猫 x=new 猫（）;

 

动物 x=new 猫（）;

 

对象函数都有多态的体现

 

1多态的基本体现

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

父类的引用也可以接受自己的子类对象

2多态的前提

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

通常还有一个前提 就是存在覆盖

3多态的好处

多态的出现大大的提高了程序的扩展性。

4多态的弊端

提高了扩展性但是只能够使用父类的引用访问父类中的成员

5多态的应用

 

*/

 

/*

动物

猫，狗

*/

abstract class Animal

{

         abstractvoid eat();//抽象

}

class Cat extends Animal

{

         publicvoid eat()

         {

                   System.out.println("吃鱼");

         }

         publicvoid catchMouse()

         {

                   System.out.println("抓老鼠");

         }

}

class Dog extends Animal

{

         publicvoid eat()

         {

         System.out.println("吃骨头");

         }

         publicvoid kanjia()

         {

                   System.out.println("看家");

         }

}

 

 

class Pig extends Animal

{

         publicvoid eat()

         {

                   System.out.println("饲料");

         }

         publicvoid gongDi()

         {

                   System.out.println("拱地");

         }

}

 

/********************************/

class Duotaidemo

{

         publicstatic void main(String[] args)

         {

                   //Catc=new Cat();

                   //c.eat();

                   //Dogd=new Dog();

                   //d.eat();

                   /*Catc=new Cat();

                   Catc1=new Cat();

                   function(c1);

                   function(newDog());

                   function(newPig());*/

                   //Animalc=new Cat();

                   //c.eat();

                   function(newCat());

                   function(newDog());

                   function(newPig());

                  

         }

         publicstatic void function(Animal a )//提高代码扩展性后期再加一个动物也不需再加代码

                   {                                      //Animal c=new Cat();

                   a.eat();

         }

         /*

         publicstatic void function(Cat c)//提取共同点 吃

         {

                   c.eat();

         }

         publicstatic void function(Dog d)

         {

                   d.eat();

         }

         publicstatic void function(Pig p)

         {

                   p.eat();

         }

         */

}

 

/********************************/

class Duotaidemo2

{

         publicstatic void main(String[] args)

         {

                  

                   Animala=new Cat();//类型提升，向上转型。

                   a.eat();

                   //如果想要调用猫的特有方法时 如何操作？

                   Catc=(Cat)a;   //强制将父类的引用转成子类类型 向下转型

                   c.catchMouse();

                   //千万不要出现这样操作 就是将父类对象转成子类类型

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

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

 

                  

         }

         publicstatic void function(Animal a )//提高代码扩展性后期再加一个动物也不需再加代码

         {                                      //Animal c=newCat();

                   a.eat();

                   /*if(a instanceof Animal)

                   {

                            System.out.println("ss");

                   }

                   else*///Animal属于父类 不要传父类判断 因为只要是父类肯定满足 下面都执行不到了

                   if(a instanceof Cat)//instanceof 关键字判断

                   {

                            Catc=(Cat)a;  

                            c.catchMouse();

                   }

         }

                   elseif (a instanceof Dog)

                   {

                            Dogc=(Dog)a;

                            c.kanjia();

                   }

        

}

 

 

 

class Fu

{

         voidmethod1()

         {

                   System.out.println("fumethod_1");

         }

         voidmethod2()

         {

                   System.out.println("fumethod_2");

         }

}

 

class Zi extends Fu

{

         voidmethod1()

         {

                   System.out.println("zimethod_1");

         }

         voidmethod3()

         {

                   System.out.println("zimethod_3");

         }

}

class Duotaidemo3

{

         publicstatic void main(String[] args)

         {

                   Fuf=new Zi();

                   f.method1();//被子类覆盖

                   f.method2();//继承父类

                   //f.method3();//父类中没有method3

                            /*在多态中成员函数（非静态）的特点：

                            在编译时期：参阅引用型变量所属的类中是否有调用的方法 如果有 编译通过 如果没有编译失败

                            运行时期 ：参与对象所属的类中是否有调用的方法

                            简单的总结是：成员函数在多态调用时 编译看左边 运行看右边

                            在多态中成员变量的特点：无论编译和运行都参考左边（引用型变量所属的类）

                            在多态中 静态成员函数的特点 无论编译和运行 都参考左边

 

                            */

                            Ziz=new Zi();

                            z.method1();//子类覆盖父类

                            z.method2();//继承父类

                            z.method3();//子类特有

         }

}

 

//   面试

class Fu

{

         intnum=5;//面试

         voidmethod1()

         {

                   System.out.println("fumethod_1");

         }

         voidmethod2()

         {

                   System.out.println("fumethod_2");

         }

         staticvoid method4()

         {

                   System.out.println("fumethod_4");

         }

}

 

class Zi extends Fu

{

         intnum=8;

         voidmethod1()

         {

                   System.out.println("zimethod_1");

         }

         voidmethod3()

         {

                  System.out.println("zimethod_3");

         }

 static      voidmethod4()

         {

                   System.out.println("zimethod_4");

         }

}

class Duotaidemo4

{

         publicstatic void main(String[] args)

         {

                   //Fuf=new Zi();

                   //System.out.println(f.num);

                   //Ziz=new Zi();

                   //System.out.println(z.num);

 

                   Fuf=new Zi();

                   f.method4();//静态不能被覆盖

 

              Zi z=new Zi();

                    z.method4();

        

 

        

 

                  

                            /*在多态中成员函数（非静态）的特点：

                            在编译时期：参阅引用型变量所属的类中是否有调用的方法 如果有 编译通过 如果没有编译失败

                            运行时期 ：参与对象所属的类中是否有调用的方法

                           

                            简单的总结是：成员函数在多态调用时 编译看左边 运行看右边

面试：    

                            在多态中成员变量的特点：

                            无论编译和运行都参考左边（引用型变量所属的类）

                           

                            在多态中 静态成员函数的特点 ：

                            无论编译和运行 都参考左边

 

                            */

                  

         }

}

 

 

 

/*

 

 

 

 

*/

interface PCI

{

         publicvoid open();

         publicvoid close();

}

class Mainboard

{

         publicvoid run()

         {

                   System.out.println("mainboardrun");

         }

         publicvoid usePCI(PCI p)//PCI p=new Netcard //接口型引用指向自己的子类对象

         {

                   if(p!=null)

                   {

                            p.open();

                      p.close();

             }

                  

         }

}

class Netcard implements PCI

{

         publicvoid open()

         {

                   System.out.println("netcardopen");

         }

         publicvoid close()

         {

                   System.out.println("netcardclose");

         }

 

}

 

class Soundcard implements PCI

{

        

         publicvoid open()

         {

                   System.out.println("soundcardopen");

         }

         publicvoid close()

         {

                   System.out.println("soundcardclose");

         }

}

/*

电脑运行

主板

 

*/

 

 

/*

class Mainboard

{

         publicvoid run()

         {

                   System.out.println("mainboardrun");

         }

         publicvoid useNetcard (Netcard c)

         {

                   c.open();

                   c.close();

         }

}

class Netcard

{

         publicvoid open()

         {

                   System.out.println("netcardopen");

         }

         publicvoid close()

         {

                   System.out.println("netcardclose");

         }

 

}

*/

class Duotaidemo5

{

         publicstatic void main(String[] args)

         {

                   Mainboardmb=new Mainboard();

                   mb.run();

                   mb.usePCI(null);

       mb.usePCI(new Netcard());

             mb.usePCI(new Soundcard());

 

 

 

                   //mb.useNetcard(newNetcard ());

         }

}