内部类

  内部类就是一个类的内部定义的类

一、成员内部类

成员内部类的格式如下：

class Outer{
     class Inner{}
}

编译上述代码会产生两个文件：
Outer.class 和 Outer$Inner.class

public class Test1 {
    public static void main(String[] args){

        Outer outer = new Outer();
        // 在外部创建成员内部类的实例，因为成员内部类需要依赖外部类的对象
        // 通常情况下，我们不建议这样来
        Outer.Inner inner = outer.new Inner();
        inner.print();
    }
}

class Outer{
    private String name;
    class Inner{
        public void print(){
            System.out.println("inner");
        }
    }
}

建议在外部类中定义一个方法，对外提供访问内部类的接口

public class Test1 {
    public static void main(String[] args){

        Outer outer = new Outer();
        outer.innerPrint();

    }
}

class Outer{
    private String name;
    // 建议在外部类中定义一个方法，对外提供访问内部类的接口
    public void innerPrint(){
        Inner inner = new Inner();
        inner.print();
    }
    private class Inner{
        public void print(){
            System.out.println("inner");
        }
    }
}

二、方法内部类

方法内部类只能在定义该内部类的方法内实例化。不可以在此方法外对其实例化。
方法内部类对象不能使用该内部类所在方法的非final局部变量。

public class Test1 {
    public static void main(String[] args){

        Outer outer = new Outer();
        outer.show();

    }
}

class Outer{
    // show方法的局部变量或方法的参数，实际必须是常量 final
   public void show(){
       final int x = 2;
       class Inner2{
           public void print(){
               //x++；// 从内部类引用的本地变量必须是最终变量或实际上的最终变量
               System.out.println("方法内部类"+x);
           }
       }
       Inner2 inner2 = new Inner2();
       inner2.print();
   }
}

三、静态内部类

  在一个类内部定义一个静态内部类。静态内部类的含义是该内部类可以像其他静态成员一样，没有外部对象时，也能够访问它。静态嵌套类仅能访问外部类的静态成员和方法。

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

class Outer{
    static private String name = "aiguo";
    static public void say(){
        System.out.println("could say");
    }
    static class Inner{
        public void show(){
            System.out.println(name);
            say();
        }
    }
}

四、匿名内部类

  匿名内部类就是没有名字的内部类。
  匿名内部类有三种情况：
  （1）、集成式匿名内部类

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

class Outer{

    // 继承式
    public void print1(){
        Cat cat = new Cat() {
            public void eat() {
                System.out.println("集成式匿名内部类");
            }
        };
        cat.eat();
    }
}

abstract class Cat{
    public abstract void eat();
}

  （2）、接口式匿名内部类

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

class Outer{
    // 接口式
    public void print2(){
        Eat eat = new Eat() {
            public void eat() {
                System.out.println("接口式匿名内部类");
            }
        };
        eat.eat();
    }
}

interface Eat{
    public void eat();
}

  （3）、参数式匿名内部类

public class Test1 {
    public static void main(String[] args){
        Outer outer = new Outer();
        outer.print3(new Eat(){
            public void eat(){
                System.out.println("参数式匿名内部类");
            }
        });
    }
}

class Outer{
   public void print3(Eat eat){
        eat.eat();
   }
}

interface Eat{
    public void eat();
}

  在使用匿名内部类时，要记住下面几个原则：

  （1）、不能有构造方法，只能有一个实例
  （2）、不能定义任何静态成员
  （3）、不能使用public，protected，private，static
  （4）、一定是在new的后面，用其隐含实现一个接口或实现一个类。
  （5）、匿名内部类为局部的，所以局部内部类的所有限制对其生效。

五、问题：局部内部类访问局部变量必须用final修饰，为什么？

  当调用这个方法时，局部变量如果没有final修饰，它的生命周期和方法的生命周期是一样的，当方法调用时会入栈，方法结束后会弹栈，这个局部变量也会消失，那么如果局部内部类的对象还没马上消息想用这个局部变量，显然已无法使用了，如果用final修饰会在类加载的时候进入常量池，即使方法弹栈，常量池的常量还在，也就可以继续使用了。

  注意⚠️：在jdk1.8中取消了在局部内部类中使用变量必须显式的使用final修饰，编译器默认会为这个变量加上final。

六、内部类的作用

  每个内部类都能独立的继承自一个（接口的）实现，所以无论外部类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类是的多重继承的解决方法变得完整。接口解决了部分问题，而内部类有效的实现了“多重继承”。

20220214140033.jpg

成员 局部
成员内部类 方法内部类
静态内部类 匿名内部类

依赖外部类对象的：成员内部类 、方法内部类、匿名内部类
静态内部类不依赖外部类的对象。所以，我们在项目中优先考虑静态内部类（不会产生内存泄漏）