外部类、外部接口、类的内部类、类的内部接口、接口的内部类、接口的内部接口 修饰符

/**
 * 外部类，顶级类
 * 
 * Illegal modifier for the class TestClass4; only public, abstract & final are permitted
 *
 */
public class TestClass1 {

}

class TestClass2 {
	
}

/**
 * 注意： final 必须在 class 前面 
 */
final class TestClass5 {
	
}

/**
 * 注意： abstract 必须在 class 前面， abstract final不能共存
 */
abstract class TestClass6 {
	
}

//protected class TestClass3 {
//	
//}
//
//private class TestClass4 {
//	
//}

/**
 * 外部接口
 * 
 * 自带 abstract ，加不加abstract效果一样、
 * 
 * Illegal modifier for the interface TestInterface3; only public & abstract are permitted
 * 
 * 与类一样，public 修饰的接口必须与文件名相同
 *
 */
public interface TestInterface1 {

}

/**
 * 注意： 与类一样这里也是包访问权限
 */
interface TestInterface2 {
	
}

/**
 * 注意：abstract 必须在 interface 前面 
 */
abstract interface TestInterface5 {
	
}

//protected interface TestInterface3 {
//	
//}
//
//private interface TestInterface4 {
//	
//}

/**
 * 类的内部类
 * 
 * 类的内部类的访问修饰符可以是四个中的任意一个
 * 
 * 非静态内部类对象必须在外部类对象引用的基础上创建 比如q为外部类对象引用  需要 非静态内部类 n = q.new 非静态内部类();，
 * 所以，拥有外部类对象之前是不可能拥有非静态内部类对象的。
 * 非静态内部类可以被普通类继承，但是必须在普通类的构造器的第一行，使用外部类的对象.super()显式调用内部类的构造器，比如enclosingClassReference.super()。
 * 
 * 静态内部类和普通类几乎差不多，可以直接new 出来，可以被普通类继承。
 * 
 * 可以在非静态内部类中继续定义非静态内部类，但是不能定义静态内部类。因为静态内部类不能依赖于对象。
 * 所以可以这么说，外部类如果不算修饰符的差异也相当于静态内部类，
 * 可以在静态内部类中定义静态内部类和非静态内部类，非静态内部类中只能定义非静态内部类，可以层层往下。
 * 
 * 局部类可以被局部类继承，但不能被其他类继承，继承类的范围仅限于大括号以内的局部类，
 * 同时局部类可以继承外部类，静态内部类。
 * 
 * Illegal modifier for the member class TestClassMemberClass6; 
 * only public, protected, private, abstract, static & final are permitted
 * 
 * Illegal modifier for the local class TestClassMemberClass8; only abstract or final is permitted
 *
 */
public class TestClassMemberClass {
	
	public class TestClassMemberClass1 {}
	protected class TestClassMemberClass2 {}
	class TestClassMemberClass3 {}
	private class TestClassMemberClass4 {}
	
	public final class TestClassMemberClass5 {}
	
	public abstract class TestClassMemberClass6 {}
	
	public static class TestClassMemberClass7 {}
	
	public class TestClassMemberClass12 {
		public class TestClassMemberClass13 {
			
		}
		
		/**
		 * The member type TestClassMemberClass14 cannot be declared static; 
		 * static types can only be declared in static or top level types
		 *
		 */
//		public static class TestClassMemberClass14 {
//			
//		}
	}
	
	public static class TestClassMemberClass15 {
		public class TestClassMemberClass16 {
			
		}
		public static  class TestClassMemberClass17 {
			
		}
	}
	
	{
		/**
		 * 局部类
		 */
		class TestClassMemberClass9 {
			
		}
		
	}
	
	static {
		class TestClassMemberClass10 {
			
		}
	}
	
	public void method1() {
		
		/**
		 * 局部类
		 */
		class TestClassMemberClass8 {
			
		}
		
		class B extends TestClassMemberClass8 {
			
		}
		
	}
	
	public static void method2() {
		class TestClassMemberClass11 {
			
		}
	}
	
}

/**
 * 
 * 类的内部接口
 * 
 * 类的内部接口的访问修饰符可以是四个中的任意一个
 * 
 * 一旦定义内部接口，便会自带static 和 abstract，所以放不放这两个关键字效果都是一样的。
 * 
 * 也可以在静态内部类中继续定义内部接口，因为 静态内部类和外部类几乎一样，不依赖于对象。
 * 非静态内部类类就不可以了
 * 
 * 不能定义局部接口
 * 
 * 所以，个人理解，类中的内部接口与类中的静态内部类 基本一致。
 * 
 * Illegal modifier for the member interface TestClassMemberInterface5;
 *  only public, protected, private, abstract & static are permitted
 *  
 *  The member interface TestClassMemberInterface7 can only be defined 
 *  inside a top-level class or interface or in a static context
 *
 */
public class TestClassMemberInterface {
	
	public interface TestClassMemberInterface1 {}
	protected interface TestClassMemberInterface2 {}
	interface TestClassMemberInterface3 {}
	private interface TestClassMemberInterface4 {}
	
	public abstract interface TestClassMemberInterface5 {}
	
	public static interface TestClassMemberInterface6 {}
	
	public static class TestClassMemberInterfaceClass1 {
		// 可以在静态内部类中继续定义内部接口，因为 静态内部类和外部类几乎一样，不依赖于对象。
		public interface TestMemberInterface10 {
			
		}
	}
	
	public class TestClassMemberInterfaceClass2 {
		/**
		 * The member interface TestMemberInterface11 can only be defined inside a top-level class 
		 * or interface or in a static context
		 */
//		public interface TestMemberInterface11 {
//			
//		}
	}
	
	{
		// 不能定义局部接口
//		interface TestClassMemberInterface8 {}
	}
	
	static {
		// 静态块中也不行，静态方法中也不行
//		interface TestClassMemberInterface9 {}
	}
	
	public void method1() {
		// 不能定义局部接口
//		interface TestClassMemberInterface7 {}
	}

}

/**
 * 接口的内部类
 *	
 * 访问修饰符只能 public 和 默认（包访问权限）
 * 
 * 自动 static ，加不加一样
 * 
 * The interface member type TestInterfaceMemberClass2 can only be public
 *
 */
public interface TestInterfaceMemberClass {
	
	public class TestInterfaceMemberClass1 {}
//	protected class TestInterfaceMemberClass2 {}
	class TestInterfaceMemberClass3 {}
//	private class TestInterfaceMemberClass4 {}
	
	public final class TestInterfaceMemberClass5 {}
	
	public abstract class TestInterfaceMemberClass6 {}
	
	public static class TestInterfaceMemberClass7 {}
	
	public class TestInterfaceMemberClass12 {
		public class TestInterfaceMemberClass13 {
			
		}
		
		/**
		 * 注意：因为接口中的内部类加不加static 都是static，所以此处可行。
		 * @author cmdsm
		 *
		 */
		public static class TestInterfaceMemberClass14 {
			
		}
	}
	
	public static class TestInterfaceMemberClass15 {
		public class TestInterfaceMemberClass16 {
			
		}
		public static  class TestInterfaceMemberClass17 {
			
		}
	}
	
}

/**
 * 接口的内部接口
 * 
 * 访问修饰符只能默认（包访问权限） 和 public
 * 内部接口自动static
 * 
 * The interface member type TestInterfaceMemberInterface2 can only be public
 *
 */
public interface TestInterfaceMemberInterface {
	
	public interface TestInterfaceMemberInterface1 {}
//	protected interface TestInterfaceMemberInterface2 {}
	interface TestInterfaceMemberInterface3 {}
//	private interface TestInterfaceMemberInterface4 {}
	
	public abstract interface TestInterfaceMemberInterface5 {}
	
	public static interface TestInterfaceMemberInterface6 {}
	
	public static class TestInterfaceMemberInterfaceClass1 {
		// 可以在静态内部类中继续定义内部接口，因为 静态内部类和外部类几乎一样，不依赖于对象。
		public interface TestMemberInterface10 {
			
		}
	}
	
	public class TestInterfaceMemberInterfaceClass2 {
		/**
		 * The member interface TestMemberInterface11 can only be defined inside a top-level class 
		 * or interface or in a static context
		 */
		public interface TestMemberInterface11 {
			
		}
	}
	
}

	public protected 默认 private	abstract final	static	备注
外部类	public 或 默认（包）	abstract 或 final	不行
外部接口	public 或 默认（包）	abstract（自动）	不行
类的内部类	四个中任意一个	abstract 或 final	可以	静态内部类（static） 非静态内部类（不加）
类的内部接口	四个中任意一个	abstract（自动）	自动	与静态内部类相似 除了abstract
接口的内部类	public 或 默认（包）	abstract 或 final	自动	与静态内部类相似
接口的内部接口	public 或 默认（包）	abstract（自动）	自动	与类的内部接口相似 除了访问权限

注意：（1）静态内部类（内部接口）或者外部类 可以添加静态的和非静态的，非静态内部类只能添加非静态内部类。实际上非静态也就是非静态内部类。

   （2）接口的内部类内部接口默认访问修饰符的访问权限经过我自己测试确实是包（jdk8），但java编程思想上写的是默认访问权限也是自动public，不知道什么情况。

总结：类的修饰符： public protected 默认 private abstract final static

   接口的修饰符： public protected 默认 private abstract static（区别只在 final）

note：Java8 接口支持 default 有方法体的方法。