java内部类的总结！

柔光的暖阳◎ 2022-09-20 08:36 241阅读 0赞

# 一、非静态内部类 #

public class OutClass{	
    	private String name="outclass";
      public void show(){
    		System.out.println(this.name);
    	}
    	public void innerShow(){
    		
    		InnerClass inner=new InnerClass();
    		inner.show();
    		inner.outShow();
    	}
    	
    	
    	//非静态内部类
      class InnerClass {
      	//2.0非静态内部类不能有静态变量的声明
      	//public static int age=0;
      	
      	
      	private String name="innerclass";
    	 	public void show(){
    	 		System.out.println(this.name);
    	 	}
    	 	public void outShow(){
    	 		//3.0内部类做为外部类的实例成员，可以随意访问其他外部类成员
    	 		System.out.println(OutClass.this.name);
    	 	}
    	}
    	
    	public static void main(String[] args){
    		OutClass out=new OutClass();
    		out.show();
    		out.innerShow();
    		
    		
    		//1.0下面一行编译报错，静态方法无法访问this指针
    		//因为等同于this.InnerClass inner=new this.InnerClass();
    	        //InnerClass inner=new InnerClass();
    		
    	
    	}
    }

1.外部类不能直接访问非静态内部类，必须在外部类中保存内部类的引用间接访问。

2.非静态内部类中不能有静态属性。

个人理解：非静态内部类是外部类的实例成员，它属于外部类的实例对象所拥有，若内部类有静态属性，那么属性必定属于内部类所有，即所有的内部类实例对象都共享这个属性。但是这个内部类已经属于外部类的实例对象所拥有了，貌似是1：1的关系，除非外部类的对象保存了n多份内部类实例的引用，那这样内部类的静态属性才有存在的必要，可这么做就没有什么意义了。

3.非静态内部类可以随意访问外部类的成员，因为它们都是外部类的成员，等级一样。

4.若要得到内部类的实例，可以OutClass.InnerClass inner=new OutClass().new InnerClass();

# 二、静态内部类 #

public class OutClass{	
    	private String name="outclass";
    	private static int age=10;
    	
    	//静态内部类
      static class InnerClass {
      	
    	 	public void show(){
    	 		//1.0
    	 		System.out.println(new OutClass().name);
    	 	}
    	 	public void outShow(){
    	 		//2.0
    	 		System.out.println(age);
    	 	}
    	}
    	
    	public static void main(String[] args){
    		//3.0
    		OutClass.InnerClass inner=new OutClass.InnerClass();
    		inner.outShow();
    		inner.show();
    	
    	}
    }

1.静态内部类不能随意访问外部类的实例成员，必须引用外部类的对象。

2.静态内部类可以随意访问外部类的类成员。

3.若要获取静态内部类的实例，则形式如OutClass.InnerClass inner=new OutClass.InnerClass();

注意与非静态内部类获取实例的区别：   OutClass.InnerClass inner=new OutClass().new InnerClass();

# 三、局部类 #

## 1.匿名内部类 ##

interface IDraw{
    	void draw();
    }
    public class OutClass{	
    	
    	public void createCircle(IDraw obj){
    		obj.draw();
    	}
    	public static void main(String[] args){
    		OutClass out=new OutClass();
    		out.createCircle
    		  (
    				new IDraw(){
    				  public void draw(){
    				  	System.out.println("i'm drawing...");
    				  }		  	
    				}
    			);
    	}
    	
    }

在调用多态形式的方法createCircle(IDraw obj)时，参数用到了new IDraw()\{ \},做为接口来说是不能直接实例化的，这里的new IDraw()并不是直接实例化，而是创建了匿名内部类。

## 2.闭包与回调 ##

interface IDraw{
    	void draw();
    }
    public class OutClass{	
    	private String name="private name";
    	
    	public Closure getClosure(){
    		return new Closure();
    	}
    	
    	class Closure implements IDraw{
    		public void draw(){
    			System.out.println(OutClass.this.name);//name
    		}
    	}
    	public static void main(String[] args){
    		OutClass out=new OutClass();
    	  out.getClosure().draw();
    	}
    	
    }

内部类可以像其他类一样灵活的实现各种接口和继承，并且可以将外部类的属性和方法绑定到自身中，形成闭包。而在外部类中提供了方法供外界获取内部类的引用，因为内部类的方法灵活的访问了外部类的许多信息，甚至是私有信息，获得了这个对象后可以反过来调用外部类的方法和函数形成回调。

其实上面只是有闭包的形式，并不算是真正的闭包，闭包的定义里主要是绑定方法里的变量，但是java是无法实现方法里的内部类还能访问方法变量的，因为无法实现真正的闭包。

java内部类有许多用处，比如利用内部类实现多个接口可以模拟多继承；比如让内部类成为辅助外部类的工具类，来帮助外部类实现更好的逻辑与扩展。