JAVA 基础 / 第二十九课：接口与继承 / JAVA 重…

2018-06-18 02:43:35来源：未知阅读 ()

2018-03-19

子类可以继承父类的对象方法。在继承后，重复提供该方法，就叫做方法的重写；又叫覆盖 override

1、父类Item

父类Item有一个方法，叫做effect

package property;
 
public class Item {
    String name;
    int price;
 
    public void buy(){
        System.out.println("购买");
    }
    public void effect() {
        System.out.println("物品使用后，可以有效果");
    } 
}

2、子类LifePotion

子类LifePotion继承Item,同时也提供了方法effect

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

3、调用重写的方法

调用重写的方法
调用就会执行重写的方法，而不是从父类的方法
所以LifePotion的effect会打印：
"血瓶使用后，可以回血"

package property;
 
public class Item {
    String name;
    int price;
     
    public void effect(){
        System.out.println("物品使用后，可以有效果");
    }
     
    public static void main(String[] args) {
        Item i = new Item();
        i.effect();        
        LifePotion lp =new LifePotion();
        lp.effect();
    }    
}

4、如果没有重写这样的机制怎么样？

如果没有重写这样的机制，也就是说LifePotion这个类，一旦继承了Item，所有方法都不能修改了。
但是LifePotion又希望提供一点不同的功能，为了达到这个目的，只能放弃继承Item,重新编写所有的属性和方法，然后在编写effect的时候，做一点小改动.
这样就增加了开发时间和维护成本

package property;
 
public class Item {
    String name;
    int price;
 
    public void buy(){
        System.out.println("购买");
    }
    public void effect() {
        System.out.println("物品使用后，可以有效果");
    } 
}

package property;
 
public class LifePotion {
    String name;
    int price;
 
    public void buy(){
        System.out.println("购买");
    }
    public void effect(){
        System.out.println("血瓶使用后，可以回血");
    }
}

5、多态

操作符的多态：+ 可以作为算数运算，也可以作为字符串连接
类的多态：父类引用指向子类对象

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

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);         
    }       
}

观察类的多态现象：
1. i1和i2都是Item类型
2. 都调用effect方法
3. 输出不同的结果
多态: 都是同一个类型，调用同一个方法，却能呈现不同的状态

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();
    }
 
}

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

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

类的多态条件：

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

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

如果不使用多态，假设英雄要使用血瓶和魔瓶，就需要为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);         
    }       
}

二、类的多态-使用多态

如果物品的种类特别多，那么就需要设计很多的方法
比如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);              
    }       
}