前言

静态内部类的使用场景

(1)、外部类需要使用内部类，而内部类无需使用外部类的资源

(2)、内部类可以独立外部类创建对象

使用示例

示例1

嵌套Json反序列化为JAVA对象

Json结构如下

{
  "name": "John",
  "age": 30,
  "address": {
    "street": "123 Main St",
    "city": "New York"
  }
}

Java对象结构如下

import com.fasterxml.jackson.annotation.JsonGetter;
import com.fasterxml.jackson.annotation.JsonSetter;

public class Person {
    private String name;
    private int age;
    private Address address;

    // 默认构造函数
    public Person() {
    }

    @JsonGetter("name")
    public String getName() {
        return name;
    }

    @JsonSetter("name")
    public void setName(String name) {
        this.name = name;
    }

    @JsonGetter("age")
    public int getAge() {
        return age;
    }

    @JsonSetter("age")
    public void setAge(int age) {
        this.age = age;
    }

    @JsonGetter("address")
    public Address getAddress() {
        return address;
    }

    @JsonSetter("address")
    public void setAddress(Address address) {
        this.address = address;
    }

    // 静态内部类表示地址
    public static class Address {
        private String street;
        private String city;

        // 默认构造函数
        public Address() {
        }

        public String getStreet() {
            return street;
        }

        public void setStreet(String street) {
            this.street = street;
        }

        public String getCity() {
            return city;
        }

        public void setCity(String city) {
            this.city = city;
        }
    }
}

使用Jackson库进行反序列化

import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) throws Exception {
        String json = "{\"name\":\"John\",\"age\":30,\"address\":{\"street\":\"123 Main St\",\"city\":\"New York\"}}";

        ObjectMapper objectMapper = new ObjectMapper();
        Person person = objectMapper.readValue(json, Person.class);

        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
        Person.Address address = person.getAddress();
        System.out.println("Street: " + address.getStreet());
        System.out.println("City: " + address.getCity());
    }
}

实际上，使用静态内部类来表示嵌套的JSON数据结构是一个很好的做法，因为静态内部类不需要外部类的实例，而且更容易组织和管理代码

示例2

建造者模式

class Product {
    private String part1;
    private String part2;

    public static class Builder {
        private Product product = new Product();

        public Builder setPart1(String part1) {
            product.part1 = part1;
            return this;
        }

        public Builder setPart2(String part2) {
            product.part2 = part2;
            return this;
        }

        public Product build() {
            return product;
        }
    }
}

内部类可以用于帮助构建复杂对象的不同部分，最终组合成一个完整的对象。

示例3

未完待后续

静态内部类和普通内部类对比

1）普通内部类不能有静态变量和方法

解释下原因：普通内部类也叫成员内部类，顾名思义，它跟成员变量是一个级别的，所以它是外部类实例的一部分，静态的变量属于类的一部分和实例无关，那么显然在普通内部类中声明和类实例无关的静态属性是不合适的。

2）多个外部类可以共享一个静态内部类

但是如果需要多个外部类共享一个静态内部类，倒不如放弃静态内部类的方式（违反初衷）