how2j.cn

本视频是解读性视频,所以希望您已经看过了本知识点的内容,并且编写了相应的代码之后,带着疑问来观看,这样收获才多。 不建议一开始就观看视频



33分26秒
本视频采用html5方式播放,如无法正常播放,请将浏览器升级至最新版本,推荐火狐,chrome,360浏览器。 如果装有迅雷,播放视频呈现直接下载状态,请调整 迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的 视频下载插件会影响播放,如 IDM 等,请关闭或者切换其他浏览器



示例 1 : 明确引用类型与对象类型的概念   
示例 2 : 子类转父类(向上转型)   
示例 3 : 父类转子类(向下转型)   
示例 4 : 没有继承关系的两个类,互相转换   
示例 5 : 实现类转换成接口(向上转型)   
示例 6 : 接口转换成实现类(向下转型)   
示例 7 : instanceof   
示例 8 : 练习-类型转换   
示例 9 : 答案-类型转换   

示例 1 :

明确引用类型与对象类型的概念

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

public class Hero {
	public String name; 
	protected float hp;
	
	public static void main(String[] args) {
		
		ADHero ad = new ADHero();
		
	}
}
示例 2 :

子类转父类(向上转型)

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

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


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 :

父类转子类(向下转型)

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

什么时候行呢?

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

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

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

		APHero ap = new APHero();

		// 没有继承关系的类型进行互相转换一定会失败,所以会出现编译错误
		ad = (ADHero) ap;

	}

}
示例 5 :

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

edit
引用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;
         
    }
      
}
示例 6 :

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

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

练习-类型转换

edit  姿势不对,事倍功半! 点击查看做练习的正确姿势
如下转换能否成功?
如果不能,是哪一行会出错?
为什么会出错
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; } }
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;
	}
}
示例 9 :

答案-类型转换

edit
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
查看本答案会花费4个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 基础总计0个答案 (总共需要0积分)
查看本答案会花费4个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 基础总计0个答案 (总共需要0积分)
账号未激活 账号未激活,功能受限。 请点击激活
本视频是解读性视频,所以希望您已经看过了本答案的内容,带着疑问来观看,这样收获才多。 不建议一开始就观看视频

1分50秒 本视频采用html5方式播放,如无法正常播放,请将浏览器升级至最新版本,推荐火狐,chrome,360浏览器。 如果装有迅雷,播放视频呈现直接下载状态,请调整 迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的 视频下载插件会影响播放,如 IDM 等,请关闭或者切换其他浏览器


11 行会出错,因为不能把ADHero转换为APHero,这两种类型之间没有关系
答案-类型转换
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; } }
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;
	}
}


HOW2J公众号,关注后实时获知最新的教程和优惠活动,谢谢。


问答区域    
2023-01-12 AD adi = (AD) h;
guagua666

为啥能写AD adi? AD不是一个接口吗?




4 个答案

hncj指尖风雨
答案时间:2023-12-29
APHero ap = (APHero) adi; 第11行出错 因为adi接口指向了ad类不能转化为AP类

xihaiyan
答案时间:2023-12-02
但是教材里明确规定接口不能创建实例

莫諾
答案时间:2023-03-31
111

Inkwair
答案时间:2023-03-23
接口也是一种类



回答已经提交成功,正在审核。 请于 我的回答 处查看回答记录,谢谢
答案 或者 代码至少填写一项, 如果是自己有问题,请重新提问,否则站长有可能看不到




2022-10-11 示例三:运行后没有报错,没有出现类型转换异常
chen212




此处的强制转换应该报错,但运行后没有报错
加载中
//代码有点多了,请拉至最下面
//对象转型
package charactor;

import charactor1.Support;//使用其他包下的类,必须import

import java.util.Scanner;

public class Hero {
	
	//Hero类饿汉式单例模式
	//private Hero()//1.构造方法私有化
	//{
	//	
	//}
	
	//private static Hero instance = new Hero();//2.静态/类属性指向实例化
	
	//public static Hero getInstance()//3.public static 的getInstance方法,返回第二步的静态属性
	//{
	//	return instance;
	//}
	
	public String name; //姓名  实例属性,对象属性,非静态属性
	
	public float hp; //血量
	
	protected float armor; //护甲
	
	protected int moveSpeed; //移动速度
	
	static String copyright;  //版权    类属性,静态属性
	
	public int maxHp = 9999;//声明该属性的时候初始化
	
	//物品栏的容量
	public static int itemCapacity = 8;//声明的时候初始化
	
	static
	{
		itemCapacity = 6;//静态初始化块  初始化
	}
	
	int killed; //送了多少次
	
	int kill; //杀人次数
	
	int support; //助攻次数
	
	int money; //金钱
	
	int lastHit; //补刀数
	
	int attackSpeed; //攻击速度
	
	String wordAfterKill; //杀人后说的话
	
	String wordAfterKilled; //被杀后说的话
	
	//坑队友
	void keng()
	{
		System.out.println("坑队友!");
	}
	
	//获取护甲值
	float getArmor()
	{
		return armor;
	}
	
	//增加移动速度
	void addSpeed(int speed)
	{
		//在原来的基础上增加移动速度
		moveSpeed = moveSpeed + speed;
	}
	
	//超神
	void legendary()
	{
		System.out.println("超神了");
	}
	
	//获取当前的血量
	float getHp()
	{
		return hp;
	}
	
	//回血
	void recovery(float blood)
	{
		hp = hp + blood;
	}
	
	
	//实例方法、对象方法、非静态方法
	//必须有对象才能够调用
	public void die()
	{
		hp = 0;
		battleWin();//对象方法中可以直接调用类方法
	}
	
	//类方法、静态方法
	//通过类就可以直接调用
	public static void battleWin()
	{
		System.out.println("battle win");
		
	}
	public static void main(String[] args)
	{
		Hero garen = new Hero();
		garen.name = "盖伦";
		garen.hp = 616.28f;
		garen.armor = 27.536f;
		garen.moveSpeed = 350;
		garen.addSpeed(100);
		garen.copyright = "版权由Riot Games公司所有";
		
		Hero teemo = new Hero();
		teemo.name = "提莫";
		teemo.hp = 383f;
		teemo.armor = 14f;
		teemo.moveSpeed = 330;
		
		Scanner s = new Scanner(System.in);
		int a = s.nextInt();
		System.out.println("第一个整数:" + a);
		int b = s.nextInt();
		System.out.println("第二个整数:" + b);
		System.out.println("两个数的和是:" + (a + b));
		System.out.println("比较5>8:" + (a > b));
		System.out.println("比较5>=8:" + (a >= b));
		System.out.println("比较5<8:" + (a < b));
		System.out.println("比较5<=8:" + (a <= b));
		System.out.println("比较5==8:" + (a == b));
		System.out.println("比较5!=8:" + (a != b));
		
		int i = 0;
		while (i < 5)
		{
			System.out.println(i++);
		}
		int m = 1;
		long j = s.nextInt();
		while (j > 0)
		{
			m *= j;
			j--;
		}
		System.out.println(m);
		
		//使用while打印1到4
		int n = 0;
		while (n < 5)
		{
			System.out.println("while循环输出的" + n);
			n++;
		}
		
		int y = 1;
		int sum = 0;
		for(int x = 0; x < 10; x++)
		{
			sum += y;
			y *= 2;
			System.out.println("for循环输出的" + x);
		}
		System.out.println(sum);
		
		for(int t = 1; t < 101; t++)
		{
			if (t % 3 ==0 || t % 5 == 0)
				continue;
			System.out.println(t);
			
		}
		
		for(int q = 0; q < 10; q++)
		{
			if(0 == j % 2)
				break;
			System.out.println(q);
		}
		
		int year1 = 0;
		double f = 1.2;
		for(int year = 1; f < 100; year++ )
		{
			
			int r = year;
			double u;
			for(u = 1.2; r > 0; r--)
			{
				u *= (1 + 0.20);
				
			}
			f += u;
			year1 = year;
		}
		System.out.println(year1);
		System.out.println();
		//float f = 0;  //每年的投资总收益
		//float p = 12000;  //每年的投入
		//int n = 1;    //起始年份
		//float r = 1.2f;   //每年的投资收益率
		//while (f < 1000000)
		//{
		//    f = (int)((f + p)*(1 + r));
		//    System.out.println("第" + n + "年,总收益为:" + f + "元。");
		//    n++;
		//}
		//System.out.println(n - 1);
		
		System.out.println(garen.copyright);
		System.out.println(teemo.copyright);
		
		garen.copyright = "Blizzard Entertainment Enterprise";
		System.out.println(garen.copyright);
		System.out.println(teemo.copyright);
		
		garen.die();//必须有一个对象才能调用
		Hero.battleWin();//无需对象,直接通过类调用
		
		System.out.println(Hero.itemCapacity);
		
		System.out.println();
		
		//枚举
		//增强型for循环遍历枚举类HeroType,把每种枚举常量输出为中文字符串
		for(HeroType heroType:HeroType.values())
		{
			System.out.println(heroType);

			switch(heroType)
			{
			case TANK:
				System.out.println("坦克");
				break;
			case WIZARD:
				System.out.println("法师");
				break;
			case ASSASSIN:
				System.out.println("刺客");
				break;
			case ASSIST:
				System.out.println("辅助");
				break;
			case WARRIOR:
				System.out.println("近战");
				break;
			case RANGED:
				System.out.println("远程");
				break;
			case PUSH:
				System.out.println("推进");
				break;
			case FARMING:
				System.out.println("打野");
				break;
				
			}
		}
		System.out.println();
		
		//普通循环遍历所有枚举常量
		//枚举名.values()这个方法会返回一个装着枚举元素的数组
		for(int k = 0; k < HeroType.values().length; k++)
		{
			HeroType heroType1 = HeroType.values()[k];
			
			switch(heroType1)
			{
			case TANK:
				System.out.println("坦克");
				break;
			case WIZARD:
				System.out.println("法师");
				break;
			case ASSASSIN:
				System.out.println("刺客");
				break;
			case ASSIST:
				System.out.println("辅助");
				break;
			case WARRIOR:
				System.out.println("近战");
				break;
			case RANGED:
				System.out.println("远程");
				break;
			case PUSH:
				System.out.println("推进");
				break;
			case FARMING:
				System.out.println("打野");
				break;
				
			}
			
		}
		
		//用户输入英文,得到相应的中文字符
		System.out.println("print a type:");
		Scanner scan = new Scanner(System.in);
		String type = scan.nextLine();
		
		try
		{
			HeroType heroType2 = HeroType.valueOf(type);
			switch(heroType2)
			{
			case TANK:
				System.out.println("坦克");
				break;
			case WIZARD:
				System.out.println("法师");
				break;
			case ASSIST:
				System.out.println("辅助");
				break;
			case PUSH:
				System.out.println("推进");
				break;
			}
		}
		catch(IllegalArgumentException e)
		{
			System.out.println("没有该类型");
		}
    	
		
		//对象转型
		//明确引用类型与对象转型的概念
		//在这个例子里,有一个对象类型 new ADHero(),同时也有一个引用ad
		//对象是有类型的,是ADHero
		//引用也是有类型的,是ADHero
		//通常情况下,引用类型和对象类型是一样的
		//接下来要讨论的类型转换的问题,指的是引用类型和对象类型不一致的情况下的转换问题
		
		//右边对象的类型转换为左边引用的类型
		ADHero ad = new ADHero();
		
		//子类转父类(向上转型)
		//所谓的转型,是指当引用类型和对象类型不一致的时候,才需要进行类型转换
		//类型转换有时候会成功,有时候会失败(参考基本类型的类型转换)
		//能否转换成功的判别方法:把右边的当作左边来用,看说得通不
		
		//所有的子类转换为父类,都是说得通的
		//苹果手机 继承了 手机, 把苹果手机当作普通手机使用
		//怡宝纯净水 继承了 饮品,把怡宝纯净水当作饮品来使用
		
		//类型转换指的是把一个引用所指向的对象的类型,转换为另一个引用的类型
		//ad引用所指向的对象的类型是ADHero
		//h引用的类型是Hero
		//把ADHero当作Hero使用,一定可以
		
		Hero h = new Hero();
		
		h = ad;//子类转父类,一定行,转换后h引用指向一个ad对象
		//右边ad引用所指向的对象的类型是 物理攻击英雄,左边h引用类型是 普通英雄
		//把物理攻击英雄 当做 普通英雄,说得通,可以转
		
		//父类转子类(向下转型)
		//父类转子类,有的时候行,有的时候不行,所以必须进行强制转换
		//强制转换的意思就是 转换有风险,风险自担
		
		Support s1 = new Support();
		
		ad = (ADHero)h;//父类转子类,要进行强转,此时h这个引用所指向的对象是ADHero		
		h = s1;//转换后,h引用指向一个support对象
		//上面能成功是因为:h现在是指向ADHero,但是h引用类型是Hero
		
		ad = (ADHero)h;//强制转换失败,抛出异常ClassCastException类型转换异常
		
	}
}

							





回答已经提交成功,正在审核。 请于 我的回答 处查看回答记录,谢谢
答案 或者 代码至少填写一项, 如果是自己有问题,请重新提问,否则站长有可能看不到





2022-09-27 一个理解
2022-03-22 我的总结
2022-01-23 向上转型和向下转型的另一种理解


提问太多,页面渲染太慢,为了加快渲染速度,本页最多只显示几条提问。还有 61 条以前的提问,请 点击查看

提问之前请登陆
提问已经提交成功,正在审核。 请于 我的提问 处查看提问记录,谢谢
关于 JAVA 基础-接口与继承-对象转型 的提问

尽量提供截图代码异常信息,有助于分析和解决问题。 也可进本站QQ群交流: 578362961
提问尽量提供完整的代码,环境描述,越是有利于问题的重现,您的问题越能更快得到解答。
对教程中代码有疑问,请提供是哪个步骤,哪一行有疑问,这样便于快速定位问题,提高问题得到解答的速度
在已经存在的几千个提问里,有相当大的比例,是因为使用了和站长不同版本的开发环境导致的,比如 jdk, eclpise, idea, mysql,tomcat 等等软件的版本不一致。
请使用和站长一样的版本,可以节约自己大量的学习时间。 站长把教学中用的软件版本整理了,都统一放在了这里, 方便大家下载: https://how2j.cn/k/helloworld/helloworld-version/1718.html

上传截图