Java自学-接口与继承 对象转型

java中的对象转型

示例 1 : 明确引用类型与对象类型的概念

首先，明确引用类型与对象类型的概念
在这个例子里，有一个对象 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();
         
    }
}

示例 2 : 子类转父类(向上转型)

所谓的转型，是指当引用类型和对象类型不一致的时候，才需要进行类型转换
类型转换有时候会成功，有时候会失败(参考基本类型的类型转换)

到底能否转换成功？ 教大家一个很简单的判别办法
把右边的当做左边来用，看说得通不

hero h = new hero();
adhero ad = new adhero();
h = ad;

右边ad引用所指向的对象的类型是 物理攻击英雄
左边h引用的类型是 普通英雄
把物理攻击英雄 当做 普通英雄，说不说得通？ 说得通，就可以转

所有的子类转换为父类，都是说得通的。比如你身边的例子

苹果手机 继承了 手机，把苹果手机当做普通手机使用
怡宝纯净水 继承了 饮品， 把怡宝纯净水 当做饮品来使用

package charactor;
 
public class hero {
    public string name;
    protected float hp;
     
    public static void main(string[] args) {
         
        hero h = new hero();
         
        adhero ad = new adhero();
         
        //类型转换指的是把一个引用所指向的对象的类型，转换为另一个引用的类型
         
        //把ad引用所指向的对象的类型是adhero
        //h引用的类型是hero
        //把adhero当做hero使用，一定可以
         
        h = ad;
         
    }
}

示例 3 : 父类转子类(向下转型)

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

什么时候行呢？

1.        hero h =new hero();
2.        adhero ad = new adhero();
3.        h = ad;
4.        ad = (adhero) h;

第3行，是子类转父类，一定可以的
第4行，就是父类转子类，所以要进行强转。
h这个引用，所指向的对象是adhero, 所以第4行，就会把adhero转换为adhero，就能转换成功。

什么时候转换不行呢？

1.        hero h =new hero();
2.        adhero ad = new adhero();
3.        support s =new support();
4.        h = s;
5.        ad = (adhero)h;

第4行，是子类转父类，是可以转换成功的
第5行，是把h引用所指向的对象 support，转换为ad引用的类型adhero。 从语义上讲，把物理攻击英雄，当成辅助英雄来用，说不通，所以会强制转换失败，并且抛出异常

以下是对完整的代码的关键行分析：

14行： 把ad当做hero使用，一定可以
转换之后，h引用指向一个ad对象

15行： h引用有可能指向一个ad对象，也有可能指向一个support对象
所以把h引用转换成ad类型的时候，就有可能成功，有可能失败
因此要进行强制转换，换句话说转换后果自负
到底能不能转换成功，要看引用h到底指向的是哪种对象
在这个例子里，h指向的是一个ad对象，所以转换成adhero类型，是可以的

16行：把一个support对象当做hero使用，一定可以
转换之后，h引用指向一个support对象

17行：这个时候，h指向的是一个support对象，所以转换成adhero类型，会失败。
失败的表现形式是抛出异常 classcastexception 类型转换异常

package charactor;
  
import charactor1.support;
  
public class hero {
    public string name;
    protected float hp;
      
    public static void main(string[] args) {
        hero h =new hero();
        adhero ad = new adhero();
        support s =new support();
          
        h = ad; //14行
        ad = (adhero) h; //15行
        h = s; //16行
        ad = (adhero)h; //17行
    }
      
}

示例 4 : 没有继承关系的两个类，互相转换

没有继承关系的两个类，互相转换，一定会失败
虽然adhero和aphero都继承了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();
 
        // 没有继承关系的类型进行互相转换一定会失败，所以会出现编译错误
        ad = (adhero) ap;
 
    }
 
}

示例 5 : 实现类转换成接口(向上转型)

引用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; //10行
          
    }
       
}

示例 6 : 接口转换成实现类(向下转型)

10行： ad引用指向adhero， 而adi引用是接口类型：ad，实现类转换为接口，是向上转型，所以无需强制转换，并且一定能成功
12行: adi实际上是指向一个adhero的，所以能够转换成功
14行： adi引用所指向的对象是一个adhero，要转换为adaphero就会失败。

假设能够转换成功，那么就可以使用magicattack方法，而adi引用所指向的对象adhero是没有magicattack方法的。

package charactor;
     
public class hero {
    public string name;
    protected float hp;
         
    public static void main(string[] args) {
        adhero ad = new adhero();
            
        ad adi = ad; //10行
   
        adhero adhero = (adhero) adi; //12行
            
        adaphero adaphero = (adaphero) adi; //14行
        adaphero.magicattack();
    }
         
}

示例 7 : 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);
    }
}

练习：

（如下转换能否成功？
如果不能，是哪一行会出错？
为什么会出错）

package charactor;
 
public class hero {
    public string name;
    protected float hp;
 
    public static void main(string[] args) {
        adhero ad = new adhero();
        hero h = ad;
        ad adi = (ad) h;
        aphero ap = (aphero) adi; //11行
    }
}