Значения по умолчанию и инициализация в Java

Ответ 1

В первом примере кода a является локальной переменной метода main. Локальные переменные метода должны быть инициализированы перед их использованием.

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

Ответ 2

Внимательно прочитайте ссылку:

Значения по умолчанию

Не всегда необходимо назначать значение при объявлении поля. Поля, объявленные, но не инициализированные, будут установлены на разумный по умолчанию компилятор. Вообще говоря, это значение по умолчанию будет равна нулю или null, в зависимости от типа данных. Опираясь на такие значения по умолчанию, однако, обычно считаются плохим программированием стиль.

В следующей таблице приведены значения по умолчанию для вышеуказанных данных типы.

.,

Локальные переменные несколько отличаются; компилятор никогда не назначает значение по умолчанию для неинициализированной локальной переменной. Если вы не можете инициализируйте свою локальную переменную там, где она объявлена, убедитесь, что присвойте ему значение, прежде чем пытаться его использовать. Доступ к неинициализированная локальная переменная приведет к ошибке времени компиляции.

Ответ 3

Это основные факторы:

• переменная участника (по умолчанию ОК)
• статическая переменная (по умолчанию ОК)
• конечная переменная участника (не инициализирована, должна быть установлена ​​на конструкторе)
• конечная статическая переменная (не инициализированная, должна быть установлена ​​на статический блок {})
• локальная переменная (не инициализирована)

Примечание 1: вы должны инициализировать конечные переменные-члены в каждом реализованном конструкторе!

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

private final int memberVar;

public Foo() {
    //invalid initialization of a final member
    init();
}

private void init() {
    memberVar = 10;
}

Примечание 3: массивы - это объекты на Java, даже если они хранят примитивы.

Примечание 4: при инициализации массива все его элементы устанавливаются по умолчанию независимо от того, является ли он членом или локальным массивом.

Я прилагаю пример кода, представляющий вышеупомянутые случаи:

public class Foo {
    //static and member variables are initialized to default values

    //primitives
    private int a; //default 0
    private static int b; //default 0

    //objects
    private Object c; //default NULL
    private static Object d; //default NULL

    //arrays (Note: they are objects too, even if they store primitives)
    private int[] e; //default NULL
    private static int[] f; //default NULL

    //what if declared as final?

    //primitives
    private final int g; //not initialized, MUST set in constructor
    private final static int h; //not initialized, MUST set in a static {}

    //objects
    private final Object i; //not initialized, MUST set in constructor
    private final static Object j; //not initialized, MUST set in a static {}

    //arrays
    private final int[] k; //not initialized, MUST set in constructor
    private final static int[] l; //not initialized, MUST set in a static {}

    //initialize final statics
    static {
        h = 5;
        j = new Object();
        l = new int[5]; //elements of l are initialized to 0
    }

    //initialize final member variables
    public Foo() {
        g = 10;
        i = new Object();
        k = new int[10]; //elements of k are initialized to 0
    }

    //A second example constructor
    //you have to initialize final member variables to every constructor!
    public Foo(boolean aBoolean) {
        g = 15;
        i = new Object();
        k = new int[15]; //elements of k are initialized to 0
    }

    public static void main(String[] args) {
        //local variables are not initialized
        int m; //not initialized
        Object n; //not initialized
        int[] o; //not initialized

        //we must initialize them before usage
        m = 20;
        n = new Object();
        o = new int[20]; //elements of o are initialized to 0
    }
}

Ответ 4

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

public class Main {
      int instaceVariable; // Instance variable will be initalized to default value
    public static void main(String[] args) {
        int localVariable = 0; // Local Variable Need to initalize before use
    }
}

Ответ 5

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

Это:

• Знакам, объявленным внутри метода, не присваивается значение по умолчанию.
• Значения, объявленные как переменная instanced или статическая переменная, будут иметь значения по умолчанию, которые равны 0.

Итак, в вашем коде:

public class Main {
    int instanceVariable;
    static int staticVariable;
    public static void main(String[] args) {
        Main mainInstance = new Main() 
        int localVariable;
        int localVariableTwo = 2;
        System.out.println(mainInstance.instanceVariable);
        System.out.println(staticVariable);
       // System.out.println(localVariable); //will throw compilation error
        System.out.println(localVariableTwo);

    }
}

Ответ 6

Локальные переменные не получают значения по умолчанию. Их начальные значения равны undefined, не назначая значения каким-либо образом. Прежде чем вы сможете использовать локальные переменные, они должны быть инициализированы.

Существует большая разница, когда вы объявляете переменную на уровне класса (как член, то есть как поле) и на уровне метода.

Если вы объявляете поле на уровне класса, они получают значения по умолчанию в соответствии с их типом. Если вы объявляете переменную на уровне метода или в виде блока (означает, что anycode внутри {}) не получает никаких значений и остается undefined, пока каким-то образом они не получат некоторые начальные значения, то есть некоторые значения, назначенные им.

Ответ 7

Все переменные-члены должны загружаться в кучу, поэтому они должны инициализироваться значениями по умолчанию при создании экземпляра класса. В случае локальных переменных они не загружаются в кучу, они хранятся в стеке до тех пор, пока они не будут использоваться до java 7, поэтому нам необходимо явно их инициализировать.

Ответ 8

В java инициализация по умолчанию применима только для переменной экземпляра класса он не применим для локальных переменных.