[Java]重学Java-内部类

什么是内部类

一个类中定义了另一个类，被定义的类叫作内部类。
内部类可以将逻辑隐藏，使用好修饰符可以让实现逻辑对外隔离，并且内部类可以访问外部类的属性。在java8中，还引入了lambda表达式来优化匿名内部类的写法。
关于编译，有兴趣的小伙伴可以看看这篇文章: 点我前往

内部类例子

package com.tea.modules.java8.innerclass;

/**
 * com.tea.modules.java8.innerclass <br>
 * 内部类的理解
 *
 * @author jaymin
 * @since 2021/9/1
 */
public class Out {
    class Inner {
        private int i = 0;

        public int value() {
            return i;
        }
    }

    public void printInnerInfo() {
        Inner inner = new Inner();
        System.out.println(inner.value());
    }

    public static void main(String[] args) {
        Out out = new Out();
        out.printInnerInfo();
    }
}

• Result

0

可以看到，内部类其实就是一个类中包含了另一个类.

直接获取内部类的类型

package com.tea.modules.java8.innerclass;

import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;

/**
 * com.tea.modules.java8.innerclass <br>
 * 内部类的理解
 *
 * @author jaymin
 * @since 2021/9/1
 */
public class Out {
    @AllArgsConstructor
    @NoArgsConstructor
    class Inner {
        private int i = 0;

        public int value() {
            return i;
        }
    }

    public Inner setValue(int i){
        return new Inner(i);
    }

    public void printInnerInfo() {
        Inner inner = new Inner();
        System.out.println(inner.value());
    }

    public static void main(String[] args) {
        Out out = new Out();
        Out.Inner inner = out.setValue(2);
        System.out.println(inner.value());
    }
}

Out.Inner可以直接获取内部类的Class.

.new

使用.new来创建内部类

public static void main(String[] args) {
    Out out = new Out();
    Inner inner = out.new Inner();
    System.out.println(inner.value());
}

.this

使用.this访问外部类的属性

public class Out {
    private Integer value;

    @AllArgsConstructor
    @NoArgsConstructor
    class Inner {
        private int i = 0;

        public int value() {
            System.out.println(Out.this.value);
            return i;
        }
    }
}

局部内部类

package com.tea.modules.java8.innerclass;

import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;

/**
 * com.tea.modules.java8.innerclass <br>
 * 内部类的理解
 *
 * @author jaymin
 * @since 2021/9/1
 */
interface Print {
    void print(String message);
}

public class Out {
    @AllArgsConstructor
    @NoArgsConstructor
    class Inner {
        private int i = 0;

        public int value() {
            return i;
        }
    }

    public Print printer() {
        final class MyPrinter implements Print {

            @Override
            public void print(String message) {
                System.out.println("我是隐藏在方法中的类:" + message);
            }
        }
        return new MyPrinter();
    }

    public static void main(String[] args) {
        Out out = new Out();
        out.printer().print("局部内部类");
    }
}

注意，我们这里在方法中隐藏了一个接口的实现,并返回了一个内部类的实例.

匿名内部类

package com.tea.modules.java8.innerclass;

/**
 * com.tea.modules.java8.innerclass <br>
 * 匿名内部类
 *
 * @author jaymin
 * @since 2021/9/6
 */
interface Inner {
    int value();
}

public class AnonymousInnerClass {
    public Inner innerClass() {
        return new Inner() {
            private int i;

            @Override
            public int value() {
                return ++i;
            }
        };
    }

    public static void main(String[] args) {
        System.out.println(new AnonymousInnerClass().innerClass().value());
    }
}

这种比较常见，像经典的Runnable就可以用这种方式写。

关于内部类的意义

贴一下Java编程思想的内容，或许以后编程经验上来后，再回来看这段话能够充分理解:

每个内部类都能独立地继承自一个（接口的）实现，所以无论外部类是否已经继承了某个（接口的）实现，对于内部类都没有影响。

注意事项

1. 内部类不能声明static方法。
2. 内部类经过编译后，会自动带上"$"符号

bytecode