内部类（嵌套类）

嵌套类是指被定义在另一个类的内部的类。

嵌套类存在的目的是：只是为它的外部类提供服务；

outer.java里面定义了一个内部类inner，运行时，一旦编译成功，就会生成两个完全不同的.class文件，分别是outer.class和outer$inner.class。

嵌套类分为四种：静态成员类，非静态成员类（成员内部类），匿名类，局部类。

内部类：非静态成员类（成员内部类），匿名类，局部类。

1.静态内部类

public class Outer {

    public static String name = "Joe";
    private String password = "0806";

    //静态内部类
    public static class inner{
        public static void print1(){
            System.out.println(name);
            //调用外部类的静态方法
            outerPrint();
        }
        public void print2(){
            System.out.println(name);
        }
    }

    public static void outerPrint(){
        System.out.println("Outer static method!");
    }

    public static void main(String[] args){
       //静态内部类的静态方法调用
        Outer.inner.print1();
        //静态内部类的非静态方法调用
        Outer.inner inner = new Outer.inner();
        inner.print2();
    }
}

输出结果：

Joe
Outer static method!
Joe

通过这个例子可以看出：

　　♥ 静态内部类中可以有静态方法，也可以有非静态方法；

　　♥ 静态内部类只能访问其外围类的静态成员和静态方法；

　　♥ 和普通的类一样，要访问静态内部类的静态方法，可以直接“.”出来，不需要一个实例；

　　♥ 要访问静态内部类的非静态方法，必须拿到一个静态内部类的实例对象；

　　♥ 实例化静态内部类：外围类.内部类  xxx = new 外围类.内部类();

可以把静态内部类看作普通的类，只是碰巧被声明在另一个类的内部而已；如果静态内部类被声明为私有的，那么它就只能在外围类的内部才可以访问。

非静态成员类（成员内部类）

成员内部类是最常见的内部类，就是在外部类的基础上按照一般定义类的方式定义类，举个例子：

public class Outer {

    public static String name = "Joe";
    private String password = "0806";

    //私有成员内部类
    private class PrivateInner{
        public void print1(){
            System.out.println("private " + name);
            System.out.println("public " + password);
            //调用外部类的静态方法
            outerPrint();
        }
    }
    //公有的成员内部类
    public class PublicInner{
        public void print2(){
            String password = "0810";
            System.out.println("public " + name);
            System.out.println("public " + password);
            //调用外部类的静态方法
            outerPrint();
        }
    }
    public static void outerPrint(){
        System.out.println("Outer static method!");
    }

    public static void main(String[] args){
        Outer outer = new Outer();
        Outer.outerPrint();
        //实例化私有成员内部类
        Outer.PrivateInner privateInner = outer.new PrivateInner();
        privateInner.print1();
        //实例化公有成员内部类
        Outer.PublicInner publicInner = outer.new PublicInner();
        publicInner.print2();
    }
}

输出结果：

Outer static method!
private Joe
public 0806
Outer static method!
public Joe
public 0810
Outer static method!

通过这个例子可以看出：

　　♥ 成员内部类是依附其外围类而存在的，如果要产生一个成员内部类，必须有一个其外围类的实例；

　　♥ 成员内部类不可以定义静态方法和静态属性；

　　♥ 声明为private的成员内部类，只对其外围类可见；声明为public的成员内部类，其他非外围类对其可见；

　　♥ 成员内部类可以访问外围类的私有属性，如果成员内部类的属性和其外围类的属性重名，则以成员内部类的属性值为准；

　　♥ 实例化成员内部类：外围类.内部类 xxx = 外围类.new 内部类();

匿名内部类

在多线程的模块中代码，大量使用了匿名内部类，如下：

public class Outer {
    //匿名接口
    interface Inner{
        int getNumber();
    }
    //使用匿名接口
    public Inner getInner(final int num,String str){
        return new Inner() {
            @Override
            public int getNumber() {
                System.out.println(str);
                return num;
            }
        }; /* 注意：分号不能省 */
    }
    //测试
    public static void main(String[] args){
        Outer outer = new Outer();
        Inner inner = outer.getInner(4,"nihao");
        System.out.println(inner.getNumber());
    }
}

输出结果：

nihao
4

 通过这个例子可以看出：

　　❤ 匿名内部类没有修饰符；

　　❤ 当所在方法的形参需要被匿名内部类使用时，该形参必须为final，因为：内部类在编译时会生成一个独立的.class文件，改文件并不在它的外围类中，内部类将传过来的参数通过自己的构造器备份到了自己的内部，这样自己内部方法的调用实际上是自己的属性，而不是外围类方法的参数；简单理解就是：拷贝引用，为了避免引用值发生改变，例如被外围类的方法修改等，而导致内部类得到的值不一致，于是用final修饰让该引用不可变；

　　❤ 匿名内部类没有构造方法，因为它连名字都没有；

　　❤ new 匿名内部类；这个类必须先存在；

局部内部类

局部内部类：是指内部类定义在方法和作用域内。

看个例子：

public class Outer {
    private void internalTracking(boolean b) {
        if (b) {
            //局部内部类
            class TrackingSlip {
                private String id;
                TrackingSlip(String s) {
                    id = s;
                }
                String getSlip() {
                    return id;
                }
            }
            TrackingSlip ts = new TrackingSlip("slip");
            String s = ts.getSlip();
        }
    }

    public void track() {
        //调用方法（含有局部内部类）
        internalTracking(true);
        System.out.println(".......");
    }

    public static void main(String[] args) {
        Outer p = new Outer();
        p.track();
    }
}

局部内部类也会像其他类一样编译，只是作用域不同而已，只有在该方法或者作用域内才能用，超出作用域或者方法就不可引用。

　　❤ 局部内部类没有访问修饰符；

　　❤ 局部内部类要访问外围类的对象或者变量，那么这个变量或者对象必须是final修饰的；

内部类的好处

　　❤ Java运行实现多个接口，但不允许继承多个类，使用内部类可以解决Java不允许多个继承的问题。在一个类的内部定义一个内部类，让这个内部类继承某个原有的类，而这个内部类又可以访问外围类的属性和方法，这样就相当于多个继承了；

　　❤ 有效的对外隐藏了自己，增加了自己的私密性；

　　❤ 使用内部类可以让类与类之间的联系更加紧密；

　　❤ 有些类知道只会在某个地方使用只使用一次，为这种类创建一个外部类显然没有必要，所以这种就写个内部类用用就可以了；