内部类详解

在一个类中定义的类叫做内部类。内部类分为四种:成员内部类，静态内部类，局部内部类，匿名内部类

1.成员内部类---在一个类中定义，类似于成员变量

/**
 * 成员内部类
 * 内部类属于外部类的一个成员，所以内部类可以直接使用外部类的成员
 *
 */

class Outer{
	int num = 2;
	class Inner{
		public void show(){
			System.out.println(num);
		}
	}
	public void fun(){
		Inner inner = new Inner();
		inner.show();
	}
}

public class Test {
	
	public static void main(String[] args) {
		
		Outer  outer = new Outer();
		outer.fun();
		
		//直接创建内部类对象
		Outer.Inner inner = new Outer().new Inner();
		inner.show();
	}

}

　运行结果:

成员变量num,成员函数fun,成员内部类Inner，都是Outer的成员，三者可以相互调用。

show()依附于Inner,Inner依附于Outer-----获取show(),要获取new Inner()---要获取new Inner()，要获取new Outer()

Outer.class与Inner.class的字节码文件的名称如下：

Outer.class----Outer$Inner.class

2.静态内部类---static修饰

 1 //静态内部类
 2   class Outer{
 3       static int num = 2;
 4       static class Inner{
 5           public void show(){
 6              System.out.println(num);
 7          }
 8      }
 9      public void fun(){
10          Inner inner = new Inner();
11          inner.show();
12      }
13  }
14 
15  public class Test {
16      
17      public static void main(String[] args) {
18          
19          Outer  outer = new Outer();
20          outer.fun();
21          
22          //直接创建内部类对象
23          Outer.Inner inner = new Outer.Inner();
24  　　　　　　　　　　
25  　　　　　//这是错误的
26  　　　　　//Outer.Inner inner = new Outer.new Inner();
27          inner.show();
28           }
29   }

　运行结果:

成员变量num,成员函数fun,静态内部类Inner，都是Outer的成员。

show()依附于Inner,Inner依附于Outer-----获取show(),要获取new Inner()---要获取new Inner()，直接Outer点取 Outer.Inner

/**
 * 内部类中含有静态成员，那么内部类必须为static
 */
class Outer{
	static int num = 2;
	static class Inner{
		//内部类中含有静态成员，那么内部类必须为static
		public static void show(){
			System.out.println(num);
		}
	}
	public void fun(){
		Inner inner = new Inner();
		inner.show();
	}
}

public class Test {
	
	public static void main(String[] args) {
		
		Outer  outer = new Outer();
		outer.fun();
		
		//直接创建内部类对象
		Outer.Inner inner = new Outer.Inner();
		inner.show();
	}

}

运行结果:

成员变量num,成员函数fun,静态内部类Inner，都是Outer的成员。

show()依附于Inner,Inner依附于Outer-----获取show(),要获取new Inner()---要获取new Inner()，直接Outer点取 Outer.Inner

　/* * 内部类得到外部类对象中的成员外部类名.this.成员 **/

 1 class Outer{ 
 2     int num = 2;    
 3     class Inner{
 4         int num =3;
 5         //内部类中含有静态成员，那么内部类必须为static
 6         public void show(){
 7             int num =4;
 8             System.out.println(num);
 9             System.out.println(this.num);
10             System.out.println(Outer.this);
11             System.out.println(Outer.this.num);
12 　　　　　　　//会出现错误
13            //System.out.println(Outer.num);
14 　　　　　　}
15     }
16     public void fun(){
17         Inner inner = new Inner();
18         inner.show();
19     }
20 }
21 
22 public class Test {    
23     public static void main(String[] args) {        
24         Outer outer = new Outer();
25         outer.fun();        
26     }
27 }

运行结果:

　　4
　　3
　　langdon.Outer@40671416
　　2

System.out.println(Outer.this)输出的是Outer对象

3.局部内部类：在函数内部定义的类

/**
 * 局部内部类
 * 局部内部类使用了其所在函数的局部变量时，该局部变量必须是final的
 *
 */
class Outer{
	
	public void fun(){
		final int num = 2;
		class Inner{
			public void show(){
				//从内部类中访问本地变量num,num需要声明为final
				System.out.println(num);
			}
		}
		Inner inner = new Inner();
		inner.show();
	}
}

public class Test {
	
	public static void main(String[] args) {
		
		Outer outer = new Outer();
		outer.fun();
		
	}

}

运行结果:

class Outer{
	Object obj;
	public void fun(){
		
		final int num = 2;
		class Inner{
			public void show(){
				//从内部类中访问本地变量num,num需要声明为final
				System.out.println("inner"+num);
			}
			
			public String toString() {
				return "inner"+num;
			}
		}
		obj = new Inner();//多态
	}
	
	public void function(){
		System.out.println(obj.toString());
	}
}

public class Test {
	
	public static void main(String[] args) {
		
		Outer outer = new Outer();
		outer.fun();
		outer.function();
		
	}

}

运行结果:

　　inner2

4.匿名内部类：没有名字的内部类
（1）非匿名内部类----->匿名内部类（前提条件:存在父类）

 1 /**
 2  * 匿名内部类：没有名字的内部类
 3  * 简化书写
 4  * 前提条件:存在父类（TestMain）或父接口
 5  *
 6  */
 7 abstract class TestMain{
 8 　　public abstract void show();
 9 }
10 
11 class Outer{
12 
13 　　class Inner extends TestMain{
14 
15     　public void show(){
16 
17     　　System.out.println("show");
18 
19     　}
20     
21         
22     　public void eat() {
23     　　System.out.println("吃饭");
24     　}
25     
26 
27     }
28     
29     public void fun(){
30     　　Inner inner = new Inner();
31     　　inner.show();
32     　　inner.eat();        
33     }
34 
35     
36 }
37 
38 
39 public class Test {
40 
41 　　public static void main(String[] args) {
42 　　//类
43 　　Outer outer = new Outer();
44 　　outer.fun();        
45 　　
46 　　}
47     
48 }

 1 /**
 2  * 匿名内部类：没有名字的内部类
 3  * 简化书写
 4  * 前提条件:存在父类（TestMain）或父接口
 5  *
 6  */
 7 
 8 abstract class TestMain{
 9 　　public abstract void show();
10 }
11 
12 class Outer{
13 　　class Inner extends TestMain{
14     public void show(){
15     　　System.out.println("show");
16     }
17         
18     public void eat() {
19     　　System.out.println("吃饭");
20     }
21 
22 　　}
23 
24 　　public void fun(){
25 　　　　//创建TestMain的子类对象
26 　　　　new TestMain(){
27 　　　　　　public void show(){
28     　　　　System.out.println("show");
29 　　　　　　}
30         
31     　　public void eat() {
32         System.out.println("吃饭");
33     　　}
34     }.show();
35     
36     new TestMain(){
37     　　public void show(){
38         System.out.println("show");
39     　　}
40         
41     　　public void eat() {
42         System.out.println("吃饭");
43     　　}
44     }.eat();
45     
46 　　　}
47 
48 }
49 
50 public class Test {
51 　　public static void main(String[] args) {
52 　　//类
53 　　Outer outer = new Outer();
54 　　outer.fun();
55 　　}
56 }

　　
运行结果:

　　show

　　吃饭

（2）匿名内部类（父类类型的引用指向了子类对象）

abstract class TestMain{
	public abstract void show();
}

class Outer{
	class Inner extends TestMain{
		public void show(){
			System.out.println("show");
		}
		
		public void eat() {
			System.out.println("吃饭");
		}

	}

	public void fun(){
		//父类类型的引用指向了子类对象,只能调用show()
		TestMain testMain = new TestMain(){
			public void show(){
				System.out.println("show");
			}
					
			public void eat() {
				System.out.println("吃饭");
			}
		};
				
		testMain.show();
				
		System.out.println(new Object(){
			int age = 23;
			String name = "11";
					
			public String toString(){
				return name+","+age;
			}
		});					
	}

}

public class Test {
	public static void main(String[] args) {
	　　//类
	　　Outer outer = new Outer();
	　　outer.fun();
	}
}

运行结果:

　　show
　　11,23

（3）匿名内部类（前提条件:存在父接口）

interface inter{
	public abstract void sleep();
}

class Test1 implements inter{
	public void sleep(){
		System.out.println("睡觉");
	}
}

public class Test {
	
	public static void main(String[] args) {
		//接口
		Test1 t = new Test1();
		ff(t);
		
		//使用匿名内部类调用函数ff
		ff(new inter(){
			public void sleep(){
				System.out.println("睡觉");
			}
			public void learn(){
				System.out.println("学习");
			}
		});
		
	}
	
	public static void ff(inter in){//inter in = new Test1()
		in.sleep();
	}

}

运行结果:

　　睡觉
　　睡觉