java语言学习之内部类，静态内部类，内部类的使用，匿名内部类

一.内部类
1.内部类的作用:
内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类。
内部类成员可以直接访问外部类的私有数据，但外部类不能访问内部类的实现细节，如内部类的成员变量。
匿名内部类适合用于创建那些仅需要一次使用的类。

内部类比外部类可以多使用三个修饰符:private,protected,static，外部类不可以使用这三个修饰符。
非静态内部类不能拥有静态成员。

2.非静态内部类

public class Cow
{
	private double weight;
	// 外部类的两个重载的构造器
	public Cow(){}
	public Cow(double weight)
	{
		this.weight = weight;
	}
	// 定义一个非静态内部类
	private class CowLeg
	{
		// 非静态内部类的两个实例变量
		private double length;
		private String color;
		// 非静态内部类的两个重载的构造器
		public CowLeg(){}
		public CowLeg(double length , String color)
		{
			this.length = length;
			this.color = color;
		}
		// 下面省略length、color的setter和getter方法
		public void setLength(double length)
		{
			this.length = length;
		}
		public double getLength()
		{
			return this.length;
		}
		public void setColor(String color)
		{
			this.color = color;
		}
		public String getColor()
		{
			return this.color;
		}
		// 非静态内部类的实例方法
		public void info()
		{
			System.out.println("当前牛腿颜色是："
				+ color + ", 高：" + length);
			// 直接访问外部类的private修饰的成员变量
			System.out.println("本牛腿所在奶牛重：" + weight);   //①
		}
	}
	public void test()
	{
		CowLeg cl = new CowLeg(1.12 , "黑白相间");
		cl.info();
	}
	public static void main(String[] args)
	{
		Cow cow = new Cow(378.9);
		cow.test();
	}
}

如果外部类成员变量，内部类成员变量与内部类里方法的局部变量同名，则可通过使用this，外部类类名.this作为限定来区分.

public class DiscernVariable
{
	private String prop = "外部类的实例变量";
	private class InClass
	{
		private String prop = "内部类的实例变量";
		public void info()
		{
			String prop = "局部变量";
			// 通过 外部类类名.this.varName 访问外部类实例变量
			System.out.println("外部类的实例变量值："
				+ DiscernVariable.this.prop);
			// 通过 this.varName 访问内部类实例的变量
			System.out.println("内部类的实例变量值：" + this.prop);
			// 直接访问局部变量
			System.out.println("局部变量的值：" + prop);
		}
	}
	public void test()
	{
		InClass in = new InClass();
		in.info();
	}
	public static void main(String[] args)
	{
		new DiscernVariable().test();
	}
}

非静态内部类的成员可以访问外部类的private成员，但是反过来就不成立了。非静态内部类的成员只在非静态内部类范围内是可知的，并不能被外部类直接使用。
如果外部类需要访问非静态内部类的成员，则必须显示创建非静态内部类对象来调用访问其实例成员。

public class Outer
{
	private int outProp = 9;
	class Inner
	{
		private int inProp = 5;
		public void acessOuterProp()
		{
			// 非静态内部类可以直接访问外部类的private成员变量
			System.out.println("外部类的outProp值:"
				+ outProp);
		}
	}
	public void accessInnerProp()
	{
		// 外部类不能直接访问非静态内部类的实例变量,
		// 下面代码出现编译错误
		// System.out.println("内部类的inProp值:" + inProp);
		// 如需访问内部类的实例变量，必须显式创建内部类对象
		System.out.println("内部类的inProp值:"
			+ new Inner().inProp);
	}
	public static void main(String[] args)
	{
		// 执行下面代码，只创建了外部类对象，还未创建内部类对象
		Outer out = new Outer();      //①
		out.accessInnerProp();
	}
}

根据静态成员不能访问非静态成员的规则，外部类的静态方法，静态代码不能访问非静态内部类，包括不能使用非静态内部类定义变量，创建实例等。总之，不允许在外部类的静态成员中直接使用非静态内部类。

public class StaticTest
{
	// 定义一个非静态的内部类，是一个空类
	private class In{}
	// 外部类的静态方法
	public static void main(String[] args)
	{
		// 下面代码引发编译异常，因为静态成员（main()方法）
		// 无法访问非静态成员（In类）
		new In();
	}
}

java中不允许在非静态内部类里定义静态成员，非静态内部类里不能有静态方法，静态成员变量，静态初始化块。

public class InnerNoStatic
{
	private class InnerClass
	{
		/*
		下面三个静态声明都将引发如下编译错误:
		非静态内部类不能有静态声明
		*/
		static
		{
			System.out.println("==========");
		}
		private static int inProp;
		private static void test(){}
	}
}

2.静态内部类

如果使用static来修饰一个内部类，则这个内部类就属于外部类本身，而不属于外部类的某个对象。
静态内部类可以包含静态成员，也可以包含非静态成员。根据静态成员不能访问非静态成员的规则，静态成员内部类不能访问外部类的实例成员，只能访问外部类的类成员。即使是静态内部类的实例方法也不能访问外部类的实例成员，只能访问外部类的静态成员。

静态内部类是外部类的一个静态成员，因此外部类的所有方法，所有初始化块中可以使用静态内部类来定义变量，创建对象等。
外部类依然不能直接访问静态内部类的成员，但可以使用静态内部类的类名作为调用者来访问静态内部类的类成员，也可以使用静态内部类对象作为调用者来访问静态内部类的实例成员。

public class AccessStaticInnerClass
{
	static class StaticInnerClass
	{
		private static int prop1 = 5;
		private int prop2 = 9;
	}
	public void accessInnerProp()
	{
		// System.out.println(prop1);
		// 上面代码出现错误，应改为如下形式：
		// 通过类名访问静态内部类的类成员
		System.out.println(StaticInnerClass.prop1);
		// System.out.println(prop2);
		// 上面代码出现错误，应改为如下形式：
		// 通过实例访问静态内部类的实例成员
		System.out.println(new StaticInnerClass().prop2);
	}
}

接口里也是允许定义内部类，接口里定义的内部类默认使用public static修饰，也就是说，接口内部类只能是静态内部类.

二.内部类的使用
1.在外部类内部使用内部类
2.在外部类以外使用非静态内部类
如果希望在外部类以外的地方访问内部类(包括静态和非静态两种)，则内部类不能使用private访问控制权限，private修饰的颞部类只能在外部类内部使用。对于使用其他访问控制符修饰的内部类，则能在访问控制符对应的访问权限内使用。
1> 省略访问控制符的内部类，只能被与外部类处于同一包中的其他类所访问；
2> 使用protected修饰的内部类，可被与外部类处于同一个包中的其他类和外部类的子类所访问；
3> 使用public修饰的内部类，可以在任何地方被访问。

在外部类以外的地方定义内部类(包括静态和非静态两种)变量的语法格式如下:

OuterClass.InnerClass varName;

从上面语法课可以看出，在外部类以外的地方使用内部类时，内部类完整的类名应该是OuterClass.InnerClass。如果外部类有包名，则还应该增加包名前缀。

由于非静态内部类的对象必须寄生在外部类的对象里，因此创建非静态内部类对象之前，必须先创建其外部类对象。在外部类以外的地方创建非静态内部类实例的语法如下：

OuterInstance.new InnerConstructor()

如何在外部类以外的地方创建非静态内部类的对象，并把它赋给非静态内部类类型的变量。

class Out
{
	// 定义一个内部类，不使用访问控制符，
	// 即只有同一个包中其他类可访问该内部类
	class In
	{
		public In(String msg)
		{
			System.out.println(msg);
		}
	}
}
public class CreateInnerInstance
{
	public static void main(String[] args)
	{
		Out.In in = new Out().new In("测试信息");
		/*
		上面代码可改为如下三行代码：
		使用OutterClass.InnerClass的形式定义内部类变量
		Out.In in;
		创建外部类实例，非静态内部类实例将寄存在该实例中
		Out out = new Out();
		通过外部类实例和new来调用内部类构造器创建非静态内部类实例
		in = out.new In("测试信息");
		*/
	}
}

非静态内部类In类的构造器必须使用外部类对象来调用，代码中super代表调用In类的构造器，而out则代表外部类对象。
下面程序定义了一个子类继承了Out类的非静态内部类In类。

public class SubClass extends Out.In
{
	//显示定义SubClass的构造器
	public SubClass(Out out)
	{
		//通过传入的Out对象显式调用In的构造器
		out.super("hello");
	}
}

2.在外部类以外使用静态内部类
因为静态内部类是外部类类相关的，因此创建静态内部类对象时无需创建外部类对象，在外部类以外的地方创建静态内部类实例的语法如下:

new OuterClass.InnerConstructor()

下面程序示范了如何在外部类以外的地方创建静态内部类的实例。

class StaticOut
{
	// 定义一个静态内部类，不使用访问控制符，
	// 即同一个包中其他类可访问该内部类
	static class StaticIn
	{
		public StaticIn()
		{
			System.out.println("静态内部类的构造器");
		}
	}
}
public class CreateStaticInnerInstance
{
	public static void main(String[] args)
	{
		StaticOut.StaticIn in = new StaticOut.StaticIn();
		/*
		上面代码可改为如下两行代码：
		使用OutterClass.InnerClass的形式定义内部类变量
		StaticOut.StaticIn in;
		通过new来调用内部类构造器创建静态内部类实例
		in = new StaticOut.StaticIn();
		*/
	}
}

总结:
不管是静态内部类还是非静态内部类，它们声明变量的语法完全一样。区别只是在创建内部类对象时，静态内部类只需使用外部类即可调用构造器，而非静态内部类必须使用外部类对象来调用构造器。

三.局部内部类
如果把一个内部类放在方法里定义，则这个内部类就是一个局部内部类，局部内部类仅在该方法里有效。
由于局部内部类不能在外部类的方法以外的地方使用，因此局部内部类也不能使用访问控制符和static修饰符修饰。

如果需要用局部内部类定义变量，创建实例或派生子类，那么都只能在局部内部类所在的方法内进行。

public class LocalInnerClass
{
	public static void main(String[] args)
	{
		// 定义局部内部类
		class InnerBase
		{
			int a;
		}
		// 定义局部内部类的子类
		class InnerSub extends InnerBase
		{
			int b;
		}
		// 创建局部内部类的对象
		InnerSub is = new InnerSub();
		is.a = 5;
		is.b = 8;
		System.out.println("InnerSub对象的a和b实例变量是："
			+ is.a + "," + is.b);
	}
}

四.匿名内部类
适合那种只需要一次使用的类。
定义匿名内部类的格式如下:

new 实现接口() | 父类构造器(实参列表) 
{
	//匿名内部类的类体部分
}

匿名内部类必须继承一个父类，或实现一个接口，但最多只能继承一个父类，或实现一个接口。
1.匿名内部类不能是抽象类，因为系统在创建匿名内部类时，会立即创建匿名内部类的对象。因此不允许将匿名内部类定义成抽象类。
2.匿名内部类不能定义构造器。由于匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以定义初始化块，可以通过实例初始化来完成构造器需要完成的事件。

最常用的创建匿名内部类的方式就是需要创建某个接口类型的对象，如下程序所示：

interface Product
{
	public double getPrice();
	public String getName();
}

public class AnonymousTest
{
	public void test(Product p)
	{
		System.out.println("购买了一个" + p.getName()
			+ "，花掉了" + p.getPrice());
	}
	public static void main(String[] args)
	{
		AnonymousTest ta = new AnonymousTest();
		// 调用test()方法时，需要传入一个Product参数，
		// 此处传入其匿名实现类的实例
		/*ta.test(new Product()
		{
			//由于匿名内部类不能是抽象类，所以匿名内部类
			//必须实现它的抽象父类或者接口里包含的所有抽象方法
			public double getPrice()
			{
				return 567.8;
			}
			public String getName()
			{
				return "AGP显卡";
			}
		});*/

		//方法二
		ta.test(new AnonymousProduct());
	}
}

class AnonymousProduct implements Product {


	public double getPrice(){
		return 567.8;
	}
	public String getName(){
		return "AGP显卡";
	}
}

所以当通过实现接口来创建匿名内部类时，匿名内部类也不能显式创建构造器，因此匿名内部类只有一个隐式的无参数构造器，故new接口名后的括号里不能传入参数值。

如果通过继承父类来创建匿名内部类时，匿名内部类将拥有和父类相似的构造器，此处的相似指的是拥有相同的形参列表。

abstract class Device
{
	private String name;
	public abstract double getPrice();
	public Device(){}
	public Device(String name)
	{
		this.name = name;
	}
	// 此处省略了name的setter和getter方法
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return this.name;
	}
}
public class AnonymousInner
{
	public void test(Device d)
	{
		System.out.println("购买了一个" + d.getName()
			+ "，花掉了" + d.getPrice());
	}
	public static void main(String[] args)
	{
		AnonymousInner ai = new AnonymousInner();
		// 调用有参数的构造器创建Device匿名实现类的对象
		ai.test(new Device("电子示波器")
		{
			public double getPrice()
			{
				return 67.8;
			}
		});
		// 调用无参数的构造器创建Device匿名实现类的对象
		Device d = new Device()
		{
			// 初始化块
			{
				System.out.println("匿名内部类的初始化块...");
			}
			// 实现抽象方法
			public double getPrice()
			{
				return 56.2;
			}
			// 重写父类的实例方法
			public String getName()
			{
				return "键盘";
			}
		};
		ai.test(d);
	}
}