264、Java基础40 - 接口与继承【多态】 2019.11.18

1、多态

• 操作符的多态

+ 可以作为算数运算，也可以作为字符串连接 

• 类的多态
  父类引用指向子类对象

2、操作符的多态

同一个操作符在不同情境下，具备不同的作用
如果+号两侧都是整型，那么+代表 数字相加
如果+号两侧，任意一个是字符串，那么+代表字符串连接

package charactor;
   
public class Hero {
    public String name;
    protected float hp;
 
    public static void main(String[] args) {
         
        int i = 5;
        int j = 6;
        int k = i+j; //如果+号两侧都是整型，那么+代表 数字相加
         
        System.out.println(k);
         
        int a = 5;
        String b = "5";
         
        String c = a+b; //如果+号两侧，任意一个是字符串，那么+代表字符串连接
        System.out.println(c);
         
    }
       
}

3、观察类的多态现象

观察类的多态现象：

1. i1和i2都是Item类型
2. 都调用effect方法
3. 输出不同的结果

多态: 都是同一个类型，调用同一个方法，却能呈现不同的状态

• Items.java

package property;
 
public class Item {
    String name;
    int price;
 
    public void buy(){
        System.out.println("购买");
    }
    public void effect() {
        System.out.println("物品使用后，可以有效果 ");
    }
     
    public static void main(String[] args) {
        Item i1= new LifePotion();
        Item i2 = new MagicPotion();
        System.out.print("i1  是Item类型，执行effect打印:");
        i1.effect();
        System.out.print("i2也是Item类型，执行effect打印:");
        i2.effect();
    }
 
}

• LifePotion.java

package property;
 
public class LifePotion extends Item {
    public void effect(){
        System.out.println("血瓶使用后，可以回血");
    }
}

• MagicPotion.java

package property;
 
public class MagicPotion extends Item{
 
    public void effect(){
        System.out.println("蓝瓶使用后，可以回魔法");
    }
}

4、类的多态条件

要实现类的多态，需要如下条件

1. 父类（接口）引用指向子类对象
2. 调用的方法有重写
   那么多态有什么作用呢？ 通过比较不使用多态与使用多态来进一步了解

5、类的多态-不使用多态

如果不使用多态，
假设英雄要使用血瓶和魔瓶，就需要为Hero设计两个方法
useLifePotion
useMagicPotion

除了血瓶和魔瓶还有很多种物品，那么就需要设计很多很多个方法，比如
usePurityPotion 净化药水
useGuard 守卫
useInvisiblePotion 使用隐形药水
等等等等

package charactor;
 
import property.LifePotion;
import property.MagicPotion;
   
public class Hero {
    public String name;
    protected float hp;
 
    public void useLifePotion(LifePotion lp){
        lp.effect();
    }
    public void useMagicPotion(MagicPotion mp){
        mp.effect();
    }
 
    public static void main(String[] args) {
         
        Hero garen =  new Hero();
        garen.name = "盖伦";
     
        LifePotion lp =new LifePotion();
        MagicPotion mp =new MagicPotion();
         
        garen.useLifePotion(lp);
        garen.useMagicPotion(mp);
         
    }
       
}

6、类的多态-使用多态

如果物品的种类特别多，那么就需要设计很多的方法
比如useArmor,useWeapon等等

这个时候采用多态来解决这个问题
设计一个方法叫做useItem，其参数类型是Item
如果是使用血瓶，调用该方法
如果是使用魔瓶，还是调用该方法
无论英雄要使用什么样的物品，只需要一个方法即可

package charactor;
 
import property.Item;
import property.LifePotion;
import property.MagicPotion;
   
public class Hero {
    public String name;
    protected float hp;
 
    public void useItem(Item i){
        i.effect();
    }
 
    public static void main(String[] args) {
         
        Hero garen =  new Hero();
        garen.name = "盖伦";
     
        LifePotion lp =new LifePotion();
        MagicPotion mp =new MagicPotion();
         
        garen.useItem(lp);
        garen.useItem(mp);     
         
    }
       
}

7、练习：多态

immortal是不朽的，不死的意思
mortal就是终有一死的，凡人的意思

1. 设计一个接口
   接口叫做Mortal,其中有一个方法叫做die
2. 实现接口
   分别让ADHero,APHero,ADAPHero这三个类，实现Mortal接口，不同的类实现die方法的时候，都打印出不一样的字符串
3. 为Hero类，添加一个方法,在这个方法中调用 m的die方法。

public void kill(Mortal m)

4. 在主方法中
   首先实例化出一个Hero对象:盖伦
   然后实例化出3个对象，分别是ADHero,APHero,ADAPHero的实例
   然后让盖伦 kill 这3个对象

• Hero.java

public class Hero {
    public String name;                     //提供给子类共有的属性
     
    public void kill(Mortal m) {            //设计个用来统一调用的方法
        System.out.print(name+"放出必杀技击杀了");
        m.die();
    }
     
    public static void main(String[] args) {//程序入口
        Hero hero = new Hero();             //创建自身类的对象
        hero.name = "盖伦";
         
        ADHero ad = new ADHero();           
        ad.name = "赏金";
        APHero ap = new APHero();
        ap.name = "小法";
        ADAPHero adap = new ADAPHero();
        adap.name = "EZ";
         
        hero.kill(ad);                      //调用自身的方法，传引用类型变量
        hero.kill(ap);
        hero.kill(adap);
    }
}

• Mortal.java 接口

package charactor;
 
public interface Mortal {
    public void die();
}

• ADHero.java

package charactor;
 
public class ADHero extends Hero implements Mortal{
 
    @Override
    public void die() {
        System.out.println(name+"\n这个adc死亡");
         
    }
}

• APHero.java

package charactor;
 
public class APHero extends Hero implements Mortal{
 
    @Override
    public void die() {
        System.out.println(name+"\n这个ap死亡");
         
    }
}

• ADAPHero.java

package charactor;
 
public class ADAPHero extends Hero implements Mortal{
 
    @Override
    public void die() {
        System.out.println(name+"\n这个adap死亡");
         
    }
}

8、参考链接

[01] How2j - 接口与继承系列教材 （四）- 什么是JAVA的多态？