四大内部类

1.实例内部类

public class ShiliTest 
{
	private int a = 10;
	/**实例内部类
	 * 1)位置：类的内部,方法外部
	 * 2)修饰：没有static,允许私有化
	 * 3)对象：依托于外部类对象(先有外部类对象)
	 * 4)访问：允许访问外部类所有成员
	 * */
	class inner 
	{
		private int a = 20;
		public void show()
		{
			System.out.println(a);
			System.out.println(ShiliTest.this.a);
		}
	}
	
	/**
	 * 因为main方法是一个静态方法，而内部类不是静态内部类，所以需要依托外部类对象
	 * 构建、访问
	 * @param args
	 */
	public static void main(String[] args) {
		ShiliTest s = new ShiliTest();
		inner ss = s.new inner();
		ss.show();
	}
}

2.静态内部类

public class StaticTest
{
	private int a = 10;
	/**静态内部类
	 * 位置:类的内部，方法外部
	 * 修饰:有static修饰，允许私有化
	 * 对象:不依赖于外部类对象(相当于是一个外部类)
	 * 访问:只允许访问外部类静态成员
	 * */
	static class inner
	{
		private int a = 20;
		public void show()
		{
			System.out.println(a);
		}
	}
	
	public static void main(String[] args) {
		inner s = new inner();
		s.show();
	}
}

3.局部内部类

public class JubuTest 
{
	private int a = 10;
	public void f()
	{
		final int b = 30;
		/**局部内部类
		 * 位置:方法的内部
		 * 修饰:不能使用static,只能default修饰
		 * 访问:允许访问外部类所有成员，但只能访问方法内部使用final修饰的变量
		 * */
		class inner
		{
			private int a = 20;
			public void show()
			{
				System.out.println(a);
				System.out.println(b);
				System.out.println(JubuTest.this.a);
			}
		}
		inner s = new inner();
		s.show();
	}
	
	public static void main(String[] args) {
		JubuTest s = new JubuTest();
		s.f();
	}
}

4.匿名内部类

class InnerA{public void show(){}}
abstract class InnerB{int a = 10; public abstract void show();}
interface InnerC{void show();}


public class NimingTest01 
{
	public static void main(String[] args) {
		InnerA a = new InnerA();
		/**
		 * 匿名内部类一般用于构建抽象类对象实例，或者接口对象实例时，不用写类名，
		 * 但是其他对象和方法也不能调用匿名内部类内的方法和成员，适合一次性使用
		 */
		InnerB b = new InnerB() {
			
			public void show() {
				System.out.println("B");
				System.out.println(super.a);
			}
		};
		
		
		InnerC c = new InnerC() {
			
			public void show() {
				System.out.println("C");
			}
		};
		
		a.show();
		b.show();
		c.show();
	}
	
}

前些日子学的怕忘了，做下笔记