内部类
内部类是一种类的结构扩充，让一个类的内部除了属性与方法之外还可以存在有其它类的结构，并且内部类也可以定义在方法或代码块中
范例：观察内部类的基本形式
class Outer { // 外部类
private String msg = "Hello World !";
class Inner { // 定义一个内部类
public void print() {
System.out.println(msg);
}
}
public void fun() {
new Inner().print(); // 实例化内部类对象，并且调用print()方法
}
}
public class TestDemo {
public static void main(String args[]) {
Outer out = new Outer(); // 实例化外部类对象
out.fun(); // 调用外部类方法
}
}
程序执行结果：
Hello World !
范例：访问内部类的私有属性
class Outer { // 外部类
private String msg = "Hello World !" ;
class Inner { // 定义了一个内部类
private String info = "世界，你好！" ; // 内部类的私有属性
public void print() {
System.out.println(msg) ;// 直接访问外部类的私有属性
}
}
public void fun() {
Inner in = new Inner() ; // 内部类对象
System.out.println(in.info) ;// 直接利用了内部类对象访问了内部类中定义的私有属性
}
}
public class TestDemo {
public static void main(String args[]) {
Outer out = new Outer() ; // 实例化外部类对象
out.fun() ; // 调用外部类方法
}
}
程序执行结果：
世界，你好！
实例化内部类对象
内部类实例化语法：
外部类.内部类 对象 = new 外部类().new 内部类()；
由于内部类需要使用外部类中的属性，而所有的属性只有在对象实例化之后才会分配空间，所以在实例化内部类对象时首先要实例化外部类对象，但是需要提醒读者的是，以上的格式只是一个基础，指的是在一个类内部只定义一个内部类的情况，而如果说一个内部类中又定义了内部类，则类结构需要继续向下延伸，变为“外部类.内部类1.内部类2 对象 = new 外部类().new 内部类1().new 内部类2()；”
范例：实例化内部类对象
class Outer { // 外部类
private String msg = "Hello World !" ;
class Inner { // 定义了一个内部类
public void print() {
System.out.println(Outer.this.msg) ;
}
}
}
public class TestDemo {
public static void main(String args[]) {
Outer.Inner in = new Outer().new Inner() ; // 实例化内部类对象
in.print() ;
}
}
程序执行结果：
Hello World !
范例：定义私有内部类
class Outer { // 外部类
private String msg = "Hello World !" ;
private class Inner { // 定义私有内部类
public void print() {
System.out.println(Outer.this.msg) ;
}
}
}
由于存在有private声明，所以Inner类只能够在Outer类的内部使用，这个时候将无法在外部实例化Inner类对象，而这个内部类只能够为Outer一个类服务。
使用static定义内部类
使用static定义的属性或者是方法是不受到类实例化对象控制的，所以如果使用了static定义内部类。它一定不可能受到外部类的实例化对象控制。
如果一个内部类使用了static定义的话，那么这个内部类就变为了一个“外部类”，并且只能够访问外部类中定义的static操作。相当于定义一个外部类。
范例：利用static定义内部类
class Outer { // 外部类
private static String msg = "Hello World !"; // static属性
static class Inner { // static定义的内部类等同于外部类
public void print() {
System.out.println(Outer.msg); // 直接访问static属性
}
}
}
此时的代码利用了static定义了内部类，这个内部类就相当于变为了外部类，并且只能够访问Outer类中的static属性或方法。但是此时如果要想取得内部类的实例化对象，使用的语法如下：
外部类.内部类 对象 = new 外部类.内部类() ;
范例：实例化“外部类”对象
class Outer { // 外部类
private static String msg = "Hello World !"; // static属性
static class Inner { // static定义的内部类等同于外部类
public void print() {
System.out.println(Outer.msg);// 直接访问static属性
}
}
}
public class TestDemo {
public static void main(String args[]) {
Outer.Inner in = new Outer.Inner() ;// 实例化“外部类”对象
in.print() ; // 调用方法
}
}
程序执行结果：
Hello World !
在方法中定义内部类
内部类理论上可以在类的任意位置上进行定义，这就包括代码块之中，或者是普通方法之中，而在以后的开发过程之中，在普通方法里面定义内部类的情况是最多的。
class Outer { // 外部类
private String msg = "Hello World !" ;
public void fun() { // 外部类普通方法
class Inner { // 方法中定义的内部类
public void print() {
System.out.println(Outer.this.msg) ;
}
}
new Inner().print() ; // 内部类实例化对象调用print()输出
}
}
public class TestDemo {
public static void main(String args[]) {
new Outer().fun() ;
}
}
程序执行结果：
Hello World !
范例：访问方法中定义的参数或者是变量
class Outer { // 外部类
private String msg = "Hello World !" ;
public void fun(int num) { // 外部类普通方法
double score = 99.9 ; // 方法变量
class Inner { // 方法中定义的内部类
public void print() {
System.out.println("属性：" + Outer.this.msg) ;
System.out.println("方法参数：" + num) ;
System.out.println("方法变量：" + score) ;
}
}
new Inner().print() ;// 内部类实例化对象调用print()输出
}
}
public class TestDemo {
public static void main(String args[]) {
new Outer().fun(100) ;
}
}
程序执行结果：
属性：Hello World !
方法参数：100
方法变量：99.9