java内部类的使用

1.静态内部类

静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量；

@Data
public class StaticAnimal {
    private String name;
    private static int age =18;
    static class Cat{
        public void miaomiao(){
            System.out.println(age);
            // System.out.println(name); error
        }
    }
    // 静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量；
    // 静态内部类的创建方式，new 外部类.静态内部类()
    public static void main(String[] args) {
        Cat cat = new StaticAnimal.Cat();
        cat.miaomiao();
    }
}

2.成员内部类

/**
* 外部类
*/
@Data
public class Person {
    private String head;
    private int age;
    public String name;
    /**
     * 成员内部类
     */
    @Data
    protected class Eyes{
       private int num;
       private String shape;
       public int calculate(){
           // 成员内部类可以无条件的访问外部类的所有成员属性和成员的方法
           // 包括private成员和静态成员
           return num + age;
       }
    }
}

3.局部内部类

public class MainTest {
    public static void main(String[] args) {
        // 测试成员内部类
        Person person = new Person();
        person.setAge(10);
        person.setHead("大头");
        // 创建成员内部类的对象
        Person.Eyes eyes = person.new Eyes();
        eyes.setNum(15);
        int result = eyes.calculate();
        System.out.println(result);// 25
        MainTest mainTest = new MainTest();
        mainTest.hearing();
    }

    // 局部内部类
    public void hearing(){
        // 定义在某个方法内部的内部类，仅使用一次
        @Data
        class Ear{
            String shape = "circle";
            int distance;
        }
        Ear ear = new Ear();
        ear.setDistance(100);
        System.out.println("ear:" + ear); // ear:Ear(shape=circle, distance=100)
    }
}

4.匿名内部类

public class MainTest {
    public static void main(String[] args) {
        // Human是接口，不是类，  匿名内部类就是没有名字的类
        Human man = new Human() {
            @Override
            public void eat() {
                System.out.println("不知名学生正在吃饭!");
            }
        };
        man.eat();
    }
}

// 匿名内部类必须继承或实现一个已有的接口
public interface Human {
    public  void eat();
}

当所在的方法的形参需要被匿名内部类使用时，必须声明为 final

为什么要加final呢？是因为生命周期不一致， 局部变量直接存储在栈中，当方法执行结束后，非final的局部变量就被销毁。而局部内部类对局部变量的引用依然存在，如果局部内部类要调用局部变量时，就会出错。加了final，可以确保局部内部类使用的变量与外层的局部变量区分开，解决了这个问题

public class MainTest {
    public static void main(String[] args) {
        final int age = 10;
        Human man = new Human() {
            @Override
            public void eat() {
                System.out.println("age = " + age);
            }
        };
        man.eat();
    }
}

匿名内部类在项目中的使用： 逐条从数据库取数据

private void indexWeChatMsg(String indexName) throws Exception {
        long startTime = System.currentTimeMillis();
        List<WeChatMsgDto> dtos = new ArrayList<>();
        weChatMsgMapper.getWeChatMsgInfo(new ResultHandler<WeChatMsgDao>() {
            @Override
            public void handleResult(ResultContext<? extends WeChatMsgDao> resultContext) {
                WeChatMsgDao dao = resultContext.getResultObject();
                WeChatMsgDto dto = new WeChatMsgDto();
                BeanUtils.copyProperties(dao, dto);
                String msgType = dao.getMsgType();
                String msgContext = dao.getMsgContext();
                dtos.add(dto);
            }
        });
    }

public interface ResultHandler<T> {
   void handleResult(ResultContext<? extends T> resultContext);
}