1. package test;  
2. /** 
3.  * class one: Class1 
4.  * @author TJ 
5.  */
6. publicclass Class1 {  
7.     /** 
8.      * method: getName 
9.      * @return name 
10.      */
11.     public String getName() {  
12.         return"Luck";  
13.     }  
14. }  

1. package test;  
2. /** 
3.  * class two: Class2 
4.  * @author TJ 
5.  */
6. publicclass Class2 {  
7.     /** 
8.      * method: getAge 
9.      * @return age 
10.      */
11.     publicint getAge() {  
12.         return25;  
13.     }  
14. }  

1. package test;  
2. publicclass MainClass {  
3.     /** 
4.      * inner class one: Test1 extends Class1 
5.      * @author TJ 
6.      */
7.     publicstaticclass Test1 extends Class1 {  
8.         @Override
9.         public String getName() {  
10.             returnsuper.getName();  
11.         }  
12.     }  
13.     /** 
14.      * inner class two: Test2 extends Class2 
15.      * @author TJ 
16.      */
17.     publicstaticclass Test2 extends Class2 {  
18.         @Override
19.         publicint getAge() {  
20.             returnsuper.getAge();  
21.         }  
22.     }  
23.     /** 
24.      * method: showName 
25.      * @return name 
26.      */
27.     public String showName() {  
28.         returnnew Test1().getName();  
29.     }  
30.     /** 
31.      * method: showAge 
32.      * @return age 
33.      */
34.     publicint showAge() {  
35.         returnnew Test2().getAge();  
36.     }  
37.     publicstaticvoid main(String args[]) {  
38.         MainClass example = new MainClass();  
39.         System.out.println("name:" + example.showName());  
40.         System.out.println("age:" + example.showAge());  
41.     }  
42. } 

我們都知道Java是不能像C++一樣真正的實現多重繼承，我們只能使用父類+介面的方式來實現多重繼承，那麼現在我們還可以使用內部類來實現多重繼承，避免實現多個介面時多了一些不必要的方法，因為實現一個介面那麼接口裡的方法你都要實現。