类

• 单一权责(SRP)

public class SuperDashboard extends JFrame implements MetaDataUser {
    public Component getLastFocusedComponent()
    public void setLastFocused(Component lastFocused)
    public int getMajorVersionNumber()
    public int getMinorVersionNumber()
    public int getBuildNumber()
}

不符合单一权责原则，重构：

public class Version {
    public int getMajorVersionNumber()
    public int getMinorVersionNumber()
    public int getBuildNumber()
}

每个类都应该都应该遵守单一职责。

• 类的高内聚

  （如果一个类的变量，被类中的每个方法所使用，则该类具有最大内聚性。）

类的高内聚，意味着类的方法、变量相互依赖，结合为一个逻辑整体。

以下就是一个高内聚的类，除size()方法，其余方法中都完全使用了类的变量。

public class Stack {
    private int topOfStack = 0;
    List < Integer > elements = new LinkedList < Integer > ();
    public int size() {
        return topOfStack;
    }
    public void push(int element) {
        topOfStack++;
        elements.add(element);
    }
    public int pop() throws PoppedWhenEmpty {
        if (topOfStack == 0) throw new PoppedWhenEmpty();
        int element = elements.get(--topOfStack);
        elements.remove(topOfStack);
        return element;
    }
}

当我们把很大的方法 拆分 为一个个较小的方法时，如果小方法中用到了原有方法中的4个变量，那我们就要把这4个变量当作参数？4个参数的方法可不太好。

那我们把这四个变量设置为类变量，是方法共享。可是肯定其他大多数方法不会使用，这就降低了内聚邢。

其实，我们应该把他们拆成单独的类，既保证了内聚，又把长方法拆分了。

所以

把大方法拆分为小方法，也是把大类拆分为小类的时机，会使结构更加有组织

public class Sql {
    public Sql(String table, Column[] columns)
    public String create()
    public String insert(Object[] fields)
    public String selectAll()
    public String findByKey(String keyColumn, String keyValue)
    public String select(Column column, String pattern)
    public String select(Criteria criteria)
    public String preparedInsert()
    private String columnList(Column[] columns)
    private String valuesList(Object[] fields, final Column[] columns)
    private String selectWithCriteria(String criteria)
    private String placeholderList(Column[] columns)
}

重构后：

abstract public class Sql {
    public Sql(String table, Column[] columns)
    abstract public String generate();
}
public class CreateSql extends Sql {
    public CreateSql(String table, Column[] columns)@Override public String generate()
}
public class SelectSql extends Sql {
    public SelectSql(String table, Column[] columns)@Override public String generate()
}
public class InsertSql extends Sql {
    public InsertSql(String table, Column[] columns, Object[] fields)@Override public String generate()
    private String valuesList(Object[] fields, final Column[] columns)
}
public class SelectWithCriteriaSql extends Sql {
    public SelectWithCriteriaSql(
    String table, Column[] columns, Criteria criteria)@Override public String generate()
}
public class SelectWithMatchSql extends Sql {
    public SelectWithMatchSql(
    String table, Column[] columns, Column column, String pattern)@Override public String generate()
}
public class FindByKeySql extends Sql
public FindByKeySql(
String table, Column[] columns, String keyColumn, String keyValue)@Override public String generate()
}
public class PreparedInsertSql extends Sql {
    public PreparedInsertSql(String table, Column[] columns)@Override public String generate() {
        private String placeholderList(Column[] columns)
    }
    public class Where {
        public Where(String criteria)
        public String generate()
    }
    public class ColumnList {
        public ColumnList(Column[] columns)
        public String generate()
    }

有百利无一害，它符合 SRP、OCP，低内聚、更方便测试等等