Java 内部类

允许在一个类的内部再定义类（这个在内部定义的类称作内部类），内部类就是一个类中包含着的另外一个类。
如同一个人是由头、胳膊、脚等身体器官组成，内部类相当于其中的某个器官之一，例如头：头也有自己的属性（眼睛，嘴巴，鼻子）和行为（嘴巴可以吃饭），
不能单方面用属性或者方法表示一个头，也需要一个类，头相当于内部类，人相当于外部类。
内部类根据类的位置，修饰符，和定义的方式可以分为成员内部类，静态内部类，方法内部类。

1、成员内部类

①在一个类中可以定义成员变量，成员方法，还可以定义类，这样的类被称作成员内部类，在成员内部类中可以访问外部类的所有成员，内部类也可以在外部类中被使用。注意：外部类不能直接使用内部类的成员和方法，可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。如下例：

class Outer {
	private int num = 4; // 定义类的成员变量
	// 定义一个成员内部类
	class Inner {
		void show() {
			// 在成员内部类的方法中访问外部类的成员变量
			System.out.println("num = " + num);
		}
	}
	// 定义一个成员方法，方法中访问内部类
	public void test() {
		Inner inner = new Inner();
		inner.show();
	}
 }
 public class Example16 {
	public static void main(String[] args) {
		Outer outer = new Outer(); // 创建外部类对象
		outer.test(); // 调用 test() 方法
	}
 }

输出：num = 4

②如果想通过外部类去访问内部类，则需要通过外部类对象去创建内部类对象，格式如下：

外部类名.内部类名 变量名=new 外部类名().new 内部类名();

如下面代码

class Outer {
	private int num = 4; // 定义类的成员变量
	// 定义一个成员内部类
	class Inner {
		void show() {
			// 在成员内部类的方法中访问外部类的成员变量
			System.out.println("num = " + num);
		}
	}

 }

public class Example2 {
	public static void main(String[] args) {
		Outer.Inner inner = new Outer().new Inner(); // 创建内部类对象
		inner.show(); // 调用 test() 方法
	}
}

输出：num = 4

③如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如下例：

在编辑器中定义了成员内部类 Inner ，并在内部类的 show 方法中输出外部类和内部类的属性值。

package tcy01;

//外部类HelloWorld
public class HelloWorld{
    
    //外部类的私有属性name
    private String name = "外部类中的name";
    
    //外部类的成员属性
    int age = 22;
    
	//成员内部类Inner
	public class Inner {
		String name = "内部类中的name";
        //内部类中的方法
		public void show() { 
			System.out.println("外部类中的name：" +  HelloWorld.this.name                );
			System.out.println("内部类中的name：" + this.name                 );
			System.out.println("外部类中的age：" + age);
		}
	}
    
	//测试成员内部类
	public static void main(String[] args) {
        
        //创建外部类的对象
		HelloWorld o = new HelloWorld (); 
        
        //创建内部类的对象
		Inner inn = o.new Inner();
        
        //调用内部类对象的show方法
		inn.show();
	}
}

结果：

外部类中的name：外部类中的name
内部类中的name：内部类中的name
外部类中的age：22

④注意：

如果将内部类声明为私有，外界将无法访问，如果将Inner类使用private修饰，则该程序编译会报错。

2、静态内部类

使用static关键字来修饰的一个成员内部类称作静态内部类，静态内部类只能访问外部类的静态成员变量，具有局限性。

①创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

class Outer {
	private static int num = 4;  //静态变量
	// 定义一个静态内部类
	static class Inner {
		void show() {
			System.out.println("num = " + num);
		}
	}
}
class Example2 {
	public static void main(String[] args) {
		Inner inner = new Inner(); 	   // 创建内部类对象，和非静态的创建方式不同
		inner.show(); 					// 调用内部类的方法
	}
}

输出：num = 4

注意：

①如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

②静态内部类不能直接访问外部类的非静态成员，但可以通过new 外部类().成员 的方式访问 

①②例子如下：

package tcy01;

//外部类
public class HelloWorld {
    
    // 外部类中的静态变量score
    private static int score = 84;
    private  String name ="小田";
    // 创建静态内部类
	public static class SInner {
        // 内部类中的变量score
        int score = 91;
		public void show() {
			System.out.println("访问外部类中的score：" + HelloWorld.score);
			System.out.println("访问内部类中的score：" + score);
		}
		public void introduce() {
			System.out.println("访问外部类中的name：" + new HelloWorld().name);
		}
	}

	// 测试静态内部类
	public static void main(String[] args) {
		// 直接创建内部类的对象
        SInner si=new SInner();
        
        // 调用show方法
		si.show();
		si.introduce();
	}
}

结果：
访问外部类中的score：84
访问内部类中的score：91
访问外部类中的name：小田

③在静态内部类中可以定义静态成员，而在非静态内部类中不可以定义静态成员，如下面代码是错的

class Outer {
	// 非静态内部类
	  class Inner {
	     static int num = 4;  //这里不能这样定义静态变量，因为内部类不是静态的，
		 void show() {
			 System.out.println("num = " + num);
		 }
	}
}

3、方法内部类

方法内部类是指在成员方法中定义的类，它只能在当前方法中被使用，方法内部类也可以访问外部类的成员变量。

例①：

class Outer {
	private int num = 4;  // 定义成员变量
	public void test() {
		// 在方法中定义内部类
		class Inner {
			void show() {
				System.out.println("num = " + num);  // 访问外部类的成员变量
			}
		}
		Inner in = new Inner();                 // 创建内部类对象
		in.show();				// 调用内部类的方法
	}
}
public class Example19 {
	public static void main(String[] args) {
		Outer outer = new Outer();	// 创建外部类对象
		outer.test();				// 调用 test() 方法
	}
}

输出：num = 4

上面代码中，Inner是方法内部类，程序只能在方法中创建该类的实例对象并调用show()方法。

例②：

package tcy01;

//外部类
public class HelloWorld {
    
    private String name = "小田";
    
    // 外部类中的show方法
    public void show() { 
		// 定义方法内部类
		class MInner {
			int score = 83;
			public int getScore() {
				return score + 10;
			}
		}
        
		// 创建方法内部类的对象
        MInner minner = new MInner();
        
        // 调用内部类的方法
		int newScore=minner.getScore();
        
		System.out.println("姓名：" + name + "\n加分后的成绩：" + newScore);
	}
    
	// 测试方法内部类
	public static void main(String[] args) {
        
		// 创建外部类的对象
        HelloWorld mo= new HelloWorld ();
        
        // 调用外部类的方法
		mo.show();
	}
}

结果：

姓名：小田
加分后的成绩：93

注意：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。