Question

我知道什么是耦合和凝聚力我有以下示例，它有一些可维护性问题，因此需要进行一些重构：

问题是，除了GLOBAL VARIABLES之外，我无法解决任何耦合，内聚或任何其他可维护性问题。如果没有这个全局变量问题，我怎么能重构以下代码（因为全局变量增加了复杂性并且增加了代码的不灵活性？！）

double value;
double min, max;

public void read()
{
    do 
    {
        value = ConsoleInput.readDouble();
    }
    while(value < min || value > max);
}

public double hyp()
{
    double x, y;
    min = 0.0;
    max = 100.0;
    read();
    x = value;
    read();
    y = value;
    return Math.sqrt(x * x + y * y);
 }

我正在考虑重构如下：

public void read()
{
    double value;
    double min = 0.0;
    double max = 100.0;

    do 
    {
        value = ConsoleInput.readDouble();
    }
    while(value < min || value > max);
}

public double hyp()
{
    double x, y;
    read();
    x = value;
    read();
    y = value;
    return Math.sqrt(x * x + y * y);
 }

这看起来不错吗？或者还有其他有效的重构方法吗？

Answer 1

重构您的read()方法，如下所示：

public double read(double min, double max)

因此，不是将值保存在全局中，而是从函数

返回

Answer 2

根据您提供的信息，我建议如下：

public double read() {
    // set value to a not accepted value to start the while-loop
    double value = -1;
    double min = 0.0;
    double max = 100.0;

    while(value < min || value > max) {
        value = ConsoleInput.readDouble();
    }
    return value;
}

public double hyp() {
    double x = read();
    double y = read();
    return Math.sqrt(x * x + y * y);
}

Answer 3

拥有像min和max这样的“全局变量”是绝对正确的，如果它们只在其自己的类中“全局” - 那就是应该使用类变量的方式。

但是“read”值应返回值，而不是将其插入某个类变量然后使用。在构造函数中使用min和max创建类的实例以获得最大的灵活性，但也有默认的构造函数，这将是很好的。

public class GoodApp {

    private double min, max;

    public GoodApp(double min, double max){
        this.min = min;
        this.max = max;
    }

    public GoodApp(){
        this(1,100);
    }

    public double read() {
        double value;
        do {
            value = ConsoleInput.readDouble();
        } while (value < min || value > max);
        return value;
    }


    public double hyp() {
        double x, y;
        x = read();
        y = read();
        return Math.sqrt(x * x + y * y);
    }
}

Answer 4

这是我的版本。要记住几点 - 一个方法应该正确地暴露它的依赖（它依赖于什么 - 像依赖注入），否则它可能是一个骗子。此外，您的read方法没有使用当前对象的状态（即它没有使用this引用）。因此，它可以是静态的（但这会使单元测试变得困难 - 如果它是您的担忧）。

所以，我建议如下（这对于这个小程序来说似乎有些过分 - 但在实时项目中表现不错。它会减少耦合，因为你可以推送任何ReadData实现） -

enum Bound{

 MAX(100.0), MIN(0.0);

 public double value(){
     return this.value;
 }

 private final double value;

 private Bound(double value){
     this.value = value;
 }

}


public class CalcHyp{

ReadData readData;

CalcHyp(ReadData readData){
    this.readData = readData;
}

public double hyp() {
    double x = readData.read();
    double y = readData.read();
    return Math.sqrt(x * x + y * y);
}

public static void main(String[] args) {
    CalcHyp calcHyp = new CalcHyp(new ReadData());//Declare the dependencies.(Dependency Injection)
    System.out.println(calcHyp.hyp());
}

}

class ReadData{ //Can declare an interface in real time, and various implementations based on your requirement.

  double read() {

    double value = Bound.MAX.value()+1;
    while(value < Bound.MIN.value() || value > Bound.MAX.value()) {
        value = ConsoleInput.readDouble();
    }
    return value;
}
}

耦合和内聚示例（重构代码）

4 个答案: