【Java基础】Java内部类

什么是内部类

把类定义在其他类的内部，这个类就被称为内部类。

内部类的分类

内部类分为两种，分别为成员内部类和局部内部类：

成员内部类：和成员变量和成员方法定义在同级
局部内部类：和局部变量定义在同级，包括在构造方法，成员方法体和静态方法体中

class Outer {

    class InnerA {//成员内部类
    }
    
    
    {
        class InnerB {//局部内部类
        }
    }

    static {
        class InnerC {//局部内部类
        }
    }

    public Outer() {
        class InnerD { //局部内部类
        }
    }

    public void show() {
        class InnerE {//成员内部类
        }
    }
}

成员内部类访问特点

内部类可以直接访问外部类的全部成员。
外部类要访问内部类的成员，必须创建对象。
成员内部类一般多用private修饰和static修饰

class Outer {
    private int age = 20;
    
    class Inner {
        public void getAge() {
            System.out.println(age);
        }
    }
    
    public void method() {
        //找不到符号
        //getAge();
        Inner inner = new Inner();
        inner.getAge(); 
　　} 
}

public class Test {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.getAge();
    }
}

上面的例子中，可以直接通过new Outer(). new Inner();来访问内部来，这种访问一般不安全，因为类之所以定义在内部而不定义在外部，肯定有安全性需求，这时候可以在内部类前的修饰符加private，如果类中的成员变量，外部只能通过指定的方法来访问，这个时候在对外的方法可以提供验证，例如：

class Outer {

    private class InnerA {
        public void play() {
            System.out.println("play");
        }
    }

    public void getInner(String name) {
        if(name.equals("lili")){
            new InnerA().play();
        }
    }
}


public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.getInner("lili");
    }
}

当然，成员内部类也常用static修饰，这样访问起来便利性比较高，但是静态内部类只能访问静态外部成员变量。

public class Test {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
        inner.getAge();
    }
}

class Outer {
    private static int age = 20;

    static class Inner {
        public void getAge() {
            System.out.println(age);
        }
    }

    public void method() {
        Inner inner = new Inner();
        inner.getAge();
    }
}

局部内部类访问特点

可以直接访问外部类的全部成员
在局部位置，可以创建内部类对象来使用局部内部类提供的功能
局部内部类访问局部变量必须用final修饰

class Outer {
    private String name = "lili";

    public void show(){
        int phoneNum = 10086;
        class Inner {
            final int age = 20;
            public void getAge() {
//                phoneNum = 110;//Error:(13, 17) java: 从内部类引用的本地变量必须是最终变量或实际上的最终变量
                int miniPhoneNum = phoneNum;//可以访问

                System.out.println(age);
                System.out.println(phoneNum);                System.out.println(name);
            }
        }
        new Inner().getAge();
    }

}


public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}

为什么局部内部类只能访问final类型的局部变量？

局部变量是随着方法的调用而调用，随着调用完毕而消失。而堆内存的内容并不会立即消失。所以，我们加final修饰。加入final修饰后，这个变量就成了常量。既然是常量。你消失了，我在内存中存储的是数据20，所以，我还是有数据在使用。

内部类中如何区分多层同名变量

class Outer {
    public int num = 10;
    class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(num);
            System.out.println(this.num);
            //System.out.println(new Outer().num);
            System.out.println(Outer.this.num);
        }
    }
}