java内部类与多重继承

内部类

定义：一个定义在类内部的类。之所以用内部类是因为使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。可以这样说，接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。

内部类：内部类可以有多个实例，每个实例都有自己的状态信息，并且与其他外部对象的信息相互独立。在单个外部类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。创建内部类对象的时刻并不依赖于外围类对象的创建。内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。内部类提供了更好的封装，除了该外围类，其他类都不能访问。内部类与外部类建立一种关系，可以访问外部类包括私有的属性。引用内部类首先创建内部类对象要用外部类对象来创建，OuterClass.InnerClass innerClass = outerClass.new InnerClass();内部类与外部类是编译时的概念，编译之后就是两个不同的class文件，内部类分为成员内部类，局部内部类、匿名内部类、静态内部类。

成员内部类：：1）成员内部类中不能存在任何static的变量和方法；2）成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。

[java]  view plain  copy

1. public class Outer {  
2.     private String str;  
3.     public void outerDisplay(){  
4.         System.out.println("outer");  
5.     }    
6.     public class InnerClass{  
7.         public void innerDisplay(){             
8.             str = "ch";  
9.             System.out.println(str);           
10.             outerDisplay();  
11.         }  
12.     }  
13.     public InnerClass getInnerClass(){  
14.         return new InnerClass();  
15.     }   
16.     public static void main(String[] args) {  
17.         Outer  outer = new Outer();  
18.         Outer.InnerClass inner = outer.getInnerClass();  
19.         inner.innerDisplay();  
20.     }  
21. }  

输出ch    换行outer
局部内部类 ：嵌套在方法和作用域内，用来解决复杂问题不创建公共的，就所谓的局部内部类，局部内部类和成员内部类一样被编译，只是作用域发生了改变，只能在该方法和属性内使用。

匿名内部类：Swing编程中，我们经常使用这种方式来绑定事件，

[java]  view plain  copy

1. button2.addActionListener(    
2.                 new ActionListener(){    
3.                     public void actionPerformed(ActionEvent e) {    
4.                         System.out.println("你按了按钮二");    
5.                     }    
6.                 });  

匿名内部类是没有访问修饰符的。new 匿名内部类，这个类首先是要存在的。当所在方法的形参需要被匿名内部类使用，那么这个形参就必须为final。匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法

使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的。匿名内部类的使用它是存在一个缺陷的，就是它仅能被使用一次。创建匿名内部类时它会立即创建一个该类的实例，该类的定义会立即消失，所以匿名内部类是不能够被重复使用，匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。：匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

当所在的方法的形参需要被内部类里面使用时，该形参必须为final。内部类并不是直接调用方法传递的参数，而是利用自身的构造器对传入的参数进行备份，自己内部方法调用的实际上时自己的属性而不是外部方法传递进来的参数。内部类中我对属性的改变并不会影响到外部的形参，所以为了保持参数的一致性，就规定使用final来避免形参的不改变。匿名内部类没有构造器，使用构造代码块达到创造一个构造器的效果。
静态内部类：非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外部类，但是静态内部类却没有。没有这个引用就意味着：它的创建是不需要依赖于外部类的。2）它不能使用任何外围类的非static成员变量和方法。

[java]  view plain  copy

1. public class Outer {  
2.     private String sex;  
3.     public static String name = "che";  
4.     static class InnerClass1{  
5.         /* 在静态内部类中可以存在静态成员 */  
6.         public static String _name1 = "che_static";         
7.         public void display(){  
8.             /*  
9.              * 静态内部类只能访问外围类的静态成员变量和方法 
10.              * 不能访问外围类的非静态成员变量和方法 
11.              */  
12.             System.out.println("OutClass name :" + name);  
13.         }  
14.     }  
15.     class InnerClass2{  
16.         /* 非静态内部类中不能存在静态成员 */  
17.         public String _name2 = "che_inner";  
18.         /* 非静态内部类中可以调用外围类的任何成员,不管是静态的还是非静态的 */  
19.         public void display(){  
20.             System.out.println("OuterClass name：" + name);  
21.         }  
22.     }  
23.     public void display(){  
24.         /* 外围类访问静态内部类：内部类. */  
25.         System.out.println(InnerClass1._name1);  
26.         /* 静态内部类 可以直接创建实例不需要依赖于外围类 */  
27.         new InnerClass1().display();  
28.         /* 非静态内部的创建需要依赖于外围类 */  
29.         Outer.InnerClass2 inner2 = new Outer().new InnerClass2();  
30.         /* 方位非静态内部类的成员需要使用非静态内部类的实例 */  
31.         System.out.println(inner2._name2);  
32.         inner2.display();  
33.     }    
34.     public static void main(String[] args) {  
35.         Outer outer = new Outer();  
36.         outer.display();  
37.     }  
38. }  

输出：che_static     OutClass name :che        che_inner          OuterClass name：che

多重继承的实现

一个类可以同时从多个类继承行为和属性，java只支持单继承，那么实现多重继承的方式有接口和内部类。

接口实现：接口和抽象类的时候了解到子类只能继承一个父类，也就是说只能存在单一继承，但是却可以实现多个接口，接口是没有任何具体实现的，也就是说，没有任何与接口相关的存储。

[java]  view plain  copy

1. interface CanFight {  
2.     void fight();  
3. }  
4.   
5. interface Swim {  
6.     void swim();  
7. }  
8.   
9.   
10. interface Fly {  
11.     void fly();  
12. }  
13.   
14. public class Action {  
15.     public void fight(){  
16.           
17.     }  
18. }  
19.   
20. public class Hero extends Action implements Fight,Fly,Swim{  
21.   
22.     public void fly() {  
23.     }  
24.   
25.     public void swim() {  
26.     }  
27.   
28.     /** 
29.      * 对于fight()方法，继承父类的，所以不需要显示声明 
30.      */  
31. }  

内部类实现多继承：

如果父类为抽象类或者具体类，那么我就仅能通过内部类来实现多重继承了。

[java]  view plain  copy

1. class Father {  
2.     public int str(){  
3.         return 2;  
4.     }  
5. }  
6. class Mother {  
7.     public int can(){  
8.         return 2;  
9.     }  
10. }  
11.  class Son {  
12.     class Father_1 extends Father{  
13.         public int str(){  
14.             return super.str() + 1;  
15.         }  
16.     }   
17.     class Mother_1 extends  Mother{  
18.         public int can(){  
19.             return super.can() - 2;  
20.         }  
21.     }    
22.     public int get(){  
23.         return new Father_1().str();  
24.     }    
25.     public int getcan(){  
26.         return new Mother_1().can();  
27.     }  
28. }  
29. public class Outer {  
30.   
31.     public static void main(String[] args) {  
32.         Son son = new Son();  
33.         System.out.println( son.get());  
34.         System.out.println( son.getcan());  
35.     }  
36. }  

输出3  0，定义两个内部类，他们分别继承父亲Father类、母亲类Mother类，且都可以非常获取各自父类的行为，这是内部类一个重要的特性：内部类可以继承一个与外部类无关的类，保证了内部类的独立性，正是基于这一点，多重继承才会成为可能。 点击打开链接