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 = ne
4000
w 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 修饰符。