Java

参考我最喜欢的一本书，李刚《疯狂java讲义》第6章

一.内部类的访问控制修饰符

1.外部类的上一级单元是包，所以它只有两个作用域：同一个包内和任何位置。所以外部类有包访问权限（即默认的，没有修饰符）和public。

2.内部类的上一级程序单元是外部类，它有四个作用域：同一个类private，同一个包default，父子类protected和public

二.非静态内部类

1.非静态内部类的方法访问某个变量时，系统查找顺序为：

　　该方法内的局部变量  --〉  内部类的局部变量  --〉  外部类的成员变量，都查找不到则编译出错。

　　如果外部类成员变量、内部类成员变量、内部类里的方法的局部变量重名，则可用外部类类名.this、this作为限定来区分。

public class OutClass {
    private String str = "外部类的成员变量";
    private class InClass{
        private String str = "内布类的成员变量";
        public void test(){
            String str = "局部变量";
            //通过外部类类名.this.varName 访问外部类实例变量
            System.out.println(OutClass.this.str);
            //通过this.varName 访问内部类实例变量
            System.out.println(this.str);
            //直接访问局部变量
            System.out.println(str);
        }
    }
    
    public static void main(String[] args) {
        new OutClass().new InClass().test();
    }
}

输出结果为：

外部类的成员变量
内布类的成员变量
局部变量

2.非静态内部类的成员可以访问外部类的private成员，但反过来就不成立了。而且非静态内部类public成员也不可以被外部类直接访问。

非静态内部类的成员只有在非静态内部类范围内可知，并不能被外部类直接使用。可以通过创建非静态内部类对象来调用访问其实例成员。

**非静态内部类对象必须寄生在外部类对象里，而外部类对象则不一定有非静态内部类对象寄生其中。因此外部类对象访问非静态内部类成员时，可能非静态内部类对象根本不存在！而非静态内部类对象访问外部类成员时，外部类对象一定存在。

3.非静态内部类里不能有静态方法、静态成员变量、静态初始化块，可以包含普通初始化块。

二.静态内部类

1.静态内部类访问外部类

静态内部类可以包含静态成员，也可以包含非静态成员。根据静态成员不能访问非静态成员的规则，静态内部类不能访问外部类的实力成员，只能访问外部类的类成员，即使是静态内部类的实例方法也不可访问外部类的实例成员。

2.外部类访问静态内部类

外部类依然不能直接访问静态内部类成员，但可以使用静态内部类的类名作为调用者来访问静态内部类的静态成员，也可以使用静态内部类对象作为调用者来访问静态内部类的实例成员。

*静态内部类是外部类的类相关的，而不是外部类的对象相关的。也就是说，静态内部类对象不是寄生在外部类的实例中，而是寄生在外部类的类本身中。当静态内部类对象存在时，并不存在一个被它寄生的外部类对象。静态内部类对象只持有外部类的类引用，没有外部类对象的引用。

三.在外部类以外使用内部类

1.访问权限

默认（default）：只能被与外部类处于同一个包中的其他类访问。

protected：可被与外部类处于同一个包中的其他类和外部类的子类访问。

2.在外部类以外使用非静态内部类

非静态内部类需要寄生在外部类的对象里，所以创建非静态内部类对象之前需要先创建外部类对象，语法如下：

Out.In in = new Out().new In(); 也可以拆成两步，即：

Out out = new Out();

Out.In in = out.new In();

3.在外部类以外使用静态内部类

因为静态内部类是外部类的类相关的，因此创建静态内部类对象时无需创建外部类对象，语法如下：

Out.StaticOutIn in = new Out.StaticIn();

 四.匿名内部类

1.语法：

new 接口()|抽象类构造器(参数列表)|父类构造器(参数列表){

　　//匿名内部类的类体部分

}

由此可知：匿名内部类必须且只能继承一个父类或实现一个接口或者实现一个抽象类。

由于匿名内部类没有类名，所以不能定义构造器，但匿名内部类可以定义初始化块来完成构造器需要完成的事情。

2.final修饰的局部变量才可被匿名内部类使用

package test;

public class Test {
    public void testClass(TestClass t){
        System.out.println("已进入testClass------------------------");
        t.test();
    }
    
    public void testAbstract(TestAbstract t){
        System.out.println("已进入testAbstract------------------------");
        t.test("===抽象类测试方法");
    }
    
    public void testInterface(TestInterface t){
        System.out.println("已进入testInterface------------------------");
        t.test("===接口测试方法");
    }
    
    public static void main(String[] args) {
        Test t = new Test();
        //final修饰的局部变量才可被匿名内部类使用，（Java8更智能可以自己加）
        final String str = "局部变量";
        //测试继承类，并在匿名内部类中重写父类测试方法
        t.testClass(new TestClass("---被匿名内部类测试中。。。"){
            public void test(){
                System.out.println("继承类时的匿名内部类重写测试方法");
                System.out.println("测试在匿名内部类中使用局部变量-=-=-"+str);
            }
        });
        
        //测试实现抽象类，并在匿名内部类中重写抽象类测试方法
        t.testAbstract(new TestAbstract("---被匿名内部类测试中。。。"){

            @Override
            //匿名内部类实现抽象类时必须重写其抽象方法
            void test(String str) {
                // TODO Auto-generated method stub
                System.out.println("匿名内部类重写的抽象类测试方法"+str);
            }
            
        });
        
        //测试实现接口
        t.testInterface(new TestInterface(){

            @Override
            //匿名内部类实现接口时必须重写其抽象方法
            public void test(String str) {
                // TODO Auto-generated method stub
                System.out.println("匿名内部类重写的接口测试方法"+str);
            }
            
        });
        
    }
}

class TestClass{
    public TestClass(String str){
        System.out.println("父类有参构造器"+str);
    }
    
    public void test(){
        System.out.println("父类测试方法");
    }
}
abstract class TestAbstract{
    public TestAbstract(String str){
        System.out.println("抽象类有参构造器"+str);
    }
    abstract void test(String str);
}
interface TestInterface{
    void test(String str);
}
运行结果:
父类有参构造器---被匿名内部类测试中。。。
已进入testClass------------------------
继承类时的匿名内部类重写测试方法
测试在匿名内部类中使用局部变量-=-=-局部变量
抽象类有参构造器---被匿名内部类测试中。。。
已进入testAbstract------------------------
匿名内部类重写的抽象类测试方法===抽象类测试方法
已进入testInterface------------------------
匿名内部类重写的接口测试方法===接口测试方法