Java内部类

成员内部类

和外部类中的成员变量，成员方法同级，内部类中也可以定义变量和方法等

内部类的修饰符和成员变量，成员方法的修饰符相同，可以使用public，private，protected，default，成员内部类分为静态内部类和非静态内部类

非静态内部类

和实例方法类似，不使用static修饰符

//  外部类
public class outSide {
//    成员变量
    private String outName;

//    成员方法
    public void outPut(){
        System.out.println("外部类方法执行");
    }

//    成员内部类（非静态）
    public class inSide{
//        内部类中的变量
        private String inName = "内部类";

//        内部类中的方法
        public void intPut(){
            System.out.println("内部类方法执行");
        }
    }

}

访问内部类中的变量和方法

在外部类中定义main方法

因为是非静态内部类，所以访问内部类时和访问实例变量，实例方法的格式一致，都是用 外部类对象.变量/方法/非静态内部类 的格式

    public static void main(String[] args) {
//        创建外部类对象
        outSide outSide = new outSide();
//        创建内部类对象
        test.outSide.inSide inSide = outSide.new inSide();
//        访问内部类变量
        System.out.println(inSide.inName);
//        访问内部类方法
        inSide.intPut();
    }

结果

---

静态内部类

和静态方法类似，使用static修饰符

//  外部类
public class outSide {
//    成员变量
    private static String outName;

//    成员方法
    public static void outPut(){
        System.out.println("外部类方法执行");
    }

//    成员内部类（静态）
    public static class inSide{
//        内部类中的变量
        private String inName = "内部类";

//        内部类中的方法
        public void intPut(){
            System.out.println("内部类方法执行");
        }
    }

}

访问内部类中的变量和方法

在外部类中定义main方法

因为是静态内部类，所以访问内部类和访问静态变量，静态方法的格式类似，使用 外部类.变量/方法/静态内部类 的格式

//       创建内部类对象
outSide.inSide inSide = new outSide.inSide();

因为静态内部类是在当前类中，所以上面的式子可以简写为

    public static void main(String[] args) {
//        outSide.inSide inSide = new outSide.inSide();
//        因为静态内部类是在当前类中，所以上面的式子可以简写为
        outSide.inSide inSide = new inSide();
        System.out.println(inSide.inName);
        inSide.intPut();
    }

就像我们在当前类中调用outName变量，我们是直接调用outName，而不是使用outSide.outName的格式调用

结果

---

局部内部类

局部内部类和局部变量同级，都是定义在方法中

局部内部类不能使用任何修饰符，包括static

在outPut方法中创建内部类

//  外部类
public class outSide {
//    成员变量
    private static String outName;

//    成员方法
    public static void outPut(){
//        局部变量
        String name;

//        局部内部类
        class inSide{
//            局部内部类中的变量
            private String inName = "局部内部类";
            
//            局部内部类中的方法
            public void inPut(){
                System.out.println("局部内部类方法执行");
            }
        }
    }

}

访问内部类中的变量和方法

要访问内部类同样要在内部类所在的方法中进行访问

//  外部类
public class outSide {
//    成员变量
    private static String outName;

//    成员方法
    public static void outPut(){
//        局部变量
        String name;

//        局部内部类
        class inSide{
//            局部内部类中的变量
            private String inName = "局部内部类";

//            局部内部类中的方法
            public void inPut(){
                System.out.println("局部内部类方法执行");
            }
        }

//        创建内部类对象
        inSide inSide = new inSide();
//        访问内部类变量
        System.out.println(inSide.inName);
//        访问内部类方法
        inSide.inPut();
    }

}

在外部类中定义main方法，调用outPut方法

public static void main(String[] args) {
    outSide.outPut();
}

结果

---

匿名内部类

通过一个例子来演示一下，这里我们定义一个接口，定义一个接口实现类和一个测试类，通过测试类调用接口中的方法

接口Inter

public interface Inter {
    void start();
}

实现类InterImp

public class InterImp implements Inter{
    @Override
    public void start() {
        System.out.println("接口实现类，实现接口方法");
    }
}

测试类MyTest

普通方法

//      调用实现类中的方法
public class MyTest {
    public static void main(String[] args) {
    //	创建接口实现类对象
        Inter inter = new InterImp();
        inter.start();
    }
}

结果

使用匿名内部类

public class MyTest {
    public static void main(String[] args) {
//        匿名内部类
//        不用创建实现类
        Inter inter = new Inter() {
            @Override
            public void start() {
                System.out.println("接口实现类，实现接口方法");
            }
        };
        inter.start();
    }
}

结果

我们可以将匿名内部类和接口实现类作比较

图1.匿名内部类

图2.实现类

图1当中的后半部分和图2实现类的主体部分相同，所以我们也可以将他看成是一个类，只不过这个类没有名称，并且这个类又是定义在当前类中，所以我们称它为匿名内部类

使用匿名内部类我们可以不用创建实现类，可以少创建类，但使用匿名内部类我们只能调用一次，不能反复调用，可重用性降低