java 四种内部类 使用细节(含代码)

内部类

定义在类体部,方法体部,甚至比方法体更小的代码块内部的类(if 语句里面等)

1.静态内部类（内部类中最简单的形式）

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

/**
 * @author gress
 *静态内部类
 */
public class StaticInnerTest {
	public static void main(String[] args) {
 
		StaticOuter.StaticInner si = new StaticOuter.StaticInner();
		si.test2();
		//StaticOuter.StaticInner.test();
		System.out.println("si.b = "+si.b);
		System.out.println("si.a = "+si.a);
	//	System.out.println("StaticOuter.b  = "+StaticOuter.b);  这里报错
	}
 
}
 
class StaticOuter {
private int a = 100;
private static int b = 150;
public static void test(){
	System.out.println("Outer static test ...");
}
public  void test2(){
	System.out.println("Outer instabce test ...");
}	
 
	static class StaticInner {
		public  int a = 200;
		static int b =300;
		public static void test(){
			System.out.println("Inner static test ...");
		}
		public  void test2(){
			System.out.println("Inner instance test ...");
			StaticOuter.test();
			new StaticOuter().test2();
			System.out.println("StaticOuter.b  = "+StaticOuter.b);
		}	
	}
}

2.成员内部类(实例内部类)

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

/**
 * @author gress
 * 实例内部类
 *
 */
class MemberOuter{
	
	private String s1 = "Outer InstanceMar";
	private String s2 = "OuterStatic s2";
	public void setS1(String s1) {
		this.s1 = s1;
		new MemberOuter().new MemberInner();
		this.new MemberInner();  //此时MemberOuter已经实例化完成,所以可以使用this
		new MemberInner().test2();
	}
	public static void  test2 (){
		new MemberOuter().new MemberInner();
		/*this.new MemberInner();  
		 * 此时MemberOuter没有实例化完成,所以不可以使用this
		 * static 是在MemberOuter构造器前使用,所以此时this不能使用
		 * 
*/
		
	}
 
 
	class MemberInner{
		 String s1= "Inner  instanceMae  ";
		static final String s4 = "static final  MemberInner";
			
				void test2(){
					System.out.println(" s1 =" + s1);
					System.out.println(" Outter MemberOuter.this.s1 =" + MemberOuter.this.s1);
					System.out.println("s2 = "+s2);
				}
	}
	
}
 
public class MemberInnerTest {
 
	public static void main (String args []){
	/*	MemberOuter.MemberInner mm =  new MemberOuter().new MemberInner();
		mm.test2();*/
		
		MemberOuter mo = new MemberOuter();
		mo.setS1("");
		
		
	}
}

3.局部内部类:

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

/**
 * @author gress 局部内部类
 *
 */
public class LocalInnerTest {
 
	private int a = 1;
	private static int b = 2;
 
	public void test() {
		final int c = 3;
		class LocalInner {
			public void add1() {
				System.out.println("a= " + a);
				System.out.println("b= " + b);
				System.out.println("c= " + c);
			}
		}
		new LocalInner().add1();
	}
 
	static public void test2() {
		final int d = 5;
		class LocalInner2 {
			public void add1() {
				// System.out.println("a= " + a);
				System.out.println("b= " + b);
				System.out.println("c= " + d);
			}
		}
		new LocalInner2().add1();
	}
 
	public static void main(String args[]) {
 
		// LocalInnerTest() lc = new LocalInnerTest();
		new LocalInnerTest().test2();
		new LocalInnerTest().test();
	}
}

4.匿名内部类

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

/**
 * @author gress 匿名内部类,我只会使用一次的类
 * 
 * 就假如我想吃一个泡面,但我不可能建一个厂,制造一个流水线,生产一包泡面之后就在也不去使用这个泡面厂了
 * 所以这里引申出匿名内部类 ,而我们建立的泡面厂就像这里构建的一个类Pencil 铅笔类一样
 */
interface Pen {
	public void write();
}
 
class  Pencil implements Pen {
	@Override
	public void write() {
		//铅笔 的工厂
	}
}
 
class Person {
	public void user(Pen pen) {
		pen.write();
	}
}
 
public class AnyInnerTest {
	public static void main(String args[]) {
		Person guo = new Person();
		
		guo.user(new Pen() {
			@Override
			public void write() {
				System.out.println("写子");
			}
		});
	}
 
}