我定义了两个接口Programmer,BizAgent,两个类：一个是SoftEngineer类工程师类，一个Test测试类
工程师类SfotEngineer实现了接口Programmer,BizAgent,
测试类Test中有一条BizAgent bizAgent=(BizAgent)programmer;这不是表明一个接口能强制转化成另一个接口吗？但两个接口没有继承关系啊，它们属于平等的关系，怎么能强制转换呢？百思不得其解，请高手解惑！详细代码如下：

/**
* 人接口
* @author Administrator
*
*/
public interface Person {
/**
* 返回人的姓名
* @return 姓名
*/
public String getName();
}
/**
*Programmer接口
*/
public interface Programmer extends Person {
/**
* 写程序代码。
*/
public void writeProgram();
}
/**
*BizAgent 接口
*/
public interface BizAgent extends Person{
/**
* 讲解业务
*/
public void giveBizSpeech();
}
/**
*软件工程师类
*/
public class SoftEngineer implements Programmer,BizAgent{
private String name;//软件工程师姓名
public SoftEngineer(String name){
this.name=name;
}
public String getName(){
return name;
}

public void giveBizSpeech(){
System.out.println("我会讲业务。");
}
public void writeProgram(){
System.out.println("我会写代码。");
}
}
/**
*测试类
*/
public class Test {
public static void main(String[] args) {
Programmer programmer=new SoftEngineer("小明");
System.out.println("我是一名软件工程师，我的名字叫"+programmer.getNam()+". ");
programmer.writeProgram();
BizAgent bizAgent=(BizAgent)programmer;
bizAgent.giveBizSpeech();
}

}

SoftEngineer implements Programmer,BizAgent    说明SoftEngineer 既实现了 Programmer接口  又实现了BizAgent 接口
public class Test {
public static void main(String[] args) {
Programmer programmer=new SoftEngineer("小明");
System.out.println("我是一名软件工程师，我的名字叫"+programmer.getNam()+". ");
System.out.println(programmer instanceof BizAgent); //在测试代码中加上这一行，其结果返回true  说明 programmer是BizAgent的实例
programmer.writeProgram();
BizAgent bizAgent=(BizAgent)programmer;              //所以这里就可以将programmer对象强制转换成 BizAgent
bizAgent.giveBizSpeech();
}

如果把 BizAgent与Person接口之间的继承关系去掉 结果也一样
也就是说之所以能强制转换 跟BizAgent 与 Programmer接口之间的关系没什么关系，只是因为它同时实现了两个接口

1. 
   
2. /**
   
3. * 人接口
   
4. * @author Administrator
   
5. *
   
6. */
   
7. interface Person {
   
8. /**
   
9. * 返回人的姓名
   
10. * @return 姓名
    
11. */
    
12. public String getName();
    
13. }
    
14. /**
    
15. *Programmer接口
    
16. */
    
17. interface Programmer extends Person {
    
18. /**
    
19. * 写程序代码。
    
20. */
    
21. public void writeProgram();
    
22. }
    
23. /**
    
24. *BizAgent 接口
    
25. */
    
26. interface BizAgent extends Person{
    
27. /**
    
28. * 讲解业务
    
29. */
    
30. public void giveBizSpeech();
    
31. }
    
32. /**
    
33. *软件工程师类
    
34. */
    
35. class SoftEngineer implements Programmer,BizAgent{
    
36. private String name;//软件工程师姓名
    
37. public SoftEngineer(String name){
    
38. this.name=name;
    
39. }
    
40. public String getName(){
    
41. return name;
    
42. }
    
43. 
    
44. public void giveBizSpeech(){
    
45. System.out.println("我会讲业务。");
    
46. }
    
47. public void writeProgram(){
    
48. System.out.println("我会写代码。");
    
49. }
    
50. }
    
51. /**
    
52. *测试类
    
53. */
    
54. class Test
    
55. {
    
56.         public static void main(String[] args) {
    
57.                 Programmer programmer=new SoftEngineer("小明");// 这句话： SoftEngineer 是Programmer接口的子类 这就是典型的多态问题。
    
58.                 //父类的引用指向了子类对象 。 你要知道 SoftEngineer实现 了Programmer和BizAgent两个接口.
    
59.                 BizAgent bizAgent= (BizAgent) programmer; // programmer是指向了SoftEngineer子类对象 。而你定义的SoftEngineer也是BizAgent接口的子类，所以可以转换成BizAgent类型。
    
60.                 /*
    
61.                  注意：
    
62.                   <1>我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。
    
63.                   <2>多态自始至终都是子类对象在做着变化。
    
64.                  */
    
65.                 System.out.println("我是一名软件工程师，我的名字叫"+programmer.getName()+". ");
    
66.                 programmer.writeProgram();
    
67.                 bizAgent.giveBizSpeech();
    
68.         }       
    
69. }
    

复制代码