JAVA基础：接口、对象转型、多台

来源：how2j
接口
在设计LOL的时候，进攻类英雄有两种，一种是进行物理系攻击，一种是进行魔法系攻击
这时候，就可以使用接口来实现这个效果。
接口就像是一种约定，我们约定某些英雄是物理系英雄，那么他们就一定能够进行物理攻击。
AD ，声明一个方法 physicAttack 物理攻击，但是没有方法体，是一个“空”方法

package charactor;
 
public interface AD {
        //物理伤害
    public void physicAttack();
}

设计一类英雄，能够使用物理攻击，这类英雄在LOL中被叫做AD
类：ADHero， 继承了Hero 类，所以继承了name,hp,armor等属性
实现某个接口，就相当于承诺了某种约定
所以，实现了AD这个接口，就必须提供AD接口中声明的方法physicAttack()
实现在语法上使用关键字 implements

package charactor;
 
public class ADHero extends Hero implements AD{
 
    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }
 
}

接口的成员特点：
A:成员变量 只能是常量。默认修饰符 public static final
B:成员方法 只能是抽象方法。默认修饰符 public abstract

对象转型
明确引用类型与对象类型的概念 ：
首先，明确引用类型与对象类型的概念
在这个例子里，有一个对象 new ADHero(), 同时也有一个引用ad
对象是有类型的， 是ADHero
引用也是有类型的，是ADHero
通常情况下，引用类型和对象类型是一样的
接下来要讨论的类型转换的问题，指的是引用类型和对象类型不一致的情况下的转换问题

package charactor;
 
public class Hero {
    public String name;
    protected float hp;
     
    public static void main(String[] args) {
         
        ADHero ad = new ADHero();
         
    }
}

子类转父类(向上转型) ：
所谓的转型，是指当引用类型和对象类型不一致的时候，才需要进行类型转换
所有的子类转换为父类，都是说得通的。
Hero h = new Hero();
ADHero ad = new ADHero();
h = ad;

父类转子类(向下转型) ：
父类转子类，有的时候行，有的时候不行，所以必须进行强制转换。
强制转换的意思就是 转换有风险，风险自担。
行：

1.    Hero h =new Hero();
   

2.    ADHero ad = new ADHero();
   

3.    h = ad;
   

4.    ad = (ADHero) h;
   

不行：

1.    Hero h =new Hero();
   

2.    ADHero ad = new ADHero();
   

3.    Support s =new Support();
   

4.    h = s;
   

5.    ad = (ADHero)h;
   

没有继承关系的两个类，互相转换：
没有继承关系的两个类，互相转换，一定会失败

实现类转换成接口(向上转型) ：
引用ad指向的对象是ADHero类型，这个类型实现了AD接口
10行： 把一个ADHero类型转换为AD接口
从语义上来讲，把一个ADHero当做AD来使用，而AD接口只有一个physicAttack方法，这就意味着转换后就有可能要调用physicAttack方法，而ADHero一定是有physicAttack方法的，所以转换是能成功的。

package charactor;
   
public class Hero {
    public String name;
    protected float hp;
       
    public static void main(String[] args) {
        ADHero ad = new ADHero();
          
        AD adi = ad;
          
    }
       
}

接口转换成实现类(向下转型) ：

package charactor;
     
public class Hero {
    public String name;
    protected float hp;
         
    public static void main(String[] args) {
        ADHero ad = new ADHero();
            
        AD adi = ad; //能
   
        ADHero adHero = (ADHero) adi; //能
            
        ADAPHero adapHero = (ADAPHero) adi; //不能
        adapHero.magicAttack();
    }
         
}

instanceof ：
instanceof Hero 判断一个引用所指向的对象，是否是Hero类型，或者Hero的子类

package charactor;
  
public class Hero {
    public String name;
    protected float hp;
      
    public static void main(String[] args) {
        ADHero ad = new ADHero();
        APHero ap = new APHero();
         
        Hero h1= ad;
        Hero h2= ap;
         
        //判断引用h1指向的对象，是否是ADHero类型
        System.out.println(h1 instanceof ADHero);
         
        //判断引用h2指向的对象，是否是APHero类型
        System.out.println(h2 instanceof APHero);
         
        //判断引用h1指向的对象，是否是Hero的子类型
        System.out.println(h1 instanceof Hero);
    }
}

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

多态
操作符的多态 ：+可以作为算数运算，也可以作为字符串连接
类的多态：父类引用指向子类对象
注：java里不存在类似于C++里的自定义操作符重载
注：java里的普通函数类似于C++的虚函数
C++虚函数 == Java普通函数
C++纯虚函数 == Java抽象函数
C++抽象类 == Java抽象类
C++虚基类 == Java接口

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

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. 父类（接口）引用指向子类对象
2. 调用的方法有重写

隐藏：
与重写类似，方法的重写是子类覆盖父类的对象方法
隐藏，就是子类覆盖父类的类方法