对象及数据结构优化方案

1.对象的反对称

一段很简单的代码

/**
 * @author huzhibo
 * @Description: 乘法实现
 * @date 2020/8/23 22:00
 */
public class Multiplication {
    public double numOne;
    public double numTwo;

    public Multiplication(double numOne, double numTwo) {
        this.numOne = numOne;
        this.numTwo = numTwo;
    }
}

我们可以看到，对象的形状类都是简单的数据结构，所有的行为都在逻辑类中实现，优化方案如下：

/**
 * @author huzhibo
 * @Description:
 * @date 2020/8/23 22:02
 */
public class Test {
    private final static double NUMONE = 1;
    private final static double NUMTWO = 2;
    public static void main(String[] args) throws Exception{
        Multiplication multiplication = new Multiplication(NUMONE, NUMTWO);
        double v = multiplication.numOne * multiplication.numTwo;
    }
}

举例是很基础的， 但是实际应用中会出现类包含类的情况，我们应尽可能多的考虑。得出以下结论:

(1).对象的基本方法都需要在对象中实现。逻辑层只需要关注方法实现的功能而不能关注功能实现的方式。

(2).类的属性都应该是private类型的。对外不能暴露属性。只能通过get，set方法取调用（特殊情况下不适用，例如常量类）

2.得墨忒定律

得墨忒定律提到，我们不应该调用一个对象中包含的另一个对象的方法：

public class StringTest {
    private String string;

    public String getString() {
        return string;
    }

    public void setString(String string) {
        this.string = string;
    }
}

public class StringTestOne {
    private StringTest stringTest;

    public StringTest getStringTest() {
        return stringTest;
    }

    public void setStringTest(StringTest stringTest) {
        this.stringTest = stringTest;
    }
}

public class Test {
    private final static double NUMONE = 1;
    private final static double NUMTWO = 2;
    public static void main(String[] args) throws Exception{
        String string = new StringTestOne().getStringTest().getString();
    }
}

此类中，方法进行了多次调用，是不合理的。

 

3.Dto是一个传送对象，它应该只包含公共变量，不能存在函数。