多态的好处和弊端


A：多态的好处 

a：提高了代码的维护性(继承保证)
b：提高了代码的扩展性(由多态保证)
B：案例演示 

多态的好处
可以当作形式参数,可以接收任意子类对象
C：多态的弊端

不能使用子类的特有属性和行为。

class Demo04_Animal {
    public static void main(String[] args) {
        //Cat c1 = new Cat();
        //c1.eat();
        method(new Cat());
        method(new Dog());

        //开发中很少在创建对象的时候用父类引用指向子类对象
        //直接创建子类对象更方便,可以使用子类中的特有属性和行为
        //Animal a = new Cat();
    }

    //Cat c = new Dog();狗是一只猫,这是错误的
    /*public static void method(Cat c) {            
        c.eat();
    }

    public static void method(Dog d) {
        d.eat();
    }*/

    //如果把狗强转成猫就会出现类型转换异常,ClassCastException
    public static void method(Animal a) {   //当作参数的时候用多态最好,因为扩展性强
        //关键字 instanceof 判断前边的引用是否是后边的数据类型
        //开发中很少这样做，一般都是父类具有方法A，子类重写方法A，然后把父类类型作为参数，子类传递进去
        //如果想调用子类特有的方法，就必须强转之后才能去使用
        if (a instanceof Cat) {
            Cat c = (Cat)a;
            c.eat();
            c.catchMouse();
        }else if (a instanceof Dog) {
            Dog d = (Dog)a;
            d.eat();
            d.lookHome();
        }else {
            a.eat();
        }
    }
}

class Animal {
    public void eat() {
        System.out.println("动物吃饭");
    }
}

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 lookHome() {
        System.out.println("看家");
    }
}

转载自：

java8-3 多态的好处和弊端以及多态的理解
多态的好处：
A:提高了代码的维护性(继承保证)
B:提高了代码的扩展性(由多态保证)

猫狗案例代码


class Animal {
    public void eat(){
        System.out.println("eat");
    }
    
    public void sleep(){
        System.out.println("sleep");
    }
}

class Dog extends Animal {
    public void eat(){
        System.out.println("狗吃肉");
    }
    
    public void sleep(){
        System.out.println("狗站着睡觉");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
    
    public void sleep() {
        System.out.println("猫趴着睡觉");
    }
}

class Pig extends Animal {
    public void eat() {
        System.out.println("猪吃白菜");
    }
    
    public void sleep() {
        System.out.println("猪侧着睡");
    }
}

//针对动物操作的工具类
class AnimalTool {
    private AnimalTool(){}

    /*
    //调用猫的功能
    public static void useCat(Cat c) {
        c.eat();
        c.sleep();
    }
    
    //调用狗的功能
    public static void useDog(Dog d) {
        d.eat();
        d.sleep();
    }
    
    //调用猪的功能
    public static void usePig(Pig p) {
        p.eat();
        p.sleep();
    }
    */
    public static void useAnimal(Animal a) {
        a.eat();
        a.sleep();
    }
    //把所有的可能都归为动物类
}

class DuoTaiDemo2 {
    public static void main(String[] args) {
        //我喜欢猫，就养了一只
        Cat c = new Cat();
        c.eat();
        c.sleep();
        
        //我很喜欢猫，所以，又养了一只
        Cat c2 = new Cat();
        c2.eat();
        c2.sleep();
        
        //我特别喜欢猫，又养了一只
        Cat c3 = new Cat();
        c3.eat();
        c3.sleep();
        //...
        System.out.println("--------------");
        //问题来了,我养了很多只猫，每次创建对象是可以接受的
        //但是呢?调用方法，你不觉得很相似吗?仅仅是对象名不一样。
        //我们准备用方法改进
        //调用方式改进版本
        //useCat(c);
        //useCat(c2);
        //useCat(c3);
        
        //AnimalTool.useCat(c);
        //AnimalTool.useCat(c2);
        //AnimalTool.useCat(c3);
        
        AnimalTool.useAnimal(c);
        AnimalTool.useAnimal(c2);
        AnimalTool.useAnimal(c3);
        System.out.println("--------------");
        
        //我喜欢狗
        Dog d = new Dog();
        Dog d2 = new Dog();
        Dog d3 = new Dog();
        //AnimalTool.useDog(d);
        //AnimalTool.useDog(d2);
        //AnimalTool.useDog(d3);
        AnimalTool.useAnimal(d);
        AnimalTool.useAnimal(d2);
        AnimalTool.useAnimal(d3);
        System.out.println("--------------");
        
        //我喜欢宠物猪
        //定义一个猪类，它要继承自动物，提供两个方法，并且还得在工具类中添加该类方法调用
        Pig p = new Pig();
        Pig p2 = new Pig();
        Pig p3 = new Pig();
        //AnimalTool.usePig(p);
        //AnimalTool.usePig(p2);
        //AnimalTool.usePig(p3);
        AnimalTool.useAnimal(p);
        AnimalTool.useAnimal(p2);
        AnimalTool.useAnimal(p3);
        System.out.println("--------------");
        
        //我喜欢宠物狼，老虎，豹子...
        //定义对应的类，继承自动物，提供对应的方法重写，并在工具类添加方法调用
        //前面几个必须写，我是没有意见的
        //但是，工具类每次都改，麻烦不
        //我就想，你能不能不改了
        //太简单：把所有的动物都写上。问题是名字是什么呢?到底哪些需要被加入呢?
        //改用另一种解决方案。
        
    }
    
    /*
    //调用猫的功能
    public static void useCat(Cat c) {
        c.eat();
        c.sleep();
    }
    
    //调用狗的功能
    public static void useDog(Dog d) {
        d.eat();
        d.sleep();
    }
    */
}

多态的弊端：

不能使用子类的特有功能。


我就想使用子类的特有功能?行不行?

行。


怎么用呢?

A:创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)

B:把父类的引用强制转换为子类的引用。(向下转型)


对象间的转型问题：

向上转型：

Fu f = new Zi();

向下转型：

Zi z = (Zi)f; //要求该f必须是能够转换为Zi的.(所属关系)

多态的问题理解：

class 孔子爹 {

public int age = 40;


public void teach() {

System.out.println("讲解JavaSE");

}

}


class 孔子 extends 孔子爹 {

public int age = 20;


public void teach() {

System.out.println("讲解论语");

}


public void playGame() {

System.out.println("英雄联盟");

}

}


//Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了

//但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?

//然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹

//向上转型

孔子爹 k爹 = new 孔子();

//到人家那里去了

System.out.println(k爹.age); //40

k爹.teach(); //讲解论语

//k爹.playGame(); //这是儿子才能做的



//讲完了，下班回家了

//脱下爹的装备，换上自己的装备

//向下转型

孔子 k = (孔子) k爹; 

System.out.println(k.age); //20

k.teach(); //讲解论语

k.playGame(); //英雄联盟


2、向下转型中有可能的异常：

ClassCastException:类型转换异常

一般在多态的向下转型中容易出现

面向对象多态的好处和弊端


优点

1.提高代码的维护性（由继承保证）：上面修改了下面也跟着修改。

2.提高了代码的延展性（由多态保证）。

3.可以当做形式参数，可以接受任何类型的子类对象。


缺点

不能使用子类特有的属性和行为


关键字instanceof的介绍

instanceof:为了判断引用是否是后面的数据类型

如果想使用子类特有的属性和行为，就要强转之后再使用。否则，就会出现类型转化异常ClassCastException。


运用到instanceof通常的写法
public static void method(父类 a) {				//创建静态的方法
       		 if (a instanceof 子类1) {  					//如果a是子类1
                 子类1 z  = (子类) a;						//将父类a强制转化子类1
                 c.子类特有方法1 ( );	
                 c.子类的方法 ( );
             } 
             else if (a instanceof 子类2) {					//如果a是子类2同上
                 Dog3 d = (Dog3) a;
                 a.eat ( );
                 a.lookHouse ( );
             } 
             else {											//否则调用父类自己的行为
                 a.eat ( );
             }
         }



以猫狗类为例说明延展性代码如下
public class Demo3_Animal {
   public static void main(String[] args) {
       //Cat3 c = new Cat3();
       //c.eat ();
       method (new Cat3 ( ));
       method (new Dog3 ( ));
       //Animal3 a = new Cat3();开发中很少这样写，父类引用子类对象没有好处，直接创建子类对象更方便可以直接使用子类中的特有方法

   }

   /*public static void method(Cat3 c){			//这样写太麻烦了
       c.eat ();
   }
   public static void method(Dog3 d){
       d.eat ();
   }*/
   public static void method(Animal3 a) {		//通常这样写，当作参数的时候这样写最好，再来一个猪类都可以只要属于动物类都行。
      //如果强制把猫类型转换成狗类型就会出现类型转化异常ClassCastException
 		 if (a instanceof Cat3) {  //缺点不能调用子类特有的方法
           Cat3 c = (Cat3) a;
           c.catchMouse ( );
           c.eat ( );
       } else if (a instanceof Dog3) {
           Dog3 d = (Dog3) a;
           a.eat ( );
           ((Dog3) a).lookHouse ( );
       } else {
           a.eat ( );
       }
   }
}

class Animal3 {
   public void eat() {
       System.out.println ("吃饭");
   }
}

class Cat3 extends Animal3 {
   public void eat() {
       System.out.println ("猫吃鱼");
   }

   public void catchMouse() {
       System.out.println ("抓老鼠");
   }
}

class Dog3 extends Animal3 {
   public void eat() {
       System.out.println ("狗吃肉");
   }

   public void lookHouse() {
       System.out.println ("狗看家");
   }
}

结果
抓老鼠
猫吃鱼
狗吃肉
看家

多态的好处和弊端以及对象的向上转型和向下转型
什么是多态

多态：

多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

多态的好处

提高了代码的可维护性（继承保证）；
提高了代码的扩展性(由多态保证)；
无论右边new的时候换成哪个子类对象，等号左边调用方法都不会变化；

多态性：父类引用指向子类对象；
格式：
            父类名称 对象名 = new 子类名称（）；
            接口名称 对象名 = new 实现类名称（）；

**多态内的成员变量特点：

直接通过对象名访问，等号左边(父类/接口)是谁，优先用谁，否则向上找（object）。
间接通过成员方法访问，方法是谁，则优先用谁。

访问成员方法：

new的是谁，则优先用谁。口诀（编译看左边，运行看右边）

**
//父类
public class Fu {
    public void teach(){
        System.out.println("父亲教java");
    }
}

//子类
public class Zi extends Fu{
    @Override
    public void teach() {
        System.out.println("儿子教python");
    }

    public void playGame(){
        System.out.println("儿子玩游戏");
    }
}

//main
public class Main {
    public static void main(String[] args) {

        //对象向上转型
        Fu fu = new Zi();//多态
        fu.teach();
        //fu.playGame() --错误，因为父类没有该方法，是无法指向子类的方法的

        /*[把父类的引用强制转换为子类的引用。(向下转型)]
        解释：当我们使用多态方式调用方法时，首先检查父类中是否有该方法，
        如果有，再去调用子类的同名方法；如果没有，则会编译错误。*/

        System.out.println("============分割线============");

        //我就想使用子类的特有功能?行不行?--行 ===>>>> 对象向下转型
        Zi zi = (Zi) fu;
        zi.playGame();
        zi.teach();
    }
}

向下转型中有可能的异常：

ClassCastException:类型转换异常 ,一般在多态的向下转型中容易出现