JAVA内部类

//内部类：类中套类，称为内部类
class ExternalClass{
	//外部类属性
	public static String name = "小明";
	//创建一个内部类
	class InternalClass{
		public int age = 10;
		//内部类的方法
		public  void printString(){
			System.out.println("内部类可以直接调用外部类的属性："+name);
			//内部类也可以直接调用外部类的方法
			show();
		}
	}
	//外部类方法
	public void show(){
		System.out.println(name+"今年"+new InternalClass().age+"岁了");
	}
}

class Test{
	public static void main(String[] args){
		ExternalClass.InternalClass outClass = new ExternalClass().new InternalClass();
		outClass.printString();
	}
}





编译后的文件名为：ExternalClass$InternalClass.class，注意，一般的类，与内部类的命名是不同的。

执行结果 为：
内部类可以直接调用外部类的属性：小明
小明今年10岁了

在其它类中调用内部类，声明方式为：

ExternalClass.InternalClass outClass = new ExternalClass().new InternalClass();
不可以直接使用  InternalClass internal = new InternalClass()  直接声明。这点一定要注意

==========================================================================================================================
在外部类中，如果想使用内部 类，必须声明并实例化后才可使用
class ExternalClass{
	public static String name = "小明";
	//创建一个内部类
	class InternalClass{
		public int age = 10;
		public  void printString(){
			System.out.println("在外部为中想使用内部类，必须实例化：");
		}
	}
	//外部类方法
	public void show(){
		//在外部类的方法中，如果想使用内部类，必须实例化
		InternalClass internal = new InternalClass();
		//实例化后，调用内部类的方法
		internal.printString();
	}
}

class Test{
	public static void main(String[] args){
		ExternalClass external = new ExternalClass();
		external.show();
	}
}

执行结果 ：

在外部为中想使用内部类，必须实例化：




===========================================================================================================================
如果一个类是内部类，那么它的外部类的权限只能是默认（default）或是public的
//如果一个类是内部类，那么它的外部类的权限只能是默认（default）或是public的
protected class ExternalClass{
	//创建一个内部类
	class InternalClass{
	}
	//外部类方法
	public void show(){
		
	}
}

class Test{
	public static void main(String[] args){
		
	}
}

编译结果如下 ：

ExternalClass.java:1: 错误: 此处不允许使用修饰符protected
protected class ExternalClass{
          ^
1 个错误




==================================================================================================================================

内部类可以被private修饰，被private修饰的内部 类，称为私有内部类，因为它只能在外部类中实例化，其它类中无法被创建
//如果一个类是内部类，那么它的外部类的权限只能是默认（default）或是public的
class ExternalClass{
	//创建一个被private修饰的内部类，则称为私有内部类
	private class InternalClass{
		String name = "小子";
		public void printName(){
			System.out.println("私有内部类被调用："+name);
		}
	}
	//外部类方法
	public void show(){
		
	}
}

class Test{
	public static void main(String[] args){
		//私有内类，无法在外部类的其它中实例化
		ExternalClass.InternalClass external = new ExternalClass().new InternalClass();
	}
}

执行结果如下：

ExternalClass.java:19: 错误: ExternalClass.InternalClass可以在ExternalClass中访问private
                ExternalClass.InternalClass external = new ExternalClass().new InternalClass();
                             ^
ExternalClass.java:19: 错误: ExternalClass.InternalClass可以在ExternalClass中访问private
                ExternalClass.InternalClass external = new ExternalClass().new InternalClass();
                                                                               ^
2 个错误




-------------------------------------
只所以称为私有内部类，是因为只有在外部类中，才可以实例化内部类，其它类无权访问
//如果一个类是内部类，那么它的外部类的权限只能是默认（default）或是public的
class ExternalClass{
	//创建一个被private修饰的内部类，则称为私有内部类
	private class InternalClass{
		String name = "小子";
		public void printName(){
			System.out.println("私有内部类被调用："+name);
		}
	}
	//外部类方法
	public void show(){
		//只有在内部类中，才可以实例化私有内部 类
		InternalClass internal = new InternalClass();
		internal.printName();
	}
}

class Test{
	public static void main(String[] args){
		//私有内类，无法在外部类的其它中实例化,只能在外部类中使用
		ExternalClass external = new ExternalClass();
		external.show();
	}
}

执行结果：

私有内部类被调用：小子



====================================================================================================================================
内部类可以被static修饰，这种内部类称为静态内部类
//如果一个类是内部类，那么它的外部类的权限只能是默认（default）或是public的
class ExternalClass{
	//内部类可以被static修饰，称为静态内部类
	static class InternalClass{
		String name = "小子";
		public void printName(){
			System.out.println("私有内部类被调用："+name);
		}
	}
	//外部类方法
	public void show(){
		
	}
}

class Test{
	public static void main(String[] args){
		//内部类的实例化方法为：外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
		//静态内部类的实例化方法为：外部类名.内部类名 变量名 = new 外部类名.内部类名();
		ExternalClass.InternalClass external = new ExternalClass.InternalClass();
		external.printName();
	}
}
执行结果 为：

私有内部类被调用：小子



注意内部类与静态内部在其它类中实例化的区别：

内部类的实例化方法为： 外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

静态内部类的实例化方法为： 外部类名.内部类名 变量名 = new 外部类名.内部类名();





还需要注意一点，一般类是无法被static修饰的，代码如下：
static class Test{
	
}
编译结果如下 ：

Test.java:1: 错误: 此处不允许使用修饰符static
static class Test{
       ^
1 个错误