java-引用、对象转型和instanceof

java引用和对象转型

• 引用

1.定义：如果一个变量的类型是类类型，而非基本类型，那么该变量又叫做引用。

2.引用和指向
new Hero(); 代表创建了一个Hero对象，但没有办法访问它，为了访问这个对象，会使用引用来代表这个对象。

Hero h = new Hero();h这个变量是Hero类型，又叫做引用，=的意思指h这个引用代表右侧创建的对象,“代表” 在面向对象里，又叫做“指向”。

public class Hero {     
    String name; //姓名
    float hp; //血量
    float armor; //护甲 
    int moveSpeed; //移动速度 
    public static void main(String[] args) {
        //创建一个对象
        new Hero();
         
        //使用一个引用来指向这个对象
        Hero h = new Hero();     
    }        
}

3.多个引用，一个对象
(对象就像 “房产”，引用就像"房产证",房产证的复印件可以有多张，但是真正的"房产" 只有这么一处)

public class Hero {     
    String name; //姓名
    float hp; //血量
    float armor; //护甲 
    int moveSpeed; //移动速度 
    public static void main(String[] args) {
        //使用一个引用来指向这个对象
        Hero h1 = new Hero();
        Hero h2 = h1;  //h2指向h1所指向的对象
        Hero h3 = h1;
        Hero h4 = h1;
        Hero h5 = h4;
        //h1,h2,h3,h4,h5 五个引用，都指向同一个对象         
    }        
}

4.一个引用，多个对象
引用gareen指向新创建的对象（对象1）
同一个引用gareen指向新创建的对象（对象2）
这个时候，对象1，就没有任何引用指向了。
（即没有任何手段控制和访问该对象，该对象没有意义，将被回收。）

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

• 对象转型

1.引用类型和对象类型一致

package charactor;
public class Hero {
    public String name;
    protected float hp;
     
    public static void main(String[] args) {
        //对象是有类型的， 是ADHero
		//引用也是有类型的，是ADHero 
		//通常情况下，引用类型和对象类型是一样的。
        ADHero ad = new ADHero();      
    }
}

2.引用类型和对象类型不一致
子类转父类(向上转型)

到底能否转换成功？把右边的当做左边来用，看说得通不。
右边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;     
    }
}

父类转子类(向下转型)

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;
        ad = (ADHero) h;
        h = s;
        ad = (ADHero)h;
    }
      
}

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

没有继承关系的两个类，互相转换，一定会失败
虽然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;
    }
}

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

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;
        //假设能够转换成功，那么就可以使用magicAttack方法，而adi引用所指向的对象ADHero是没有magicAttack方法的。
        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);
    }
}