Java面向对象_内部类(innerClass) ——恋天小结

内部类

概念

	在类体中编写的类

作用

	 可以访问外部类私有化数据

变量

	成员变量  --- 普通内部类/成员内部类
	   		静态变量  --- 静态内部类
	   		局部变量  --- 局部内部类
	   		形参和实参变量 --- 匿名内部类

分类

1 成员内部类

		1 成员内部类可以看做成员变量
		   		2 成员内部类中不能有静态声明
		   		3 成员内部类中可以直接访问外部类所有的数据
		4 类体中没有static修饰的类是成员内部类
		注意
			 成员内部类中 不能有静态声明
			 成员内部类 可以使用 权限控制修饰符 , 比如 private class xxxx
			 编译之后的类名 外部类类名$内部类类名  _01_OuterClass$InnerClass
			外部类对象
				_01_OuterClass oc = new _01_OuterClass();
			使用外部类对象.new 内部类()  来创建内部类对象

public class _01_OuterClass {
	
	private static String s1 = "静态变量";
	private String s2 = "成员变量";
	
	//类体中  灭有static修饰的类 是成员内部类
	class InnerClass{
		//成员内部类中  不能有静态声明
		//成员内部类 可以使用 权限控制修饰符，比如  private class xxxx
		//编译之后的类名  外部类类名$内部类类名 _01_OuterClass$InnerClass
		
		//static String aa = "";
		//public static void m1(){
		//}
		
		public void m2() {
			//可以直接访问外部类的所有属性
			System.out.println(s1);
			System.out.println(s2);
		}
		class A{
			
		}
	}

	public static void main(String[] args) {
		// 外部类对象
		_01_OuterClass oc = new _01_OuterClass();
		
		//使用外部类对象.new 内部类（）  来创建内部类对象
		InnerClass inner = oc.new InnerClass();
		inner.m2();
		
		System.out.println(inner);
		InnerClass inner1 = new _01_OuterClass().new InnerClass();

	}
	

}

2 静态内部类

		静态内部类,可以看做静态变量
		 在类体中使用static修饰的类是静态内部类
		静态内部类中可以声明成员属性也可以声明静态属性
		但是静态内部类中不能直接访问外部类的成员属性(需要使用外部类对象调用外部类的成员属性)
		 访问静态属性

public class _02_OuterClass {
	private static String s1 = "静态变量";
	private String s2 = "成员变量";
	
	static class InnerClass{
		//静态变量
		static int i = 1;
		//成员变量
		int b = 2;
		
		
		//静态方法
		public static void m1() {
			System.out.println(s1);
			// 不能直接调用外部类的成员属性
			// System.out.println(s2);
			// 需要使用外部类对象调用成员属性
			System.out.println(new _02_OuterClass().s2);
		}
		
		// 成员方法
		public void m2() {
					System.out.println(s1);
					// 不能直接调用外部类的成员属性
					// System.out.println(s2);
					// 需要使用外部类对象调用成员属性
					System.out.println(new _02_OuterClass().s2);
				}
	}
	

	public static void main(String[] args) {
		// 访问静态属性
		_02_OuterClass.InnerClass.m1();
		InnerClass.m1();
		// InnerClass inner = new _02_OuterClass.InnerClass();
		InnerClass inner = new InnerClass();
		inner.m2();

	}

}

3 局部内部类

		局部 内部类 等同于 局部变量
		 局部内部类中访问外部类的局部变量的时候,局部变量需要加final修饰(1.8之前),但是局部变量的值不能更改
		不管是成员方法还是静态方法,都不能使用static修饰内部类
		如果外部方法是成员方法的话,在内部类中可以直接访问外部类的所有属性
		 如果外部方法是静态方法的话,在内部类中不能直接访问外部类的成员属性,需要创建对象访问
		不管方法是静态还是成员,局部内部类都不可以有静态声明
		 类名
			如果多个方法的内部类类名不一致,就是  外部类类名$1内部类类名
			如果内部类类名一致 , 就是 外部类类名$1内部类类名 , 外部类名$2内部类类名 依次类推
			使用局部内部类 必须在方法内部调用

public class _03_OuterClass {
	private static String s1 = "静态变量";
	private String s2 = "成员变量";
	
	
    public void m1() {
    	int i = 10;
    	class InnerClass{
    		//不能有静态声明
    		//public static void m3(){}
    		public void m4() {
    			System.out.println(s1);
				System.out.println(s2);
				System.out.println(i);
    		}
    	}
    	//使用局部内部类  必须在方法内部调用
    	InnerClass inner = new InnerClass();
    		inner.m4();
    		System.out.println(inner);
			
    }
    public static void m2() {
    	int i = 10;
    	//不饿能更改i的值，是final修饰
    	//i= 2；
    	class InnerClass{
    					// 不能有静态声明
    					// public static void m3(){}
    					public void m4() {
    						System.out.println(s1);
    						// 静态方法中的内部类,没有办法直接访问外部类的成员属性,需要用对象调用
    						// System.out.println(s2);
    						System.out.println(new _03_OuterClass().s2);
    						System.out.println(i);
    					}
    				}
    				// 使用局部内部类 必须在方法内部调用
    				InnerClass inner = new InnerClass();
    				inner.m4();
    				System.out.println(inner);

    	}
    	
    
			

	public static void main(String[] args) {
		_03_OuterClass oc = new _03_OuterClass();
		oc.m1();
		_03_OuterClass.m2();

	}

}

4 匿名内部类

		匿名内部类 : 指在调用方法的时候,需要传入一个接口的实现类对象,这个时候可以不传递实现类对象,传递一个匿名内部类
		 语法
			方法(new 接口名(){ 类体 });
		 传入匿名内部类的时候,会自动创建一个对象传入,因为没有名字,我们不能自己创建
		 类名
			外部类类名$1 以此类推
		不能有静态声明,但是可以声明常量(public static final int i = 10)
		 静态变量 / 静态方法 都不行
		不能直接访问外部类的成员属性,需要使用对象调用

public class _04_OuterClass {
	private static String s1 = "静态变量";
	private String s2 = "成员变量";

	public static void main(String[] args) {
	//	IUserService userService = new UserService();
	//	m1(userService);
		m1(1,new IUserService(){
			public static final int i = 2;
			
			public void m1() {
				
			}
			
			public void login() {
				System.out.println("啥也不是");
				System.out.println(this);
				System.out.println(s1);
				// 需要使用对象调用,不能直接调用外部类的成员属性
				// System.out.println(s2);
				
			}
			
		});

	}
	public static void m1(int i ,IUserService userService) {
		userService.login();
	}


}
interface IUserService{
	public void login();
}