Как проинициализировать переменную java

Переменные: типы, объявление, инициализация

В этой статье мы с вами разберемся что такое переменные в Java и научимся работать с ними.

x = 1; y = x + 1; // y = 2 z = y + x; // z = 3 

В этом примере мы содали 3 математические переменные с именами: x, y, z.

Сначала мы создали (объявили) переменную x и сразу же присвоили (инициализировали) ей значение 1.

Во второй строчке мы создали переменную y и присвоили ей значение, основываясь на текущем значении переменной x.

В третьей строке мы объявили и инициализировали переменную z, основываясь на значениях переменных x и y.

В Java переменные работают практически таким же образом, с единственной разницей — при создании переменной нужно указать, какие данные она будет хранить. В отличие от Javascript, каждая переменная может хранить только определенный тип данных — тот, под который она создавалась.

По аналогии с реальным миром: переменная — это некое хранилище, которое может хранить что-то определенное: сундук — хранилище для сокровищ, а бочка — для вина. Согласитесь, что хранить вино в сундуке, а сокровища — в бочонке будет несколько. неудобно. Точно такие же правила работают в Java. Например, тип int (от англ integer) означает, что переменная хранит целое число (в таком случае дробное в нее уже записать будет невозможно!), а String — переменная для строкового типа данных (в нее мы записываем текст).

Давайте рассмотрим небольшой пример:

int x = 999; //объявили целочисельную переменную под именем "x" и присвоили ей значение 999 int y = x + 1; //объявили и инициализировали (присвоили значение) целочисельную переменную "y" со значением 1000 (999 + 1) String someText = "hi!"; //объявили и инициализировали переменную "someText" со значением "hi!" 

Обратите внимание: когда мы инициализируем переменную числового типа — в качестве значения переменной мы указываем просто число. Когда мы инициализируем переменную строкового типа — мы пишем текст в двойных кавычках: «text» . В Java строковые ( String ) данные всегда выделяются двойными кавычками, и только отдельные символы ( char ) — одинарными ‘O’ .

String s = "One more time"; //строковые данные в двойных кавычках char sign = 'x'; //переменная "sign" может хранить исключительно символы; сейчас она хранит символ "x" 

Немного теории (оба определения верны):

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

Что это означает на практике:

• Переменная представляет собой некий контейнер (физически — это область в оперативной памяти).
• Переменная всегда должна иметь какое-то имя (по имени мы обращаемся к переменной).
• Переменная может содержать какие-то данные, а может и не содержать (если мы присвоили значение переменной, то она его содержит; а если мы этого не делали, то в некоторый случаях она содержит значение по умолчанию, а в некоторых — остается пустой).
• Значение переменной может меняться с ходом выполнения программы.

В Java переменная может быть примитивной или ссылочной.

Примитивные типы можно разделить на 4 группы:

1. Целочисленные (целые числа) — byte , short , int , long .
2. С плавающей точкой (вещественные, дробные) — float , double .
3. Символы (буквенные символы) — char .
4. Логические — boolean .

Ссылочный тип данных — тема очень обширная. Сегодня достаточно запомнить, что тип String относится к ссылочным данным, а в другой раз поговорим о них более подробно.

В жизни каждой переменной есть два важных момента:

Объявление переменной — этап когда мы сообщили программе, что мы создаем новую переменную:

int x; //мы объявили переменную "x", которая будет хранить целые числа, например 1000 double y; //переменная "y" будет хранить числа с плавающей точкой (дробные), например 99.99 char sign; //переменная "sign" будет хранить символы, например 'a', 'b', '!', если захотите - ',' и другие boolean isTrue; //переменная "isTrue" будет хранить логические значение, их только два: "true" и "false" String message; //переменная "message" будет хранить текст, возможно, даже такой: "Сколько же этих переменных?!" 

int number1, number2; //мы объявили сразу 2 переменных в одной строке boolean isPresent1, isPresent2; //объявляем 2 логические переменные 

Важно!

 //Здесь мы только объявляем переменные: int x; double y; char sign; boolean isTrue; int var1, var2; boolean isPresent1, isPresent2; String message; //Здесь мы инициализируем переменные: x = 1; //как видим, в момент инициализации тип переменной указывать не нужно; y = 0.5; //дробную часть мы отмечаем точкой "." sign = 'a'; //символы обязательно брать в одинарные кавычки '' isTrue = true; //логический тип имеет только два значения: истина/ложь; true = истина var1 = x; //переменной можно присваивать значение другой переменной, главное чтобы они были одного типа var2 = 1000 + 1; //несмотря на то, что переменные объявлялись в одну строку, инициализироваться они могу отдельно друг от друга. isPresent1 = isPresent2 = false; //. а могут и вместе message = "Вот такое вот пироги"; 

Также в одной строке можно выполнить оба эти действия — объявить переменную и инициализировать ее:

int myVar = 500; int myVar2 = myVar + 1; //myVar = 501 

В программировании переменная может менять свое значение прямо в процессе выполнения программы:

int x = 1; //x = 1 int y = x; //y = 1 x = x + 1; //x = 2; y = 1; обращаем внимание, что тип переменной указывать не нужно - его мы указываем только при объявлении y = 100; //x = 2; y = 100 x = y - x; //x = 98; y = 100 String message = "пока o_O"; message = "привет =)"; //да-да, со строками это тоже возможно 

Несколько слов об именовании:

• Переменные именуются в lowerCamelCase стиле, то есть если имя состоит из нескольких слов, то оно пишется слитно, а каждое новое слово — с заглавной буквы: firstVariable , carBrend , maxNumber . Первая буква всегда будет строчная.
• Имена чувствительны к регистру. variable и Variable (в первом случае первая буква строчная, во втором — Заглавная) для Java — 2 разных переменных;
• Имя переменной не должно быть ключевым или зарезервированным словом языка Java. Список ключевых и зарезервированных слов можно найти здесь.

Ключевое слово var

Начиная с Java 10 в язык было добавлено ключевое слово var , которое также позволяет определять переменную:

var x = 5; System.out.println(x); // 5 

Слово var ставится вместо типа данных, но не означает что переменная может быть любого типа. Тип переменной определяется автоматически при присвоении ей значения. Например, переменой x приваивается число 5, значит переменная будет представлять тип int .

Но если переменная объявляется с помощью var, то мы обязательно должны инициализировать ее, то есть предоставить ей начальное значение, иначе мы получим ошибку.

Задача 1

Создайте 2 целочисленные переменные и выведите их сумму на экран:

Нажмите, чтобы подсмотреть решение

Задача 2

Создайте вещественные (дробные) переменные x со значением 99.0, y со значением 0.9 , логическую переменную isTrue со значением false и строковую переменную plus со значением » + » . Используя все 4 переменные (не значение, а непосредственно созданные переменные) и немного текста выведите на экран фразу:

Подсказка `System.out.print(x);` — эта команда выводит на экран значение переданной переменной и **НЕ** переводит текст на следующую строку. Нажмите, чтобы подсмотреть решение

results matching » «

No results matching » «

Источник

Initializing Fields

As you have seen, you can often provide an initial value for a field in its declaration:

public class BedAndBreakfast < // initialize to 10 public static int capacity = 10; // initialize to false private boolean full = false; >

This works well when the initialization value is available and the initialization can be put on one line. However, this form of initialization has limitations because of its simplicity. If initialization requires some logic (for example, error handling or a for loop to fill a complex array), simple assignment is inadequate. Instance variables can be initialized in constructors, where error handling or other logic can be used. To provide the same capability for class variables, the Java programming language includes static initialization blocks.

Note: It is not necessary to declare fields at the beginning of the class definition, although this is the most common practice. It is only necessary that they be declared and initialized before they are used.

Static Initialization Blocks

A static initialization block is a normal block of code enclosed in braces, < >, and preceded by the static keyword. Here is an example:

A class can have any number of static initialization blocks, and they can appear anywhere in the class body. The runtime system guarantees that static initialization blocks are called in the order that they appear in the source code.

There is an alternative to static blocks — you can write a private static method:

The advantage of private static methods is that they can be reused later if you need to reinitialize the class variable.

Initializing Instance Members

Normally, you would put code to initialize an instance variable in a constructor. There are two alternatives to using a constructor to initialize instance variables: initializer blocks and final methods.

Initializer blocks for instance variables look just like static initializer blocks, but without the static keyword:

The Java compiler copies initializer blocks into every constructor. Therefore, this approach can be used to share a block of code between multiple constructors.

A final method cannot be overridden in a subclass. This is discussed in the lesson on interfaces and inheritance. Here is an example of using a final method for initializing an instance variable:

This is especially useful if subclasses might want to reuse the initialization method. The method is final because calling non-final methods during instance initialization can cause problems.

Previous page: Understanding Class Members
Next page: Summary of Creating and Using Classes and Objects

Источник