3

我要做的是创建一个使用 Builder 模式的类 ( )，然后在需要它的对象() 中将Square该类扩展为内部类 ( )。MyCubeDrawMyCube

出于有点复杂的原因，最好将它们扩展为内部类（对局部变量的引用）。

我试图使示例尽可能简单，因为实际用例太复杂而无法在此处使用：

public abstract class Square {
    protected Integer length;
    protected Integer width;

    public abstract static class Builder {
        protected Integer length;
        protected Integer width;

        public abstract Builder length(Integer length);
        public abstract Builder width(Integer width);
    }

    protected Square(Builder builder) {
        this.length = builder.length;
        this.width = builder.width;
    }
}

现在我需要在这里扩展和使用它：

public class DrawMyCube {
    private String myText;
    private Integer height;
    private String canvas;
    private MyCube myCube;

    public DrawMyCube(String canvas) {
        this.canvas = canvas;
        myCube = new MyCube.Builder().length(10).width(10).text("HolaWorld").build();
    }

    public void drawRoutine() {
        myCube.drawMe(canvas);
    }

    protected class MyCube extends Square {
        protected String text;

        public static class Builder extends Square.Builder{
            protected String text;

            public Square.Builder length(Integer length) {this.length = length; return this;}
            public Square.Builder width(Integer width) {this.width = width; return this;}
            public Square.Builder text(String text) {this.text = text; return this;}
        }

        protected MyCube(Builder builder) {
            super(builder);
            this.text = text;
        }

        protected void drawMe(String canvas) {
            canvas.equals(this);
        }
    }
}

然而问题是内部类中的静态生成器：

成员类型 Builder 不能声明为静态的；静态类型只能在静态或顶级类型中声明。

或者，我可以将内部类创建MyCube为常规类，但问题是我无法引用DrawMyCube类内部的任何内容（在实际用例中，有很多对这些内容的引用）。

4

1 回答 1

0

静态嵌套类只能在静态上下文中声明，这就是您看到编译器错误的原因。只需将您的 Builder 类声明为相邻MyCube（或静态上下文中的其他任何地方，没关系）。例如：

public class DrawMyCube {

    protected class MyCube extends Square { }

    public static class MyCubeBuilder extends Square.Builder { }
}

请注意，构建器需要对外部DrawMyCube实例的引用才能实例化一个新的MyCube. 出于这个原因，您可以将其设为内部（非静态）类MyCube：

public class DrawMyCube {

    protected class MyCube extends Square { }

    public class MyCubeBuilder extends Square.Builder { }
}

正如你所看到的，我仍然将它声明为相邻，MyCube因为将构建器作为其构建的内部类是没有意义的。

编辑：正如您所提到的，一个简单的替代方法是使MyCube静态：

public class DrawMyCube {

    protected static class MyCube extends Square {

        public static class Builder extends Square.Builder { }
    }
}

因为老实说，使用内部类并没有太大的好处——只是隐式的外部实例引用——这会让你保持现有的层次结构和命名约定。您可以自己轻松地实现对外部的引用DrawMyCube——它只需要更多的代码。

作为旁注，您可能想要使用泛型来实现构建器模式，例如Builder<T>实现构建T. 事实上，没有办法缩小派生构建器类生成的范围。这是我暗示的草图：

abstract class Square { }

abstract class SquareBuilder<T extends Square> { }

class MyCube extends Square { }

class MyCubeBuilder extends SquareBuilder<MyCube> { }
于 2012-11-06T23:00:56.510 回答