内部类

• 一个类定义在另外一个类里面或者一个方法里面，这样的类叫做内部类

成员内部类

package test.InnerClass;

class CSer {
    String weapon;
    private int hp;
    static int money = 800;

    public CSer() {
        // 外部类想要访问内部类的成员，必须先创建一个成员内部类的对象，再通过这个对象来访问
        new Weapon().print();
    }

    class Weapon {
        int damage = 80;

        public void print() {
            // 内部类可以随心所欲地访问外部类的成员
            System.out.println(hp);
            System.out.println(money);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        // 在静态方法中访问成员内部类的时候，就必须先得创建一个外部类的对象，因为内部类是依附于外部类的
        CSer cSer = new CSer();
        CSer.Weapon weapon = cSer.new Weapon();
        weapon.print();
    }
}

局部内部类

class Weapon {
    public Weapon print() {
        // 局部内部类是定义在一个方法或者一个作用域里面的类，所以局部内部类的生命周期仅限于作用域内。
        class AWP extends Weapon {
            private int damage = 80;
        }
        return new AWP();
    }
}

• 局部内部类就好像一个局部变量一样，它是不能被权限修饰符修饰的，比如说 public、protected、private 和 static 等。

匿名内部类

public class ThreadDemo {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        t.start();
    }
}

• 匿名内部类的作用主要是用来继承其他类或者实现接口，并不需要增加额外的方法，方便对继承的方法进行实现或者重写。
• 匿名内部类是唯一一种没有构造方法的类。

静态内部类

class CSer {
    String weapon;
    private int hp;
    static int money = 800;

    public CSer() {
        new Weapon().print();
    }

    // 静态内部类和成员内部类类似，只是多了一个static关键字。
    static class Weapon {
        int damage = 80;

        public void print() {
            // 由于static关键字的存在，静态内部类是不允许访问外部类中非static的变量和方法的
            System.out.println(money);
        }
    }
}

内部类特性

• 1、内部类可以使用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。
• 2、在单个外部类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。
• 3、创建内部类对象的时刻并不依赖于外部类对象的创建。
• 4、内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。
• 5、内部类提供了更好的封装，除了该外围类，其他类都不能访问。