Java内部类

内部类的分类

1. 成员内部类（包括实例内部类和静态内部类）
2. 局部内部类
3. 匿名内部类

一、成员内部类

成员内部类都是定义在类中
实例内部类
1）在创建实例内部类的实例时，外部类的实例必须已经存在
2）实例内部类的实例自动持有外部类的实例的引用。在内部类中，可以直接访问外部类的所有属性和方法。
3）在外部类中不能直接访问内部类的成员，必须通过内部类的实例去访问
4）实例内部类中不能定义静态属性和方法，而只能定义实例属性和方法
5）如果实例内部类B与外部类A包含同名的成员，那么在类B中， this.v（或者v）表示类B的成员， A.this.v表示类A的成员

public class BasicTest {
    private int i = 3;
    private static int i2 = 1;
    
	//内部类1 -- 实例内部类
    public class Inner{
        public int i2;  //实例内部类不能有静态变量和方法

        public void main() {
            int i2 = 2;
            //访问变量i2的时候，按照作用域从小到大来决定（访问顺序：方法中、内部类、外部类）
            System.out.println("实例内部类可以调用外部类的所有方法和属性"+i+i2);
            //需要访问外部类的静态或实例变量，要通过外部类的类名或实例访问
            System.out.println("外部类实例变量i="+new BasicTest().i+"外部类静态变量i2="+BasicTest.i2);
        }
    }
	
	public static void main(String[] args) {
        System.out.println("实例内部类:");
        BasicTest bt = new BasicTest();
        bt.new Inner().main();
 	}

}

结果：
实例内部类:
实例内部类可以调用外部类的所有方法和属性32
外部类实例变量i=3外部类静态变量i2=1

静态内部类
1）在创建内部类的实例时，不必创建外部类的实例
2）静态内部类可以直接访问外部类的静态属性和方法，如果访问外部类的实例成员，就必须通过外部类的实例去访问
3) 在静态内部类中可以定义静态成员和实例成员
4) 可以通过完整的类名直接访问静态内部类的静态成员 例：A.B.x;

public class BasicTest {
    private int i = 3;
    private static int i2 = 1;

	public static void main(){
        System.out.println("main方法可以重载");
    }    

	public void say(){
        System.out.println("这是个外部类实例方法");
    }

	//内部类2 -- 静态内部类
    public static class Ineer2{
        public static long l;
        public long l2 = 5;
        public static void say(){
            System.out.println("静态内部类可以有静态变量和实例变量，也可以有静态方法和实例方法");
        }

        public void say2(){
            System.out.println("静态内部类可以直接访问外部类的静态变量和方法"+i2);
            main();
            //访问实例变量和方法时，要使用外部类的实例
            BasicTest bt = new BasicTest();
            bt.say();
            System.out.println("外部类实例变量i="+bt.i);
        }
    }
	
	public static void main(String[] args) {
        System.out.println("静态内部类");
        BasicTest.Ineer2.say();
        Ineer2 in2 = new Ineer2();
        in2.say2();
 	}

}

结果：
静态内部类
静态内部类可以有静态变量和实例变量，也可以有静态方法和实例方法
静态内部类可以直接访问外部类的静态变量和方法1
main方法可以重载
这是个外部类实例方法
外部类实例变量i=3

局部内部类 – 在方法中定义的类
1）局部内部类只能在当前方法中使用
2）不能包含静态成员
3）不能被public等访问修饰符修饰
4）可以访问外部类的所有成员，以及方法中的变量

public class BasicTest {
    private int i = 3;
    private static int i2 = 1;
    
	public static void main(){
        System.out.println("main方法可以重载");
    }    

	public void say(){
        System.out.println("这是个外部类实例方法");
    }

	public void test(){
        System.out.println("外部类不能访问局部内部类");
        //内部类3 -- 局部内部类 能不能加任何修饰符（public、static等）
        class Inner3{
            public char c = 'a';    //局部内部类不能有静态变量和静态方法
            public void main3(){
                //局部内部类可以直接访问外部类的所有属性和方法
                System.out.println(""+c+i+i2);
                main();
                say();
            }
        }
        //只能在方法中new局部内部类的对象
        Inner3 i3 = new Inner3();
        i3.main3();
    }
	
	public static void main(String[] args) {
		System.out.println("局部内部类");
		BasicTest bt = new BasicTest();
        bt.test();
 	}
}

结果：
局部内部类
外部类不能访问局部内部类
a31
main方法可以重载
这是个外部类实例方法

匿名内部类
匿名内部类一般用于实现接口

interface A {
    void a();
}

public class BasicTest {
	private int i = 3;
    private static int i2 = 1;
	
	public static void main(){
        System.out.println("main方法可以重载");
    }

	public static void main(String[] args) {
		//匿名内部类
        A a = new A() {
            @Override
            public void a() {
                System.out.println(i2);
                System.out.println("匿名内部类的实现");
                main();
            }
        };
        a.a();
    }
}
结果：
匿名内部类的实现