第十二章 内部类

内部类的概念及分类

• 内部类就是在类的内部定义的类。叫做内部类
• 分为实例内部类，静态内部类，局部内部类，匿名内部类

实例内部类的定义及访问

• 实例内部类当中可以定义静态的，也可以定义实例的
• 在实例内部类当中的实例方法中可以访问外部类所有的属性
• 在实例内部类中的静态方法中不能直接访问外部类实例相关的数据

//OuterClass.java
public class OuterClass { // 外部类
    // 静态变量
    static int a = 100;
    // 实例变量
    int b = 200;
    // 实例内部类（实例变量：访问实例变量需要先new OuterClass()）
    class InnerClass {
        public void m1(){
            System.out.println("m1方法执行了");
            // 在实例内部类当中的实例方法中可以访问外部类所有的属性
            System.out.println(a);
            System.out.println(b);
        }
        public static void m2(){
            System.out.println("m2方法执行了");
            System.out.println(a);
            // 在实例内部类中的静态方法中不能直接访问外部类实例相关的数据。
            //System.out.println(b);
        }
    }
}
//Test.java
public class Test {
    public static void main(String[] args) {
        // 放到一起的。
        //OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();

        // 分开的
        OuterClass oc = new OuterClass();
        OuterClass.InnerClass innerClass = oc.new InnerClass();
        innerClass.m1();
        // 访问实例内部类的静态方法。
        OuterClass.InnerClass.m2();
    }
}

静态内部类的定义及访问

• 在静态内部类当中无法访问外部类的所有的实例相关的数据

//OuterClass.java
public class OuterClass {
    // 静态变量
    static int a = 100;
    // 实例变量（在静态内部类当中无法访问外部类的所有的实例相关的数据。）
    int b = 200;
    //静态内部类如何定义，如何访问
    // 静态内部类可以等同看做静态变量
    protected static class InnerClass { // 内部类可以添加访问控制权限修饰符。
        // 定义实例方法
        public void m1(){
            System.out.println("m1...");
            System.out.println(a);
            //在静态内部类当中无法访问外部类的所有的实例相关的数据
            //System.out.println(b);
        }
        // 定义静态方法
        public static void m2(){
            System.out.println("m2...");
            System.out.println(a);
            //在静态内部类当中无法访问外部类的所有的实例相关的数据
            //System.out.println(b);
        }
    }
}
//Test.java
public class Test {
    public static void main(String[] args) {
        // 创建内部类对象
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
        // 调用实例方法
        innerClass.m1();
        // 调用静态内部类的静态方法
        OuterClass.InnerClass.m2();
    }
}

静态内部类的定义及访问

• 局部内部类就是局部变量。只在当前方法中有效。局部变量不能使用private等修饰符修饰。局部内部类同样也不能使用private等修饰符修饰。

OuterClass.java
public class OuterClass {
    static int a = 100;
    int b = 200;

    public void m(){
        // 局部变量
        int i = 100;
        // 局部内部类
        class InnerClass {
            public void m1(){
                System.out.println("m1....");
                System.out.println(a);
                System.out.println(b);
                System.out.println(i);
            }
            public static void m2(){
                System.out.println("m2....");
                System.out.println(a);
                // 报错。
                /*System.out.println(b);
                System.out.println(i);*/
            }
        }
        // 只能在当前方法体当中使用。
        InnerClass innerClass = new InnerClass();
        innerClass.m1();
        InnerClass.m2();
    }
}
//Test.java
public class Test {
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.m();
    }
}

匿名内部类的定义及访问

public class AnonymousInnerClass {
    public static void main(String[] args) {
        SystemService systemService = new SystemService();
        //systemService.exit(new UserServiceImpl());
        // 使用匿名内部类的方式
        /*
        以下小括号当中的代码做了三件事：
        1.定义了一个没有名字的类(匿名内部类)
        2.这个类实现了UserService接口。
        3.采用new的方式创建了一个“匿名内部类”对象
        匿名内部类的缺点：类无法重复使用。只能在某个固定位置使用一次。
        如果程序中某个接口的实现类只需要在某个固定的位置使用一次，可以考虑使用匿名内部类。
         */
        systemService.exit(new UserService(){
            public void logout(){
                System.out.println("用户退出！");
            }
        });

        // java8的新特性：匿名内部类可以采用Lambda表达式代替。
        systemService.exit(()->{
            System.out.println("用户退出！");
        });

        systemService.exit(()->{
            System.out.println("用户退出！");
        });

        systemService.exit(() -> System.out.println("用户退出！") );
    }
}

class SystemService {
    public void exit(UserService userService){
        userService.logout();
        System.out.println("系统已经安全退出！");
    }
}

@FunctionalInterface // 这个注解是做编译阶段检查的，检查你这个接口中是否只有一个方法，如果只有一个方法，那么该接口称为函数式接口。
interface UserService {
    void logout();
    //void m();
}

内部类回调外部类

public interface Tool {
    /**
     * 乘积方法
     */
    int calculate(int a, int b);
}
//Robot.java
public class Robot {
    // 求和方法
    public int calculate(int a, int b){
        return a + b;
    }
    public int multiply(int a, int b){
        return a * b;
    }

    // 内部类实现Tool接口
    class InnerClass implements Tool {

        @Override
        public int calculate(int a, int b) {
            return multiply(a , b);
        }
    }
    public Tool getTool(){
        return new InnerClass();
    }
}
//Test.java
public class Test {
    public static void main(String[] args) {

        Robot robot = new Robot();
        System.out.println(robot.calculate(10, 20));

        Tool tool = robot.getTool();
        System.out.println(tool.calculate(10, 20));
    }
}
//结果：30,200