2

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

问题是，除了 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);
 }

这看起来对吗？或者有没有其他有效的重构方法？

4

4 回答 4

2

像这样重构你的read()方法：

public double read(double min, double max)

因此，与其将值保存在全局中，不如从函数中返回它

于 2015-05-27T13:39:49.623 回答
0

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

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);
}
于 2015-05-27T13:50:19.987 回答
0

如果它们仅在其自己的类中是“全局”的，那么拥有“全局变量”就像min并且max绝对没问题 - 这就是应该使用类变量的方式。

但是“读取”值应该返回值，而不是将其插入到某个类变量中然后使用。此外，最好在构造函数中创建具有 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);
    }
}
于 2015-05-27T13:53:11.637 回答
0

这是我的版本。需要记住的几点——一个方法应该正确地暴露它的依赖关系（它依赖什么——比如依赖注入），否则它可能是骗子。此外，您的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;
}
}
于 2015-05-27T14:55:41.957 回答