Java-内部类

内部类就是在一个类里面再定义一个类。

当一类事物A中包含另一类事物B，而B类不能脱离A类而存在，那么在定义A类的时候就需要在它内部定义B类。

内部类可以直接访问外部类的所有成员，而外部类需要创建内部类的对象才能访问内部类的成员

内部类分为四种：

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

匿名内部类

即隐藏名字的内部类，其一般是在“创建”抽象类或者接口的“对象”（有继承或实现关系 + 需要重写方法 + 需要创建对象）时出现

这里所谓的”对象“就是匿名内部类的对象

// 抽象类Test1.java
public abstract class Test1 {
    public abstract void needImpl();

    public void hello() {
        System.out.println("hello world!");
    }
}

// 接口Inter.java
public interface Inter {
    void inter1();
}

// “创建”抽象类与接口的“对象”
public class t1 {
    public static void main(String[] args) {
        
        // 创建接口对象并调用成员方法
        // 匿名内部类实现了接口，然后创建了这个类的对象 inter
        Inter inter = new Inter() {
            @Override
            public void inter1() {
                System.out.println("hello inter!");
            }
        };
        i.inter1();

        // 创建抽象类对象并调用成员方法
        // 匿名内部类继承了抽象类并实现了方法，然后创建了这个类的对象 t1
        Test1 t1 = new Test1() {
            @Override
            public void needImpl() {
                System.out.println("咸鱼到底有多咸");
            }
        };
        t1.needImpl();
        t1.hello();
    }
}

在某些情况，抽象类或接口不需要单独编写子类进行继承与实现（如需要临时编写一个实现的抽象方法与所有实现类不同的实现类），这时就可以使用匿名内部类，省去编写子类的时间

成员内部类

局部内部类就是作为成员的内部类，它编写在成员位置，与成员变量、成员方法同级，可以被public、private等标识符修饰

public class test {
    // 外部类的成员变量
    int anInt = 1;
    String str = "123";

    // 成员内部类
    private class test1 {
        int int1 = anInt;
        String str1 = str;

        public void showValue() {
            System.out.println(int1);
            System.out.println(str);
        }
    }
}

在外部类中获取成员内部类对象有两种方式：

在外部类中编写返回内部类对象的成员方法

public class Outer {
    class Inner {
        // 成员变量与方法
    }

    public Inner getInner() {
        return new Inner();
    }

    public static void main(String[] args) {
        Outer o = new Outer();
        Outer.Inner i = o.getInner();

        // 如果内部类是私有的，那么返回值类型可能需要为Object类型
        // 但代价就是不能访问或调用对象中的成员变量或方法
        Object obj = o.getInner();
    }
}

直接创建内部类对象，格式为：

public class Outer {
    class Inner {
        // 成员变量与方法
    }

    public static void main(String[] args) {
        // 外部类.内部类 对象名 = 外部类对象.内部类对象
        Outer.Inner oi = new Outer().new Inner();
    }
}

静态内部类

使用 static 修饰符修饰成员内部类时，内部类就是静态内部类

静态内部类只能访问外部类的静态变量或方法，如果访问非静态成员则需要创建外部类对象

public class Outer {
    int anInt = 1;
    static int intSta = 10;
    
    void test() {
        System.out.println("test...");
    }
    
    static void testSta() {
        System.out.println("test in static method...");
    }
    
    static class StaInner {
        public void test1() {
            // 调用静态成员
            System.out.println(intSta);                 
            testSta();

            // 创建外部类对象来调用非静态成员
            System.out.println(new Outer().anInt);      
            new Outer().test();
        }
    }
}

创建静态内部类对象和调用内部类方法的格式如下（虽然很多时候静态类不需要实例化）：

public class t1 {
    public static void main(String[] args) {
        Outer.StaInner osi = new Outer.StaInner();
        Outer.StaInner.test1();		// 调用静态方法
        osi.test2();	// 调用非静态方法
    }
}

局部内部类

定义在方法内的内部类就是局部内部类，与局部变量同级，不能使用 public 等修饰符修饰

方法外无法直接调用局部内部类，需要在方法内创建对象来使用

局部内部类可以直接访问外部类成员以及方法内的局部变量

public class Outer {
    public void test() {
        
        class Inner {
            int a = 1;
            public void hello() {
                System.out.println("hello world!");
            }
        }
        
        Inner i = new Inner();
        i.hello();
        System.out.println(i.a);
    }
}