java内部类

在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。内部类可以间接解决多继承问题,可以使用内部类继承一个类，外部类继承一个类，实现多继承。

       内部类主要分为成员内部类，方法内部类，静态内部类,匿名内部类。

 

1.成员内部类

    成员内部类顾名思义就是外部类的一个成员属性，只不过该属性不是String，int等类型，而是class类型。类的成员内部类可以访问该类的属性和方法，因为他也是该类的一个成员。

   成员内部类使用：

1. package com.dream;  
2.   
3. public class MyTest {  
4.   
5.     public static void main(String[] args) {  
6.   
7.         Mother mother=new Mother(12, "小明");  
8.           
9.         //实例内部类的方法之一  
10.         Mother.baby temp=mother.new baby();       
11.         temp.say();  
12.           
13.         //实例化方法二，通过调用类的成员函数访问内部类  
14.         mother.say();  
15.           
16.     }  
17.   
18. }  
19.   
20. class Mother{  
21.       
22.     private int age;  
23.   
24.     public String name;  
25.   
26.     public Mother(int age, String name) {  
27.           
28.         this.age = age;  
29.         this.name = name;  
30.     }  
31.       
32.     //定义内部类(成员内部类）  
33.     class baby{  
34.         public void say()  
35.         {  
36.             System.out.println("我已经"+age+"岁啦，名字叫"+name);  
37.         }  
38.     }  
39.       
40.     //在类中实例化  
41.     public void say()  
42.     {  
43.         baby temp=new baby();  
44.         temp.say();  
45.     }  
46.       
47. }  

复制代码

成员内部类是类的一个成员，类的成员依赖类对象，所以内部类也依赖于对象，类需要实例化才能使用,所以使用外部类对象来实例化内部类。

 

2.方法内部类

顾名思义方法内部类即把类定义在方法里面，需要注意的是：

    1.方法内部类只能在定义该内部类的方法里实例化，不可在此方法之外地方对其实例化

    2.方法内部类对象不能使用该内部类所在方法的非final属性

1. public class MyTest {  
2.     public void say(final String name)  
3.     {   //方法内部类  
4.         class baby  
5.         {         
6.             public void say()  
7.             {  
8.                 //需要final属性  
9.                 System.out.println("名字叫"+name);  
10.             }  
11.               
12.         }  
13.           
14.         //在该方法内部实例化  
15.         baby temp=new baby();  
16.         temp.say();  
17.     }  
18.   
19.     public static void main(String[] args) {  
20.               
21.             MyTest  test=new MyTest();  
22.              test.say("王小帅");  
23.               
24.     }  
25.   
26. }  

复制代码

方法内部类的作用域局限于该方法内，所以要在方法内实例化。方法内定义的变量是局部变量，离开该方法，变量就失去了作用，也就会自动被消除，而内部类却不会离开它所在方法就失去作用，它有更广的生命周期，所以需要拷贝到内部类中，而拷贝会带来不一致性，从而需要使用final声明保证一致性。

 

3.静态内部类

即在一个类里定义一个静态内部类，静态就是该内部类可以像其他静态成员一样，没有实例的外部类对象也可以访问调用，静态属性不属于类的实例对象。

1. public class MyTest {  
2.       
3.     public int age=1;  
4.       
5.     public static String name="小黑";  
6.     //定义静态内部类  
7.     static class baby{  
8.           
9.         public void say()  
10.         {  
11.             //不能访问age属性，只能访问静态属性  
12.             System.out.println("name: "+name);  
13.         }  
14.           
15.     }  
16.   
17.     public static void main(String[] args) {      
18.         //实例化静态内部类  
19.         MyTest.baby temp=new MyTest.baby();  
20.         temp.say();  
21.     }  
22.   
23. }  

复制代码

   需要注意的是静态内部类只能访问外部类中的静态成员属性和方法，因为静态属性可以不使用外部实例对象进行访问，若属性不是静态属性，则需要依赖于外部类的实例对象。所以静态内部类只能访问外部类的静态属性

 

4.匿名内部类

    匿名内部类有点像匿名对象，没有名字，只能使用一次，匿名内部类又分三种情况

1.继承式匿名内部类：可以不定义class去继承该抽象类而实现抽象类的实例和运行

1. public class MyTest {  
2.       
3.     public static void main(String[] args) {      
4.           
5.         //相当继承Mother类并实现抽象方法  
6.         Mother mother=new Mother(25, "桂纶镁"){  
7.             public void say()  
8.             {  
9.                 System.out.println("age: "+age+"  name: "+name);  
10.             }  
11.         };  
12.         mother.say();  
13.           
14.     }  
15.   
16. }  
17.   
18. abstract class Mother{  
19.       
20.     public int age;  
21.   
22.     public String name;  
23.   
24.     public Mother(int age, String name) {  
25.           
26.         this.age = age;  
27.         this.name = name;  
28.     }  
29.       
30.     public abstract void say();  
31. }  

复制代码

2.接口式匿名内部类：可以不定义class去实现该接口而实现接口的调用

1. public class MyTest {  
2.       
3.     public static void main(String[] args) {      
4.           
5.         //相当于实现接口  
6.         baby temp=new baby() {        
7.             @Override  
8.             public void say() {  
9.                 System.out.println("name： "+name);  
10.             }  
11.         };  
12.         temp.say();  
13.           
14.     }  
15.   
16. }  
17.   
18. interface baby{  
19.       
20.   String name="小黑";//接口定义的属性都是常量，修饰为 public final static String name  
21.   public void say();  
22. }  

复制代码

3.参数式匿名内部类：只能访问final属性

1. public class MyTest {  
2.   
3.     public void say(baby temp)  
4.     {  
5.         temp.say();  
6.     }  
7.       
8.     public static void main(String[] args) {      
9.           
10.         MyTest test=new MyTest();  
11.           
12.         final int age=10;  
13.         //参数匿名内部类  
14.         test.say(new baby() {  
15.                           
16.             @Override  
17.             public void say() {  
18.                 //要访问final定义的属性  
19.                 System.out.println("age: "+age);  
20.                   
21.             }  
22.         });  
23.     }  
24.   
25. }  
26.   
27. interface baby{   
28.     String name="小黑";//接口定义的属性都是常量，修饰为 public final static String name  
29.     public void say();  
30. }  

复制代码

说明为什么要使用final属性

主要是局部变量的生命周期与局部内部类的对象的生命周期的不一致。

 

   内部类里面使用外部类的局部变量时，其实就是内部类的对象在使用它，内部类对象生命周期中都可能调用它，而内部类试图访问外部方法中的局部变量时， 外部方法的局部变量很可能已经不存在了，那么就得延续其生命，拷贝到内部类中，而拷贝会带来不一致性，从而需要使用final声明保证一致性。  复制保证生命周期延续，final保证引用一致。