Java内部类详解

先来说说内部类大概是一个什么样的存在，内部类其实就是在类中镶嵌了一个类
一个类有属性（字段）， 有方法，还有代码块

• 和属性方法同级的内部类称为成员内部类
• 在方法中与局部变量同级的内部类称为局部内部类
• 在成员内部类的基础上再添加一个static修饰称为静态内部类
• 在局部内部类的基础上再做了一些升级称之为匿名内部类，匿名内部类有些特殊， 可以看本文下面的解析

成员内部类

我们一般定义类都是下面这样定义的， 属性和方法

public class A {
    public int m = 5;
    private  int n = 6;
    private void method1(){
        System.out.println("A -> method1");
    }
}

类A中有两个属性和一个方法, 这两个属性和方法都被称之为类A的成员
现在我们在类A的成员位置再定义一个类B

public class A {
    public int m = 5;
    private  int n = 6;
    private void method1(){
        System.out.println("A -> method1");
    }
    public class B{
        public void method1(){
            System.out.println("B -> method1");
        }
        public void method2(){
            System.out.println("B -> method2");
        }
        public void method3(){
            method1();
        }
    }
}

这个类B就被称之为类A的成员内部类，A是B的外部类

成员内部类是可以直接访问外部类的所有成员，包含私有的

public class A {
   public int m = 5;
   private  int n = 6;
   private void method1(){
       System.out.println("A -> method1");
   }
   public class B{
       public void method1(){
           m = 7;
           n = 8;
           System.out.println("B -> method1");
       }
       public void method2(){
           System.out.println("B -> method2");
       }
       public void method3(){
           method1();
       }
   }
}

成员内部类可以添加任意访问修饰符(public、protected、默认、private), 因为它的地位就是一个成员

作用域和外部类的其他成员一样,为整个类体

外部类可以访问成员内部类 [访问方式: 创建对象，再访问]

public class A {
    public int m = 5;
    private  int n = 6;
    private void method1(){
        System.out.println("A -> method1");
        B b = new B();
        b.method1();
    }
    public class B{
        public void method1(){
            m = 7;
            n = 8;
            System.out.println("B -> method1");
        }
        public void method2(){
            System.out.println("B -> method2");
        }
        public void method3(){
            method1();
        }
    }
}

外部其他类也可以访问成员内部类

public class test {
    public void test(){
        A a = new A();
        A.B b = a.new B();
        b.method1();
    }
}

如果外部类和内部类的成员(比如两者的方法)重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

public class A {
    public int m = 5;
    private  int n = 6;
    private void method1(){
        System.out.println("A -> method1");
        B b = new B();
        b.method1();
    }
    public  class B{
        public void method1(){
            m = 7;
            n = 8;
            System.out.println("B -> method1");
        }
        public void method2(){
            A.this.method1(); // 这里调用到的才是A中的method1方法
        }
        public void method3(){
            method1(); // 这里调用到的是B中的method1方法
        }
    }
}

局部内部类

局部内部类是定义在外部类的局部位置，比如方法中, 代码块中, 并且有类名
类似于一个局部变量

可以直接访问外部类的所有成员, 包含私有的

public class A {
    public int m = 4;
    private int n = 5;
    public void method1(){
        class B{
            public void method2(){
                m = 5;
                n = 6;
                System.out.println("你好啊");
            }
        }
    }
}

不能添加访问修饰符, 因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final

作用域: 仅仅在定义它的方法或代码块中

外部其他类不能访问----->局部内部类（因为局部内部类地位是一个局部变量)

外部类可以访问 ----> 局部内部类的成员

访问的方式：创建对象, 再访问(注意:必须在作用域内)
将类B看成是A的method1方法中的局部变量， 就比较容易理解了

public class A {
    public int m = 4;
    private int n = 5;
    public void method1(){
        class B{
            public void method2(){
                m = 5;
                n = 6;
                System.out.println("你好啊");
            }
        }
        B b = new B();
        b.method2();
    }
}

如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

public class A {
    public int m = 4;
    private int n = 5;
    public void method2(){
        System.out.println("A中的method2");
    }
    public void method1(){
        class B{
            public void method2(){
                m = 5;
                n = 6;
                System.out.println("B中的method2");
            }
        }
        B b = new B();
        b.method2();// 这里调用的是B中的method2
        A.this.method2();// 这里调用的是A中的method2
    }
}

静态内部类

静态内部类是在成员内部类的基础上，加上static修饰

可以直接访问外部类的所有静态成员，包含私有的，不能直接访问非静态成员

public class A {
    public int m = 5;
    private static int n = 6;
    private static void method1(){
        System.out.println("method1");
    }
    public void method4(){
        System.out.println("method4");
    }
    public static class B{
        public void method2(){
            System.out.println("method2");
        }
        public static void method3(){
            method1();
            n = 8;
            // m = 9; // 不能访问, 不是静态变量
            // method4();// 不能访问, 不是静态方法
        }
    }
}

可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员。

作用域: 和其他的成员变量一样，为整个类体

外部类可以访问------>静态内部类

访问方式:创建对象，再访问

public class A {
    public int m = 5;
    private static int n = 6;
    private static void method1(){
        B b = new B();
        b.method2();
        B.method3();
    }
    public void method4(){
        B b = new B();
        b.method2();
        B.method3();
    }
    public static class B{
        public void method2(){
            
        }
        public static void method3(){
            
        }
    }
}

外部其他类可以访问----->静态内部类

public class test {
    public static void main(String[] args) {
        A.B b = new A.B();
        b.method2();
        A.B.method3();
    }
}

如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.成员)去访问

匿名内部类

匿名内部类是定义在外部类的局部位置, 比如方法中，并且没有类名
匿名内部类的语法比较奇特，请大家注意，因为匿名内部类既是一个类的定义, 同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，,因此可以调用匿名内部类方法。

public class A {
    public int m = 5;
    private static int n = 6;
    private void method1(){
        new B(){
            @Override
            public void method2() {
                System.out.println("11111111111");
            }
        }.method2();
    }
}
class B{
    public int i = 7;
    private int j = 9;
    public void method2(){

    }
}

可以直接访问外部类的所有成员，包含私有的

public class A {
    public int m = 5;
    private static int n = 6;
    private void method1(){
        new B(){
            @Override
            public void method2() {
                System.out.println("11111111111");
            }
            public void method3(){
                m = 8; // 调用外部类的public 变量
                n = 10; // 调用外部类私有变量
                method1(); // 调用外部类的私有方法
            }
        }.method2();
    }
}
class B{
    public int i = 7;
    private int j = 9;
    public void method2(){
        System.out.println("222222222222222");
    }
}

不能添加访问修饰符, 因为它的地位就是一个局部变量

作用域: 仅仅在定义它的方法或代码块中。

外部其他类不能访问----->匿名内部类（因为匿名内部类地位是一个局部变量)

如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则, 如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问