JAVA中的 内部类

1. 内部类

1.静态内部类

• 1.声明在类体部，方法体外，并且使用static修饰的内部类
• 2.访问特点可以类比静态变量和静态方法
• 3.脱离外部类的实例独立创建
  在外部类的外部构建内部类的实例
  new Outer.Inner();
  在外部类的内部构建内部类的实例
  new Inner();
• 4.静态内部类体部可以直接访问外部类中所有的静态成员，包含私有

public class StaticInnerClassDemo {
   
   public static void main(String[] args) {
   	// 实例化外部类。
   	Foo foo = new Foo();
   	// 如何实例化内部类。
   	Koo koo = new Foo.Koo();
   	System.out.println(koo.b);
   	koo.show();

   	}

   }


class Foo{
   		
   private static int a = 10;
   // 内部类
   static class Koo{
   	public int b = 20;
   	public void show(){
   	System.out.println("hello innerclass"+a);// 能够访问外部静态变量。
   	}
   }
}

2.成员内部类

• 1.没有使用static修饰的内部类。
• 2.在成员内部类中不允许出现静态变量和静态方法的声明。
  static只能用在静态常量的声明上。
• 3.成员内部类中可以访问外部类中所有的成员(变量，方法)，包含私有成员，如果在内部类中定义有和外部类同名的实例变量，访问：
  OuterClass.this.outerMember;
• 4.构建内部类的实例，要求必须外部类的实例先存在
  外部类的外部/外部类的静态方法：new Outer().new Inner();
  外部类的实例方法：
  new Inner();
  this.new Inner();

public class InnerClassDemo {
	
	public static void main(String[] args){
		Joo joo = new Joo();
		// 获取内部类实例
				Noo noo = joo.new Noo();
				System.out.println(noo.b);
				noo.show();

			}

		}

		// 外部类
		class Joo{
			private int a = 10;
			class Noo{
				public  int b = 20;
				public void show(){
					System.out.println(a+b);
				}
			}
			
			public void show(){
				Noo noo = new Noo();
				System.out.println(noo.b);
	}

}

3.局部内部类

• 1.定义在方法体，甚至比方法体更小的代码块中
• 2.类比局部变量。
• 3.局部内部类是所有内部类中最少使用的一种形式。
• 4.局部内部类可以访问的外部类的成员根据所在方法体不同。
  如果在静态方法中：
  可以访问外部类中所有静态成员，包含私有
  如果在实例方法中：
  可以访问外部类中所有的成员，包含私有。
  局部内部类可以访问所在方法中定义的局部变量，但是要求局部变量必须使用final修饰。

public class LocalInnerClass {
	
		public static void main(String[] args) {
		   
			int a = 20;
			class Hoo{
				int b = 20;
				public void show(){
					System.out.println(b+a);
//					System.out.println(a++);// 内部类允许访问外部的局部变量，但不能改变其值。
				}
			}
			Hoo hoo = new Hoo();
			hoo.show();
	}
	
}

4.匿名内部类

• 1.没有名字的局部内部类。
• 2.没有class,interface,implements,extends关键字
• 3.没有构造器。
• 4.一般隐式的继承某一个父类或者实现某一个接口

public class AnonInnerClassDemo {

	public static void main(String[] args) {
		// 实例化匿名内部类。
		Aoo aoo = new Aoo(){
			public void show(){
				System.out.println("hello zhangsan");
				
			}
		};
		aoo.show();
		
		System.out.println("***************");
		new Aoo(){
			public void show(){
				System.out.println("匿名内部类");
			}
		}.show();
		
		// 匿名内部类，重写抽象类方法。
		new Coo(){
			@Override
			public void getCoo() {
				System.out.println("匿名内部类，重写抽象方法");
			}
		}.getCoo();
		
		//匿名内部类，重写接口中的方法。
		new Doo() {
			@Override
			public void getDoo() {
               System.out.println("重写接口中的方法");				
			}
		}.getDoo();
		
		// 匿名内部类获取实例。
		Doo doo = new Doo() {
			@Override
			public void getDoo() {
				
			}
		};
		doo.getDoo();

	}

}

// 普通类。
class Aoo{
	public int a = 10;
	public void show(){
		System.out.println(a);
	}
}
// 子类继承父类。
class Boo extends Aoo{
	public void show(){
		System.out.println("hello world");
	}
}
// 抽象类。
abstract class Coo{
	public abstract void getCoo();
}

// 接口
interface Doo{
	public abstract void getDoo();
}