有关java多态性的介绍

多态性的解释：
1.子类对象的多态性，父类的引用指向子类对象
2.虚拟方法调用：通过父类的引用指向子类的对象实体，当调用方法时，实际上执行的是子类重写父类的方法

方法的重载（overload）：发生在同一类中，方法名称相同，参数个数、类型不相同。没有权限要求。即同一个方法名称可以根据参数类型或个数不同调用不同的方法体。

观察下面类的多态现象：

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

package property;
 
public class Item {
    
    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("蓝瓶使用后，可以回魔法");
    }
}

方法的覆写(override)（隐藏）：发生在有继承关心的类之间，方法名称、参数个数、类型全相同。子类的方法权限>=父类方法权限。同一个父类方法，可以根据实例化子类的不同也有不同的实现

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

1. 父类（接口）引用指向子类对象
2. 调用的方法有重写（如果方法定义为private 或者是final 则子类不可重写父类的方法）

为什么要用多态性

如果不使用多态性

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

上边不使用多态性的话，每次使用不同的物品都会去定义一个新的方法，这样一旦物品多了的话，需要定义很多方法，代码的易读性会降低，浪费资源

而使用多态性的话

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

使用了多态性以后现在用英雄调用方法的 时候只需调用一个useItem即可，可想而知多态性还是很方便的

用接口去实现类的多态
首先定义一个接口

/**
 * 带有draw方法的接口
 * @author Li Zhong Wei
 */
public interface DrawTest { // 定义接口
	public void draw(); // 定义接口方法
}

定义两个类

/**
 * 正方形类，它实现DrawTest接口
 * @author Li Zhong Wei
 */
public class Square implements DrawTest {
	public void draw() {
		System.out.println("正方形.draw()");
	}
}

/**
 * 平行四边形类，它实现了DrawTest接口
 * @author Li Zhong Wei
 */
public class Parallelogram implements DrawTest {
	public void draw() { // 由于该类实现了接口，所以需要覆盖draw()方法
		System.out.println("平行四边形.draw()");
	}
}

/**
 * 实例的主类，创建接口类型的多态数组，并调用每个元素的draw()方法
 * @author Li Zhong Wei
 */
public class Demo { // 定义四边形类
	public static void main(String[] args) {
		// 接口也可以进行向上转型操作
		DrawTest[] graphs = { new Square(), new Parallelogram() };
		for (int i = 0; i < graphs.length; i++) {
			graphs[i].draw(); // 调用draw()方法
		}
	}
}

隐藏

子类去隐藏父类
父类实例

package charactor;
  
public class Hero {
    public String name;
    protected float hp;
  
    //类方法，静态方法
    //通过类就可以直接调用
    public static void battleWin(){
        System.out.println("hero battle win");
    }
      
}

package charactor;
  
public class ADHero extends Hero implements AD{
  
    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }
     
    //隐藏父类的battleWin方法
    public static void battleWin(){
        System.out.println("ad hero battle win");
    }   
     
    public static void main(String[] args) {
        Hero.battleWin();
        ADHero.battleWin();
    }
  
}