惯用Java：约束数据

使用一个简单的Java

Point

类，我想将X和Y值限制为双倍，必须在-10到10之间，包括10到10。我已经编写了一些代码，但我已经多年没有编写java了，我想知道这是否是用现代java编写的：

public class Point {
    private double x;
    private double y;

    public Point(double x, double y) {
        constrain("x", x);
        constrain("y", y);
        this.x = x;
        this.y = y;
    }

    // is there a cleaner/shorter way of handling this, such as a direct way of declaring a
    // subtype of double that I could use in method signatures?
    protected static void constrain(String name, double val) {
        if ( val < -10 || val > 10 ) {
            throw new IllegalArgumentException(name + " must be between -10 and 10");
        }
    }

    public double getX() { return x; }

    public void setX(double x) {
        constrain("x", x);
        this.x = x;
    }

    public double getY() { return y; }

    public void setY(double y) {
        constrain("y", y);
        this.y = y;
    }

    @Override
    public String toString() {
        return ("[" + x + "," + y + "]"); 
    }
}

公共类点{
私人双x；
私人双y；
公共点（双x，双y）{
约束（“x”，x）；
约束（“y”，y）；
这个.x=x；
这个。y=y；
}
//是否有更干净/更短的处理方法，例如直接声明
//我可以在方法签名中使用的double的子类型？
受保护的静态void约束（字符串名称，双val）{
如果（val<-10 | val>10）{
抛出新的IllegalArgumentException（name+“必须介于-10和10之间”）；
}
}
公共双getX（）{return x；}
公共无效集x（双x）{
约束（“x”，x）；
这个.x=x；
}
公共双getY（）{return y；}
公共空间设置（双y）{
约束（“y”，y）；
这个。y=y；
}
@凌驾
公共字符串toString（）{
返回（“[”+x+“，“+y+”]）；
}
}

我可能会这样做：

public class Point
{

    private static final double X_MIN = -10.0, X_MAX = 10.0;
    private static final double Y_MIN = -10.0, Y_MAX = 10.0;

    private double x, y;

    public Point(double x, double y) throws IllegalArgumentException
    {
        setX(x);
        setY(y);
    }

    public double getX()
    {
        return x;
    }

    public double getY()
    {
        return y;
    }

    public void setX(double x) throws IllegalArgumentException
    {
        if (x < X_MIN || x > X_MAX)
        {
            throw new IllegalArgumentException("X out of range.");
        }

        this.x = x;
    }

    public void setY(double y) throws IllegalArgumentException
    {
        if (y < Y_MIN || y > Y_MIN)
        {
            throw new IllegalArgumentException("Y out of range");
        }

        this.y = y;
    }

    @Override
    public String toString()
    {
        return String.format("[%.1f,%.1f]", x, y);
    }
}

公共类点
{
私人静态最终双X_最小值=-10.0，X_最大值=10.0；
私人静态最终双Y_最小值=-10.0，Y_最大值=10.0；
私人双x，y；
公共点（双x，双y）抛出IllegalArgumentException
{
setX（x）；
赛蒂（y）；
}
公共双getX（）
{
返回x；
}
公共双盖
{
返回y；
}
公共void setX（双x）抛出IllegalArgumentException
{
如果（xx|u最大值）
{
抛出新的IllegalArgumentException（“X超出范围”）；
}
这个.x=x；
}
public void setY（双y）抛出IllegalArgumentException
{
如果（yy|u MIN）
{
抛出新的IllegalArgumentException（“Y超出范围”）；
}
这个。y=y；
}
@凌驾
公共字符串toString（）
{
返回字符串.format（“[%.1f，%.1f]”，x，y）；
}
}

如果X和Y值始终来自同一个域，则可以将它们封装在一个类中，以便为您执行检查：

class Coord {
    private final double scalarValue;
    public Coord(double scalarValue) throws IllegalArgumentException {
        if (Math.abs(scalarValue) > MAX_COORD) {
            throw new IllegalArgumentException("Coordinate out of range");
        }
        this.scalarValue = scalarValue;
    }
    public double getScalar() {
        return scalarValue;
    }
}

这将检查放在一个地方，并允许您在将来扩展坐标功能，而不会弄乱Point类。它还显式地使坐标不可变，这可能是一个好主意（取决于用例）

然后，点构造函数变成：

public Point(Coord x, Coord y);

---

可能是一个。但是FWIW，这可能是当今最惯用的使用番石榴先决条件来解决的。这可能是基于观点的，可能对codereview.stackexchange.comNo有好处，还没有子类型。不要在通话中重复相反的内容。在构造函数中：this.x=x；替换为setX（x）；Naso先生：一个有趣的问题是如何用变量检查实例化Point，我指的不仅仅是限制。1.8具有“轻量级”代码对象，即lambdas，如果需要，可以使用它。（嗨，老Perl黑客！）您的代码是否编译并生成了预期结果？如果是这样的话，问题是什么？你在构造函数中丢失了支票。@劳恩，谢谢你指出这一点；忽略了这一点。答案已编辑。