Java内部类

成员内部类

• 什么是成员内部类
  在类内部但在方法外部创建的非静态类称为成员内部类。

• 成员内部类的定义方法

  class Outer{
  //code
  
     class Inner{
     	//code
  
     }
  }
  

• 成员内部类的例子

  public class OuterClass {
  	private int data=1;
  	
  	public void fun() {
  		System.out.println("data的值为"+data);
  	}
  	class InnerClass {
  		public void fun1() {
  			data++;
  			fun();
  		}
  	}
  	
  	public static void main(String[] args) {
  		OuterClass out =new OuterClass();
  		OuterClass.InnerClass in=out.new InnerClass();
  		in.fun1();
  	}
  }
  
  

  结果为：data的值为2

• 成员内部类的实例化方法

  public class Test {
  	public static void main(String[] args) {
  		OuterClass out =new OuterClass();
  	//1.通过外部类.内部类 = new 外部类.new 内部类的方式获取
  		OuterClass.InnerClass in=new OuterClass().new InnerClass();
  	//2.通过外部类.内部类 = 外部类实例.new 内部类的方式获取	
  		OuterClass.InnerClass in1=out.new InnerClass();
  	//3.通过外部类的get方法获取内部类实例对象
  		OuterClass.InnerClass in2=out.getInner();
  	}	
  }
  

• 成员内部类的注意事项
  1. 内部类在外部使用时，无法直接实例化，需要借助由外部信息才能完成实例化操作
  2. 内部类的访问权限修饰符任意，但是访问范围会受到影响
  3. 内部类可以直接访问外部类的成员属性，如果由同名属性，默认会调用内部类的属性
  4. 可以通过 外部类.this.同名变量 的形式访问外部类的同名属性
  5. 内部类编译后的储存命名格式是：外部类$内部类.class
  6. 内部类中包含外部类同名方法时，若在内部类中使用外部类同名方法格式： 外部类.this.同名方法

静态内部类

• 什么是静态内部类
  在定义的内部类前加static修饰符，此时的内部类就是静态内部类。
• 静态内部类的定义方法

  class Outer{
  //code
  
     static class Inner{
     	//code
  
     }
  }
  

• 静态内部类的例子

  public class OuterClass2 {
  	private static int data=1;
  	
  	public static void fun() {
  		System.out.println("data的值为"+data);
  	}
  	static class InnerClass {
  		 public int x=1;
  		public void fun1() {
  			data++;
  			fun();
  		}
  	}
  	 public InnerClass getI() {
  		 return new InnerClass();
  	 }
  	public static void main(String[] args) {
  		OuterClass2.InnerClass in=new OuterClass2.InnerClass();
  		in.fun1();
  	}
  }
  

  结果为：data的值为2
• 静态内部类的注意事项
  1. 静态内部类中，可以直接访问外部类的静态成员。如果要访问外部类的非静态成员，需要用外部类对象的实例
  2. 静态内部类对象实例时，可以不依赖外部类的实例
  3. 可以通过外部类.内部类.静态方法的形式调用静态内部类的静态成员
  4. 当内部类属性与外部类属性同名时，内部类默认调用的是内部类的成员属性，如果需要访问外部类的静态属性，可以通过外部类.属性名的方式获取，如果需要访问外部类的非静态属性，通过new 外部类().属性的方式获取
• 静态内部类的实例化方法
  静态内部类与普通内部类的区别在于，静态内部类的对象是不指向与某个具体的外部类对象，所以在创建对象时不需要创建外部类对象。并且在new的时候是通过new OutClass.InnerClass()方式，而不是OutClass.new InnerClass()的方式

  public class Test {
     public static void main(String[] args) {
     	OuterClass2 out =new OuterClass2();
     //1.通过外部类.内部类 = new 外部类.new 内部类的方式获取
     	OuterClass2.InnerClass in=new OuterClass2.InnerClass();
     //2.通过外部类的get方法获取内部类实例对象
     	OuterClass2.InnerClass in2=out.getInner();
     }
  }
  

局部（方法）内部类

• 什么是 局部（方法）内部类
  在方法中定义的内部类称为局部内部类
• 局部（方法）内部类的定义方法

  class Outer{
  //code
     	public void fun(){
     			class Inner{
     			//code
     	  }
     }
  }
  

• 局部（方法）内部类的例子

  public class OuterClass3 {
    private static int data=1;
    
    public void fun() {
    	class InnerClass {
    		public void fun() {
    			System.out.println("我是方法内部类");
    		}	
    	}
    	new InnerClass().fun();
    }
    
    public static void main(String[] args) {
    	new OuterClass3().fun();
    }
  }
  

  结果为：我是方法内部类
• 局部（方法）内部类的注意事项
  1. 局部内部类不能有访问说明符，因为它不是外部类的一部分
  2. 方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化
  3. 局部内部类可以访问当前代码块内部的常量和外部类的所有成员
  4. 局部内部类不能写静态成员
  5. 方法内部类不能访问其他地方定义的局部变量（就是本类外的地方），除非这个变量是final 修饰的
  6. 方法内部类只能包含非静态成员
• 局部（方法）内部类的使用
  方法内部类不能在外部类的方法以外的地方使用
  方法内部类使用：一般情况下返回方法内部类中的方法

匿名内部类

• 什么是匿名内部类
  匿名内部类，是指可以利用内部类创建没有名称的对象，本质是一个实现了某个接口或者继承了某个类的子类匿名对象，它一步完成了声明内部类和创建该类的一个对象，并利用该对象访问到类里面的成员
  现，对于内部类都没有影响

• 匿名内部类的定义方法

     public class anonyClass {
     public static void main(String[] args) {
     	inner a=new inner(){
     		//code
     	};		
     }
  }
  class inner{
     //code
  }
  

• 匿名内部类的例子

  public class anonyClass {
     public static void main(String[] args) {
     		inner a=new inner(){
     			@Override
     			public void fun() {
     				System.out.println("x="+x);			
     			}	
     		};
     		a.fun();
     }
  }
  interface inner{
     int x=5;
     void fun();
  }
  

  结果：x=5

• 匿名内部类的注意事项
  1. 匿名内部类不能有构造方法。
  2. 匿名内部类不能定义任何静态成员、方法和类。
  3. 匿名内部类不能是public,protected,private,static。
  4. 只能创建匿名内部类的一个实例。
  5. 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
  6. 因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

• 匿名内部类的使用
  只用到一个类的实例，且定义后马上用到
  类非常小，代码量少
  当类或接口类型作为参数传递时，可以直接使用匿名内部类方式创建对应的对象

欢迎各位大佬指出错误