内部类学习笔记

类里面在嵌套一个类，叫做内部类

成员内部类

类的成员是一个类，成员内部类可以访问外部类的所有属性与方法，哪怕是private、static的
内部类中成员为private时，只能在外部类的内部访问；成员为public时，任何地方都能访问
成员内部类中不能有static方法；可以有static域，必须是final的
依赖于外部类，所以得先创建外部类才能访问内部类

public class Test {
    public static void main(String[] args) {
        Car car = new Car();
        car.run();
		
		// 创建内部类对象。访问内部类成员，必须先有外部类的对象
        Car.Bike bike1 = car.new Bike();
        bike1.run();	// days = 15

        Car.Bike bike = new Car().new Bike();
        bike.run();	// days = 5；
    }
}

class Car { // 外部类
    class Bike { // 内部类
        public int value;
        public void run() {
            days += 5;
            System.out.println("bike run " + days);
        }
    }

    private int days;

    public void run() {
        days = 10;
        System.out.println("car run " + days);
    }
}

局部内部类

嵌套在方法里、作用域里的内部类，访问权限只在其方法或作用域里。局部内部类实际上就是方法的一个局部变量，所以不能用public、private、protected、static修饰

匿名内部类

没有名字的类，只能使用一次。匿名内部类必须是继承父类或实现接口
接口中有几个方法，就得重写几个方法；抽象类有多少个抽象方法，就要重写这些抽象方法
在平常使用中出现的最频繁的
匿名内部类不能有访问修饰符、static，不能定义静态成员、方法、类

abstract class Per{
	public abstract void eat();
	public abstract void run();
}

public class tt {
    public static void main(String[] args) {
        Per per = new Per() {
            @Override
            public void eat() { }

            @Override
            public void run() { }
        };
    }
}	   

比如Android中事件监听时，使用的就是匿名内部类。

静态内部类

static修饰的内部类——静态内部类
静态内部类不依赖于外部类的创建，不能使用外部类中非静态的成员
静态内部类可以直接创建实例，而不用通过外部类

   // 直接创建静态内部类实例
   new OuterClass.InnerClass().run();

public class Test {
    public static void main(String[] args) {
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
        innerClass.run();
    }
}

class OuterClass {
    static class InnerClass {
        public void run() {
            System.out.println("static InnerClass run");
        }
    }
}