Java内部类详解

内部类的分类

1. 成员内部类
2. 静态内部类
3. 方法内部类
4. 匿名内部类

成员内部类

又称为普通内部类。
定义规则：在一个类中直接定义，不适用static定义的内部类。可以拥有成员方法或属性。

class Outer {
	private String msg = "outer中的msg";
	class Inner {
		private int num = 10;
		private String mag = "成员内部类的msg";
		public void test() {
			System.out.println();
		}
	}
}

成员内部类对象的产生

根据产生对象的位置可以分为：
外部类的内部产生成员内部类对象
Inner inner = new Inner();

class Outer {
	private String msg = "outer中的msg";
	class Inner {
		private int num = 10;
		private String mag = "成员内部类的msg";
		public void test() {
			System.out.println();
		}
	}
	public void fun() {
		Inner inner = new Inner(); // 外部类的内部产生成员内部类对象
	} 
}

外部类的外部产生成员内部类对象
Outer.Inner inner = new Outer().new Inner();

class Test {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();// 外部类的外部产生成员内部类对象
    }
}

注意事项：
- 成员内部类必须依赖外部类而存在，必须现有外部类对象才能产生成员内部类。
- 内部类和外部类可以方便的访问彼此的私有域。
例如：
在成员内部类的方法test()中：由于在内部类中隐藏了一个外部类对象，可以直接访问外部类的私有域。

public void test() {
					// 这两行意义一样
            System.out.println(msg);
            // System.out.println(MemberClass.this.msg);
        }

在外部类的fun()方法中： ** 在外部类的方法中可以通过成员内部类的对象来访问 **

 public void fun() {
        Inner inner = new Inner(); // 外部类的内部产生成员内部类对象
        System.out.println(inner.num);
    }

- 对于成员内部类来说，不能定义静态变量，因为成员内部类必须要依赖于外部类，若成员内部类中有静态属性，意味着没有外部类对象也可以访问了与前面的是矛盾的。
- 对于外部类来说，不能在**外部类的静态方法**中使用成员内部类，因为若是这样相当于在静态方法中调用成员变量，这是不正确的。

静态内部类

定义规则：定义在类中，使用static修饰的内部类。
需要注意的是静态内部类不需要依赖外部类对象，可以看做与普通类的用法相同。

class Outer {
	private static int numT = 100;
	private String msg = "outer中的成员变量msg";
	// 静态内部类就是一个普通类，只是把它套在类outer中而已
	static class Inner {
		private int num = 10;
		public void test() {
			System.out.println(numT);
		}
	}
	public void fun() {
		Inner inner = new Inner(); // 外部类的内部产生成员内部类对象
	} 
}

静态内部类对象的产生

根据产生对象的位置可以分为：
外部类的内部产生静态内部类对象
Inner inner = new Inner();

class Outer {
	private static int numT = 100;
    private String msg = "outer中的成员变量msg";
    static class Inner {
        private int num = 10;
        public void test() {
            System.out.println();
        }
    }
    public void fun() {
        Inner inner = new Inner(); // 外部类的内部产生静态内部类对象
    }
}

外部类的外部产生静态内部类对象
Outer.Inner inner = new Outer.Inner(); 此时不用产生外部类对象。

class Test1 {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
    }
}

注意事项：
- 静态内部类与普通类的用法相同。
- 成员方法和静态方法都能创建静态内部类对象，因为类比可以类中静态变量和静态方法，没有类的对象就可以通过类直接使用或调用，更不用说成员方法同样可以。
- 静态内部类可以拥有成员域，与成员内部类不同的是它不能直接访问外部类的成员域、静态域，可以直接通过创建一个外部类对象来访问。
- 静态内部类可以直接访问外部类的静态变量和方法。
例如：
在静态内部类的方法test()中：

public void test() {
					  	 System.out.println(numT);
		//            System.out.println(msg); // 错误不能直接访问外部类的成员域，需要通过外部类对象调用
            			System.out.println(new outer().msg);
        }

方法内部类

又称为局部内部类。
定义规则：直接定义在方法内部的类，不允许使用任何访问修饰符，对外部完全隐藏。（因为出了这个方法这个类就没有了，使用修饰符是没有意义的）

class Outer {
	  String str;
	  
    public void fun(int num) {
    		// 方法内部类（其中不能出现任何访问修饰符合static）
        class inner {
            public void test() {
                System.out.println(num);
            }
        }
    }
}

注意事项：
- 方法内部类无法定义static域，除此之外和成员内部类的用法基本相同。
- 方法内部类中若使用了方法的形参，该形参为隐式的final声明。（JDK8之后，JDK8之前若使用了形参必须显示使用final声明。如：

public void test(final int num){
	System.out.println(num);
	}

)
若对这个形参在方法内部类外部进行了修改则会报错。

class Outer {
	  String str;
	  
    public void fun(int num) {
    		// 方法内部类（其中不能出现任何访问修饰符合static）
        class inner {
            public void test() {
                System.out.println(num);
            }
        }
//        num ++; // 报错
        System.out.println(num) ;
    }
}

匿名内部类

匿名内部类是方法内部类的特殊版本，直接不写类名称。
它是lambda表达式的前身，函数式编程，99%都用在方法传参。
匿名内部类遵从方法内部类的所有要求，匿名内部类默认会继承一个类（普通类或抽象类均可，一般是继承抽象类或者实现接口）或实现一个接口。

public class Outer{
    public static void fun(IMessage msg) {
        msg.printMsg();
    }
    public static void main(String[] args) {
        fun(new IMessage() {
            // 这就是一个匿名内部类
            // 等同于创建了一个类实现了Imessage接口，创建该类的对象
            @Override
            public void printMsg() {
                System.out.println("匿名内部类的用法");
            }
        });
//        IMessage msg = new IMessageImpl();
//        fun(msg);
    }
}
interface IMessage {
    void printMsg();
}
class IMessageImpl implements IMessage {
    @Override
    public void printMsg() {
        System.out.println("普通用法");
    }
}

程序进行编译之后文件类型为外部类名$1.class形式的意味着该类中使用了匿名内部类。