Java 对象转型

Java 对象转型

一.对象转型介绍

1.一个基类的引用类型变量可以“指向”其子类的对象

2.一个基类的引用不可以访问其子类对象新增加的成员(属性和方法)

3.可以使用引用变量instanceof类名 来判断该引用型变量所“指向”的对象是否属于该类或该类的子类

4.子类的对象可以当作基类的对象来使用称作向上转型，反之称为向下转型

*对象转型分为两种：一种叫**向上转型（父类对象的引用或者叫基类对象的引用指向子类对象，这就是向上转型）另一种叫做向下转型（转型的意思是：如把float类型转成int类型，把double类型转成float类型，把long类型转成int类型，这些都叫转型。）*把一种形式转成另外一种形式就叫转型。除了基础数据类型的转型之外(基础数据类型的转型：大的可以转成小的，小的也可以转成大的。)对象领域里面也有对象之间的转型。

一个转型到底能否转成功，教大家一个简单的方法

转型读法：A = B //由B向A转

把右边的当做左边来用，看说得通不？

---

上转型对象（子类转父类）

父类 引用名 = new 子类

这种创建对象的方法叫上转型对象(类型是父类，实例是子类)

//上转型对象会失去在子类中新定义而并非从父类继承的方法

所有的子类转型父类都说得通，比如身边的例子：

苹果手机 继承了 手机 把苹果手机当 普通手机用

怡宝纯净水 继承了 饮品 把怡宝纯净水 当做饮品来使用

苍老师 继承了动物 把苍老师。。。

---

代码实例

public class Hero{
    public String name;
    public float hp;
    
    public static void main(String[] args){
        
        Hero h = new Hero();
        
        ADhero ad = new ADhero();
        
        //类型转换指的是把一个引用所指向的对象的类型，转型为另一个引用的类型
        
        //把ad引用所指向的对象的类型是ADhero
        //h引用的类型是Hero
        //把ADHero当做是Hero使用，一定可以
        
        h = ad;//把物理英雄当英雄使用 yes
    }
}

---

下转型对象（父类转子类）

父类转子类，有的时候行，有的时候不行，所以必须要进行强制转换。

强制转换的意思就是 转换有风险 风险自担

什么时候行呢？

代码实例

Hero h = new Hero();
ADHero ad = new ADHero();
h = ad ;//子类转父类，一定可以的
ad = h ; //父类转子类 一定要强转，所以这样是错误的
ad = (ADHero)h;//父类转子类，所以要进行强制转换，就能成功

什么时候不行呢？

代码实例

Hero h = new Hero();   //英雄
ADHero ad = new ADHero();  //物理英雄
Support s =new Support();	//辅助英雄
h = s;   //这个是子类转父类 ，一定可以
ad = (ADHero)h; //这行是把h引用所指向的对象 Support，转换为ad引用的类型ADHero。 从语义上讲，把辅助英雄，当成物理英雄来用，说不通，所以会强制转换失败，并且抛出异常

代码实例

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; //把ad当做Hero使用，一定可以
//转换之后，h引用指向一个ad对象
        ad = (ADHero) h;//h引用有可能指向一个ad对象，也有可能指向一个support对象
//所以把h引用转换成AD类型的时候，就有可能成功，有可能失败
//因此要进行强制转换，换句话说转换后果自负
//到底能不能转换成功，要看引用h到底指向的是哪种对象在这个例子里，h指向的是一个ad对象，所以转换成ADHero类型，是可以的
        h = s;
        //把一个support对象当做Hero使用，一定可以
//转换之后，h引用指向一个support对象
        ad = (ADHero)h;
        //这个时候，h指向的是一个support对象，所以转换成ADHero类型，会失败。
//失败的表现形式是抛出异常 ClassCastException 类型转换异常
    }
      
}

---

没有继承关系的两个类，互相转换

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

虽然ADHero和APHero都继承了Hero，但是彼此互相没有互相继承关系

把魔法英雄当作物理英雄来用，在语义上是说不通的。

代码实例

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

---

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

引用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行： 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;
   
        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);
        //true
        //判断引用h2指向的对象，是否是APHero类型
        System.out.println(h2 instanceof APHero);
        //true
        //判断引用h1指向的对象，是否是Hero的子类型
        System.out.println(h1 instanceof Hero);
        //true
    }
}