назначить частный член внутри класса непосредственно после объявления [duplicate]

Второй пример - ленивая инициализация. Первая - более простая инициализация, они по существу одинаковы.

Я не видел в ответах следующее:

Возможное преимущество наличия инициализации во время объявления может быть в настоящее время IDE, где вы можете очень легко перейти к объявлению переменной (в основном Ctrl-<hover_over_the_variable>-<left_mouse_click>) из любого места вашего кода. Затем вы сразу увидите значение этой переменной. В противном случае вам нужно «искать» место, где выполняется инициализация (в основном: конструктор).

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

Я думаю, что пример 2 предпочтительнее. Я считаю, что наилучшей практикой является объявление вне конструктора и инициализация в конструкторе.

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

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

1. избегать повторения = если вы имеют более одного конструктора, или когда вам нужно будет добавить больше, вам не придется повторять инициализацию снова и снова во всех телах конструкторов;
2. улучшенная читаемость = вы можете легко сказать с первого взгляда какие переменные должны быть инициализированы извне класса,
3. сокращенные строки кода = для каждой инициализации, сделанной при объявлении, в конструкторе будет меньше строки.

мое личное «правило» (вряд ли когда-либо сломано) заключается в следующем:

• объявить все переменные в начале блока
• сделать все переменные окончательными, если они не могут быть
• объявить одну переменную на строку
• никогда не инициализировать переменную, где объявлено
• , только инициализировать что-то в конструкторе, когда ему нужны данные от конструктора, чтобы выполнить инициализацию

Итак, у меня был бы код вроде:

public class X
{
    public static final int USED_AS_A_CASE_LABEL = 1; // only exception - the compiler makes me
    private static final int A;
    private final int b;
    private int c;

    static 
    { 
        A = 42; 
    }

    {
        b = 7;
    }

    public X(final int val)
    {
        c = val;
    }

    public void foo(final boolean f)
    {
        final int d;
        final int e;

        d = 7;

        // I will eat my own eyes before using ?: - personal taste.
        if(f)
        {
            e = 1;
        }
        else
        {
            e = 2;
        }
    }
}

Таким образом, я всегда на 100% уверен, где искать объявления переменных (в начале блока) и их назначения (как только это имеет смысл после объявления). Это приводит к повышению эффективности, поскольку вы никогда не инициализируете переменную со значением, которое не используется (например, объявлять и инициализировать vars, а затем выдавать исключение, прежде чем половина этих варов должна иметь значение). Вы также не завершаете бессмысленную инициализацию (например, int i = 0, а затем позже, прежде чем использовать «i», выполните i = 5;.

Я очень сильно оцениваю последовательность, поэтому следуя этому «rule» - это то, что я делаю все время, и это упрощает работу с кодом, так как вам не нужно искать вещи.

Ваш пробег может отличаться.

Есть еще одна тонкая причина для инициализации вне конструктора, о которой никто не упоминал раньше (очень конкретный должен сказать). Если вы используете инструменты UML для создания диаграмм классов из кода (обратное проектирование), большинство инструментов, которые, как я полагаю, заметят инициализацию примера 1 и передадут его на диаграмму (если вы предпочитаете, чтобы он отображал начальные значения, например Я делаю). Они не будут принимать эти начальные значения из примера 2. Опять же, это очень конкретная причина - если вы работаете с инструментами UML, но как только я узнал об этом, я пытаюсь использовать все значения по умолчанию вне конструктора, если, как и было упомянутый выше, существует проблема возможного выброса или сложной логики.

Я считаю, что это почти вопрос вкуса, если инициализация проста и не нуждается в какой-либо логике.

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

Подробнее о инициализации в Java см. в http://java.sun.com/docs/books/tutorial/java/javaOO/initial.html (и для объяснений по блокам инициализатора и другим малоизвестным функциям инициализации).