CoreJava 内部类

内部类

一、概念

1. 在类中定义的完整的类，称为内部类
2. 内部类中可以在不破坏封装的前提下访问外部类的私有成员
3. 内部类编译之后单独生成一个.class文件(文件名格式为 外部类名$内部类名.class)
4. 内部类分为成员内部类，静态内部类，局部内部类和匿名内部类四种

二、成员内部类

1. 语法：声明在成员元素位置的内部类称为成员内部类

   class OutterClass{
   	class MemberInnerClass{		
   	}
   }
   

2. 对象的创建：

   1. 引用：外部类名.内部类名 变量名
   2. 对象：外部类对象.new 内部类名();

   public class Test {
   	public static void main(String[] args) {
   		OutterClass oc = new OutterClass();//创建外部类对象
   		OutterClass.MemberInnerClass om;//内部类的引用
   		om = oc.new MemberInnerClass();//使用外部类对象创建内部类对象
   	}
   }
   class OutterClass{
   	class MemberInnerClass{		
   	}
   }
   

3. 命名冲突问题

   1. 外部类中有一个成员变量名为a
   2. 内部类中也有一个成员变量名为a
   3. 内部类的成员方法中也有一个局部变量名为a

class OutterClass{
	public int a = 10;
	class MemberInnerClass{
		public int a = 20;
		public void menthod(){
			int a = 30;
			System.out.println(a);//访问局部变量，值为30
			System.out.println(this.a);//访问内部类的成员变量，值为20
			System.out.println(OutterClass.this.a);//访问外部类的成员变量，值为10
		}
	}
}

三、静态内部类

1. 语法：被static修饰的成员内部类

   class OutterClass{
   	static class StaticInnerClass{
   	}
   }
   

2. 对象的创建：

   1. 引用：外部类名.内部类名 变量名
   2. 对象：new 外部类名.内部类名();

   public class Test {
   	public static void main(String[] args) {
   		OutterClass.StaticInnerClass os;//静态内部类的引用
   		os = new OutterClass.StaticInnerClass();//创建静态内部类的对象
   	}
   }
   class OutterClass{
   	static class StaticInnerClass{
   	}
   }
   

3. 成员的访问：

   1. 静态内部类中可以声明非静态成员变量和非静态成员方法，使用方法和一般的类没有区别
   2. 静态内部类中只能访问外部类的静态成员，如果要访问外部类的非静态成员，需要创建外部类的对象

4. 类加载的时机：

   1. 静态内部类的类加载时机与外部类无关

四、局部内部类

1. 语法：声明在方法内部的类

2. 特点：

   1. 局部内部类及其对象的的有效范围都和局部变量相同
   2. 无法在方法之外创建该内部类的对象
   3. 可以访问外部类的私有属性
   4. 可以访问外部类的局部变量，但是该变量必须是常量(被final修饰)

   class OutterClass{
   	//成员方法
   	public void method() {
   		//局部内部类
   		class LocalInnerClass{
   			
   		}
   		//创建对象
   		LocalInnerClass inner = new LocalInnerClass();
   		
   	}
   }
   

   class OutterClass{
   	public void method() {
   		final int a = 10;//需要被final修饰
   		class LocalInnerClass{
   			public void m() {
   				System.out.println(a);
   			}
   		}
   	}
   }
   

3. 进阶应用：将接口暴露，但将实现类声明为局部内部类，可以强制弱耦合

五、匿名内部类

1. 语法：直接创建父类或者接口的对象，创建的同时对其进行实现

2. 对象创建：直接实现接口

   interface IA{
   	void m();
   }
   class Animal{
   	public void m() {}
   }
   class Test{
   	public static void main(String[] args) {
           //接口的匿名内部类
   		IA ia1 = new IA() {
   			public void m() {
   				System.out.println("实现了IA接口");
   			}
   		};
           ia1.m();
           //类的子类写成匿名内部类
           Animal a = new Animal() {
   			public void m() {
   				System.out.println("");
   			}
   		};
   		a.m();
       }
   }
   

3. 特点：

   1. 匿名内部类没有类名
   2. 匿名内部类需要实现某个接口或者继承某个父类
   3. 匿名内部类只有一个对象

六、Lambda表达式

1. 语法要求：接口必须是函数式接口

2. 语法：

   引用类型 变量名 = (形参列表) -> {//方法实现};
   

   interface IA{
   	void m(int a);
   }
   class Test{
   	public static void main(String[] args) {
   		IA ia = (int a) -> {
               System.out.println("实现了IA接口");
           };        
       }
   }
   

3. 语法细节：

   1. 如果Lambda表达式的实现体仅有一句语句，则{}可以省略

   interface IA{
   	void m(int a);
   }
   class Test{
   	public static void main(String[] args) {
   		IA ia = (int a) -> 
               System.out.println("实现了IA接口");        
       }
   }
   

   ​ b. Lambda表达式中参数列表的数据类型可以省略

   interface IA{
   	void m(int a);
   }
   class Test{
   	public static void main(String[] args) {
   		IA ia = (a) -> 
               System.out.println("实现了IA接口");        
       }
   }
   

   ​ c.如果Lambda表达式中的参数只有一个，则()可以省略

   interface IA{
   	void m(int a);
   }
   class Test{
   	public static void main(String[] args) {
   		IA ia = a -> 
               System.out.println(a);
   }
   

   ​ d.如果Lambda表达式的实现中仅有一个return语句，则可以直接写入 值的表达式

   interface IA{
   	int m(int a);
   }
   class Test{
   	public static void main(String[] args) {
   		IA ia =  a -> a;
   }