java对象类嵌套太对多的对象类且一层嵌套一层如何添加值

在 Java 中，如果对象类嵌套太多且一层嵌套一层，可以使用链式调用的方式来向嵌套类中添加值。以下是一个示例，假设你有一个名为 `OuterClass` 的外部类，其中包含一个名为 `InnerClass1` 的嵌套类，`InnerClass1` 又包含一个名为 `InnerClass2` 的嵌套类，`InnerClass2` 又包含一个名为 `InnerClass3` 的嵌套类：

public class OuterClass {
    public static class InnerClass1 {
        int value1;
        InnerClass2 inner2;

        public InnerClass1 withValue1(int value1) {
            this.value1 = value1;
            return this;
        }

        public InnerClass2 withInner2(InnerClass2 inner2) {
            this.inner2 = inner2;
            return this.inner2;
        }
    }

    public static class InnerClass2 {
        int value2;
        InnerClass3 inner3;

        public InnerClass2 withValue2(int value2) {
            this.value2 = value2;
            return this;
        }

        public InnerClass3 withInner3(InnerClass3 inner3) {
            this.inner3 = inner3;
            return this.inner3;
        }
    }

    public static class InnerClass3 {
        int value3;

        public InnerClass3 withValue3(int value3) {
            this.value3 = value3;
            return this;
        }
    }
}

在上面的示例中，我们为每个嵌套的对象类添加了一个 `withXxx` 方法，通过该方法可以向对象类中添加值，并返回对象本身或嵌套的对象，从而实现链式调用的方式。

要向 `InnerClass3` 添加值，我们可以通过嵌套的方式进行链式调用。下面是一个示例：

OuterClass outerObj = new OuterClass();
outerObj.inner1 = new OuterClass.InnerClass1()
        .withValue1(10)
        .withInner2(new OuterClass.InnerClass2()
                .withValue2(50)
                .withInner3(new OuterClass.InnerClass3()
                        .withValue3(100)));

在上面的示例中，我们首先创建了一个 `OuterClass` 对象 `outerObj`，然后通过链式调用的方式向嵌套的对象类中添加了值。具体来说，我们首先创建了一个 `InnerClass1` 对象，并调用了 `withValue1` 方法来设置 `value1` 字段的值为 `10`。接着，我们调用了 `withInner2` 方法来创建一个 `InnerClass2` 对象，并将其设置为 `inner2` 字段的值。在创建 `InnerClass2` 对象时，我们又调用了 `withValue2` 方法来设置 `value2` 字段的值为 `50`，以及 `withInner3` 方法来创建一个 `InnerClass3` 对象，并将其设置为 `inner3` 字段的值。最后，我们在创建 `InnerClass3` 对象时，又调用了 `withValue3` 方法来设置 `value3` 字段的值为 `100`。