Чистый код. Создание, анализ и рефакторинг

Еще раз выделю основные моменты: система должна состоять из множества мелких классов, а не из небольшого числа больших. Каждый класс инкапсулирует одну ответственность, имеет одну причину для изменения и взаимодействует с другими классами для реализации желаемого поведения системы.

Связность

Классы должны иметь небольшое количество переменных экземпляров. Каждый метод класса должен оперировать с одной или несколькими из этих переменных. В общем случае, чем с большим количеством переменных работает метод, тем выше связность этого метода со своим классом. Класс, в котором каждая переменная используется каждым методом, обладает максимальной связностью.

Как правило, создавать классы с максимальной связностью не рекомендуется… а скорее всего, это нереально. С другой стороны, связность класса должна быть высокой. Высокая связность означает, что методы и переменные класса взаимозависимы и существуют как единое целое.

Рассмотрим реализацию стека из листинга 10.4. Этот класс обладает очень высокой связностью. Из трех его методов только size() не использует обе переменные.

Листинг 10.4. Stack.java — класс с высокой связностью

public class Stack {

  private int topOfStack = 0;

  List elements = new LinkedList();

  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();

Листинг 10.4 (продолжение)

    int element = elements.get(--topOfStack);

    elements.remove(topOfStack);

    return element;

  }

}

Стратегия компактных функций и коротких списков параметров иногда приводит к росту переменных экземпляров, используемых подмножеством методов. Это почти всегда свидетельствует о том, что по крайней мере один класс пытается выделиться из более крупного класса. Постарайтесь разделить переменные и методы на два и более класса, чтобы новые классы обладали более высокой связностью.

Поддержание связности приводит к уменьшению классов

Сам акт разбиения больших функций на меньшие приводит к росту количества классов. Допустим, имеется большая функция, в которой объявлено много переменных. Вы хотите выделить один небольшой фрагмент этой функции в отдельную функцию. Однако выделяемый код использует четыре переменные, объявленные в исходной функции. Может, передать все четыре переменные новой функции в виде аргументов?

Ни в коем случае! Преобразовав эти четыре переменные в переменные экземпляров класса, мы сможем выделить код без передачи переменных. Таким образом, разбиение функции на меньшие фрагменты упрощается.

К сожалению, это также означает, что наши классы теряют связность, потому что в них накапливается все больше переменных экземпляров, созданных исключительно для того, чтобы они могли совместно использоваться небольшим подмножеством функций. Но постойте! Если группа функций должна работать с некоторыми переменными, не образуют ли они класс сами по себе? Конечно, образуют. Если классы утрачивают связность, разбейте их!

Таким образом, разбиение большой функции на много мелких функций также часто открывает возможность для выделения нескольких меньших классов. В результате строение программы улучшается, а ее структура становится более прозрачной.

Для демонстрации мы воспользуемся проверенным временем примером из замечательной книги Кнута «Literate Programming» [Knuth92]. В листинге 10.5 представлена программа Кнута PrintPrimes, переведенная на Java. Справедливости ради стоит отметить, что это не та программа, которую написал Кнут, а та, которую выводит его утилита WEB. Я воспользуюсь ей, потому что она является отличной отправной точкой для разбиения большой функции на несколько меньших функций и классов.

Листинг 10.5. PrintPrimes.java

package literatePrimes;

public class PrintPrimes {

  public static void main(String[] args) {

    final int M = 1000;

    final int RR = 50;

    final int CC = 4;

    final int WW = 10;

    final int ORDMAX = 30;

    int P[] = new int[M + 1];

    int PAGENUMBER;

    int PAGEOFFSET;

    int ROWOFFSET;

    int C;

    int J;

    int K;

    boolean JPRIME;

    int ORD;

    int SQUARE;

    int N;

    int MULT[] = new int[ORDMAX + 1];

    J = 1;

    K = 1;

    P[1] = 2;

    ORD = 2;

    SQUARE = 9;

    while (K < M) {

      do {

        J = J + 2;

        if (J == SQUARE) {