java基础 接口之间的转换

Question

interface tom{
void sing();
void football();
}interface jack{
void dance();
  void basketball();
}class me implements tom,jack{
public void sing(){
System.out.println("i am singing");
}
public void football(){
System.out.println("i am playing football");
}  
public void dance(){
System.out.println("i am dancing");
}
public void basketball(){
System.out.println("i am playing basketball");
}   
}public class duotai{
public static void main(String args[]){
  tom t=new me();
  jack j=(jack)t; //注释
  j.dance();
  j.basketball();
}
}请问，注释处看不明白啊？我的理解是，tom是me的接口，然后tom的引用指向了me的对象，me同时又实现了jack的接口，然后这个我就不明白了，jack j=(jack)t;这个可以看做me直接向上转型，为什么不可以直接写成jack j=t；而要强制转换？绕糊涂了啊...

Answer 1

可是t是用tom定义的,向上怎么转型..

Answer 2

其本质是个me对象啊！你的代码好比：me me=new me();
tom t = me;
  jack j=(jack)t; //注释

Answer 3

//接口类tom
interface tom
{
void sing();
void football();
}
//接口类jack
interface jack
{
void dance();
void basketball();
}
//类class启用接口tom,jack.
class me implements tom,jack
{
public void sing()
{
System.out.println("i am singing");
}
public void football()
{
System.out.println("i am playing football");
}   
public void dance()
{
System.out.println("i am dancing");
}
public void basketball()
{
System.out.println("i am playing basketball");
}   
}
//公用类duotai;
/**
 * @author 不再悲伤
 * 请问，注释处看不明白啊？我的理解是，tom是me的接口，然后tom
 * 的引用指向了me的对象，me同时又实现了jack的接口，然后这个我
 * 就不明白了，jack j=(jack)t;这个可以看做me直接向上转型，为什
 * 么不可以直接写成jack j=t；而要强制转换？绕糊涂了啊...
 */
public class duotai
{
public static void main(String args[])
{
tom t=new me();
/**
 * @author 不再悲伤
 * 楼上面的说的很正确，你的目的是得到jack的一个对象，
 * 但是这就好像各家公司分工合作最终的奥德一个产品，
 * 如果你突发奇想知道这件产品是哪几家公司生产的，你
 * 最好的办法是拿到一家产品，拆开产品的零部件，上面也就
 * 有各个公司生产不同的标志，差不多就这意思，如果楼主想
 * 深入了解话，建议看看《Java编程思想》^O^
 */
jack j=(jack)t; //注释
j.dance();
j.basketball();
}
}

Answer 4

tom t=new me();  //这里声明的是一个tom的实现（当然如果你是jack的实现也没有错）
  jack j=(jack)t; //这里需要强制转换是因为 tom声明的东西 其实和jack根本没有任何关系
                       //当然这里不会有错，因为t其实也是 jack的实现
  j.dance();
  j.basketball();
楼主的想法没有错，只是语法确实是需要这么做。
在语法上 其实只检查声明，而不会检查实例。 

Answer 5

从这里很容易看出，
me实现了接口tom,同时也实现了接口jack,
但tom和jack是两个相互独立的接口。tom t=new me();  
//这里声明的是一个tom的实现，不需要做任何类型转换，编译器可以识别me实例为一个tom对象jack j=(jack)t;
//前面说了，tom和jack是两个相互独立的接口，如果不做任何提示，编译器是无法将一个tom对象识别为jack对象的，因此这里需要强制转换声明，否则将会编译不通过。 

Answer 6

 tom t=new me();    //这里是父类引用指向子类对象 你这里只是用tom 而没有去引用JAck 
  jack j=(jack)t; //接口不能实例化  
  不知道我这样理解得对不啊....... 

Answer 7

基本同意！ 1. tom t=new me();  //根据me生成了个tom类型的对象!
2. jack j=(jack)t;  //me恰好又实现了jack这个接口，所以它能转化成Jack.
3.这样有两个不同类型的"指针",指向同一个对象( new me()生成的那个)

Answer 8

1. tom t=new me(); //根据me生成了个tom类型的对象!
2. jack j=(jack)t; //me恰好又实现了jack这个接口，所以它能转化成Jack.
3.这样有两个不同类型的"指针",指向同一个对象( new me()生成的那个)

Answer 9

tom有两个把柄，你可以抓住其中一个，也可以抓住另一个