内部类——嵌套类

1、概述

    static修饰内部类的含义：

    一、普通内部类通常有一个指向外部类的隐式引用，若内部类用static修饰，此关系将消失，嵌套类也将不须要经过外部引用实例进行建立；

    二、不能从嵌套类中访问非静态的外围类成员；

    三、普通内部类的字段和方法只能放到类的外层层次上，即普通内部类不能含有静态数据(字段、方法和嵌套类)；而嵌套类是能够包含静态数据的。

2、代码说明

    一、公共接口

            Contents.java

package com.lh.innerclass.class4;

public interface Contents {
	int value();
}

            Destination.java

package com.lh.innerclass.class4;

public interface Destination {
	String readLabel();
}

    二、嵌套类测试Parcel.java

package com.lh.innerclass.class4;

public class Parcel {
	private static class ParcelContents implements Contents{
		private int i=11;
		
		public int value(){
			return this.i;
		}
	}
	
	//普通内部类中不能有静态成员！！！
	protected static class ParcelDestination implements Destination{
		private String label;
		
		//内部类的构造器通常设置为私有
		private ParcelDestination(String whereTo){
			this.label = whereTo;
		}
		
		private static int x = 10;
		
		public String readLabel(){
			return this.label;
		}
		
		static void f(){
			System.out.println("ParcelDestination.f()");
		}
		
		//嵌套类中能够有嵌套类
		static class AnotherLevel{
			private static int x = 10;
			
			static void f(){
				System.out.println("ParcelDestination.AnotherLevel.f()");
			}
		}
		
		//嵌套类中也能够有普通内部类
		private class InnerClass{
			private int x = 10;
			
			//普通内部类中不能定义静态字段
//			private static String aa = "a";
			private String a;
			
			void f(){
				System.out.println("ParcelDestination.InnerClass.f()");
			}
			
			//普通内部类中不能定义静态方法
//			static void ff(){
//				System.out.println("ParcelDestination.InnerClass.f()");
//			}
		}
	}
	
	static Contents contents(){
		return new ParcelContents();
	}
	
	static Destination destination(String s){
		return new ParcelDestination(s);
	}

	public static void main(String[] args) {
		Parcel.contents();
		Parcel.destination("Tasmania");
	}

}

    三、接口内部类测试ClassInInterface.java

package com.lh.innerclass.class4;

/****
 * 
 * 接口内部的类：默认带有static关键字的嵌套类！
 * 
 * @author Liu
 *
 */
public interface ClassInInterface {
	void howdy();
	
	//默认带有static关键字的嵌套类！
	class Test implements ClassInInterface{

		public void howdy() {
			System.out.println("howdy！");
		}
		
		public static void main(String[] args) {
			new Test().howdy();
		}
		
	}
}

    注：在接口中定义的嵌套类默认是public的且带关键字static

    四、多层嵌套内部类的使用MultiNestingAccess.java

package com.lh.innerclass.class4;

/****
 * 
 * 从多层嵌套类中访问外部类的成员
 * 此处嵌套类含义：普通内部类
 * 
 * @author Liu
 *
 */
class MNA{
	 void f(){
		System.out.println("MNA.f()");
	 }
	 class A{
		void g(){
			System.out.println("MNA.A.g()");
		}
		
		class B{
			void h(){
				System.out.println("MNA.A.B.h()");
				A.this.g();
				MNA.this.f();
			}
		}
	}
}

public class MultiNestingAccess {

	public static void main(String[] args) {
		new MNA().new A().new B().h();
	}

}