内部类和匿名内部类

当两个业务之间联系比较紧密时，用内部类是一个不错的选择，例如一个类中有方法取到数据准备存储到数据库中，一个类是加密解密算法，通过算法将数据加密存到数据库服务器上，这时可以将算法类声明为内部类，嵌套第一个类中。

interface Interclass {

}

public class Myoutclass {
	private int j = 0;

	private static int s = 5;

	void aa() {
	};

	class Innerclass extends Myoutclass implements Interclass {
		@Override
		void aa() {
			super.aa();
		}

		void method() {
			j = 1;// 可以直接访问非静态变量
			Myoutclass.s = 6;
		}
	}

	static class Staticinnerclass extends Myoutclass {
		static int i = 1;

		void method() {
			s = 6;// 可以直接访问静态变量
		}

		static void smehtod() {
			i = 4;
			s = 7;
		}
	}

	public static void main(String[] args) {
		// 非静态内部类的调用，要通过外围类的实例
		Myoutclass.Innerclass inner = new Myoutclass().new Innerclass();
		// 静态内部类的调用，要通过外围类的名字
		Myoutclass.Staticinnerclass sinner = new Myoutclass.Staticinnerclass();
	}
}

内部类分为静态内部类和非静态内部类，但他们都可以访问外围类的私有成员变量

 * 非静态内部类不能定义静态方法和静态变量，但是可以直接访问外围类的静态变量和非静态变量
 * 静态内部类可以定义静态方法和静态变量，但是可以直接访问外围类的静态变量，非静态变量只能通过实例来访问
 * 
 * 内部类可以继承内部类，也可以实现接口,其他类也可以调用某类中的内部类
 * 内部类一样会生成对应的字节码文件，格式为：外围类名$内部类名.class

匿名内部类是没有名字的内部类，一般用于方法的灵活传参，其中最典型的两种方法如下：

class A {
	void fun() {
		System.out.println("fun()");
	}
}

public class Myinnerclass {

	void method(A a) {
		a.fun();
	}

	public static void main(String[] args) {
		Myinnerclass my = new Myinnerclass();
		my.method(new A() {// 类似于new了一个没有名字的A类型临时对象，重写了fun方法内容，传递给method方法接收。调用就是重构的方法。打印"fun2()"
					void fun() {
						System.out.println("fun2()");
					}
				});
	}
}

上面这种一般用于重构类，如一些老系统中有的类我们必须继承后再重构其方法，利用这种方式就比较灵活。

还有一种用于接口的情况，我们一般要将接口的实现类赋给接口，再调用其方法，从而达到部分面向接口编程。但这样必须写多个实现接口的实现类，如果其中有方法需要

重构时，就需要重新写实现接口的类。这时可使用匿名内部类写法技巧，达到代码的简化，如下：

interface Iface { // 声明一个接口
	void fun();
}

class Ifaceimp {
	void test(Iface ia) {// 准备接收该接口的实现类
		ia.fun();
	}
}

public class Myinner2class {
	public static void main(String[] args) {
		Ifaceimp imp = new Ifaceimp();
		imp.test(new Iface() { // 语法：new 接口(){方法体} 相当于创建了一个临时的对象，该对象实现了Iface接口，打印"fun"
					public void fun() {
						System.out.println("fun");
					}
				});

		imp.test(new Iface() { // new 接口()  相当于创建了一个实现该接口的具体的类，只是没有名称(匿名内部类)，这时就可以重构其方法，打印"fun2"
					public void fun() {
						System.out.println("fun2");
					}
				});
	}
}

由此可见，编码时适当的使用匿名内部类写法可以简化代码，但对于初学者而言可读性不强