Сохранить введенное слово в переменной java. Переменные и константы в Java

Часто Вы можете услышать такое определение переменной:

• Переменная - это некоторый контейнер, в котором может храниться значение для дальнейшего использования в программе.

Помните, как в школе было: y = x + 1

И в зависимости от того, какие значения принимает переменная x, меняется значение переменной y.

Если x = 1, тогда x+ 1 =2

Если x = 2, тогда x +1 = 3

Если х = 1.5 , тогда x + 1 =2.5

В Java переменные играют такую же роль, как и в приведенном примере со школы y = x + 1. Они выполняют роль контейнера для разных значений, которые можно подставить в переменную. В приведённом примере - в переменную x.

Типы переменных в Java. Объявление переменной

В Java можно указать, какие именно значения может принимать переменная.

Для этого все переменные сгруппировали в 4 группы:

1. Символы (char)
2. Логические (boolean)

Примечание: Итого 8 типов переменных (byte, short, int, long, float, double, char, boolean). Многоуважаемый Брюс Эккель выделяет еще и 9-й тип – так называемый тип void («пустое» значение). Но в этой статье мы рассмотрим 8 типов, как это обычно принято. Что же такое тип void мы разберёмся в теме, посвященной методам в Java.

Теперь давайте рассмотрим каждую группу переменных. И начнём с целочисленных.

Целочисленные: byte, short, int, long

Как видно из таблички, byte, short, int, long относятся к целочисленным, то есть к целым числам. Например, 1, 9, 1278, -5, -107 и т.д.

Очевидно:

1. byte может принимать значения от -128 до 127 и при этом занимает 1 байт памяти
2. short принимает значения от -32768 до 32767 и занимает 2 байта памяти
3. int от -2147483648 до 2147483647 и занимает 4 байта памяти
4. long от -9223372036854775808 до 9223372036854775807 и занимает 8 байтов памяти

"Ну, хорошо", - скажете Вы. "Если byte, short, int и long отвечают все за целые числа, как мне понять какой именно тип нужно выбирать? " Помните детские задачки по математике, которые сейчас будут как нельзя кстати для объяснения за что отвечают byte, short, int, long.

Задача 1:

У Димы 3 яблока, у Ани 2 яблока. Сколько яблок у Димы и Ани вместе?

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

Значит, если бы мы писали код в Java, который бы предполагал решение данной задачи, мы бы использовали для переменных целочисленный тип. Остается понять только какой именно мы бы использовали: byte, short, int или long?

Всегда необходимо отталкиваться от контекста .

1. Если мы знаем точно, что при решении данной задачи, даже если будут меняться значения, например, у Димы 50 яблок, у Ани 30, но в сумме это будет не больше 127 яблок, то можем смело использовать тип byte
2. Если же мы знаем, что могут поменять условия задачи и у Димы может быть, например, 10 000 яблок, а у Ани, например, 7 000 яблок, то уже тип byte мы использовать не можем. Поскольку это явно выходит за пределы допустимых значений в byte – не более 127. Значит, могли бы использовать тип short, у которого максимально допустимое значение 32767

1. Если же предположить, что у Димы и у Ани может быть даже больше, чем 32767 яблок. Ну, например, у них яблоневые сады по всей Украине. Тогда необходимо использовать тип int. Кстати, int – это сокращенно от английского integer (целое число).
2. Ну, а если предположить, что Дима и Аня – это «яблочные магнаты» и им принадлежат все яблоневые сады в мире, то тогда число может быть намного больше, чем даже максимальное значение int 2147483647. И тогда необходимо использовать тип long.

Однако чаще всего при написании программ на Java, Вы будете использовать тип int. Это самый распространенный целочисленный тип. Более того, тип int в Java является типом "по умолчанию" для целочисленных типов. Что это значит, Вы узнаете на практике.

. А объявляются переменные так.

И здесь сразу же хочется сказать о том, что переменные, когда их название состоит из 2 и более слов, пишутся слитно и как бы "горбиками" как у верблюда. Такой стиль написания слов называется CamelStyle (от англ. camel - "верблюд").

Например:

int applesAnnaJune;

int applesDimaJuneUkraine;

Видите, названия примеров переменных состоят из 2 и более слов и пишутся слитно. Причем первое слово пишется с маленькой буквы, а во всех последующих словах первая буква большая. Теперь Вы знаете - это CamelStyle, стиль написания названий. Он иногда называется CamelCase. Мы об этом даже написали 🙂

Ну что ж, самое время понять за что отвечают переменные с плавающей точкой.

С плавающей точкой: float, double

И снова обратимся к примеру школьной задачи.

Задача 2:

У Димы 3,5 яблока, у Ани 2,5 яблока. Сколько яблок у Димы и Ани вместе?

Как видите, в задаче речь идёт уже не о целых яблоках. Уже речь идёт о дробных числах. А значит мы уже не можем использовать целочисленный тип: нам не подойдет ни byte, ни short, ни int, ни long. Запомните: как только речь идет о дробных числах, значит, речь идет о float и ли double. Примеры дробных чисел: 1.0, 1.8, 3.141562, 9.0, 12.579, 1278.0, -5.0, - 9.4, -107.0, -107.356 и т.д.

Как видно из таблички:

1. float может принимать значения от -3.4Е +38 до 3.4Е +38 и при этом занимает 4 байта памяти
2. double принимает значения от -1.7E + 308 до 1.7Е + 308 и занимает 8 байт памяти

Запомните:

• дробные числа пишутся не через запятую, как мы привыкли со школы, а через точку . Например, 1,5 - это неправильно. Правильно 1.5
• float определяет значение одинарной точности. Это значит, что переменные данного типа удобны, когда требуется дробная часть без особой точности. Например, для денежных сумм.
• double обеспечивает двойную точность и это видно из названия (double - двойная).

Прежде, чем использовать переменную, её необходимо объявить . А объявляются переменные float и double по такому же принципу.

А вот и

float money; // объявили переменную money типа float

float wage; // объявили переменную wage типа float

float c; // объявили переменную c типа float

double stat; //объявили переменную stat типа double

Символы: char

В Java для char используется кодировка Unicode. Как видно из таблички, диапазон допустимых значений char от 0 до 65536 и при этом занимает 2 байта памяти. Отрицательных значений не существует. На самом деле переменная типа char хранит не сам символ, а его числовой код из таблички Unicode, по этому мы можем проводить целочисленные операции над символами.

Прежде, чем использовать переменную, её необходимо объявить . А объявляются переменные char по такому же принципу, что и ранее.

Примеры объявления переменных:

char y; //объявили переменную y типа char

char f; //объявили переменную f типа char

Логические: boolean

Логические или их еще называют булевы значения могут принимать только одно из двух возможных значений: true или false.

Только у славян возможен такой разговор:

Кушать будешь?

Да нет, наверное.

Это то, что очень удивляет иностранцев, когда они учат, например, украинский или русский язык. Так все-таки да или все-таки нет?

Так вот в языке программирования Java всё очень точно:

• либо true (с английского - "истина")
• либо false (с английского - "ложь)

Чуть позже Вы поймете где применяется данный тип переменных, когда мы, например, дойдём до темы . А пока просто запомните, что есть такой тип. Пусть это будет пока "черной лошадкой" для Вас.

Прежде, чем использовать переменную, её необходимо объявить . А объявляются переменные boolean по такому же принципу, что и ранее.

Примеры объявления переменных:

boolean check1; //объявили переменную check1 типа boolean

boolean check2; //объявили переменную check2 типа boolean

Ну вот, теперь Вы знаете за что отвечают эти типы переменных:

Что ещё Вы должны знать?

1. Вы должны знать, что эти типы переменных относятся к так называемым примитивным типам переменных. Поэтому если услышите "примитивные типы данных" , "примитивы" или "primitives", знайте, речь идёт о 8 типах переменных - byte, short, int, long, float, double, char, boolean.

2. Есть еще один тип переменных - тип String . О нём мы поговорим в статье "Как присвоить значение переменной"

3. В Java очень важно п равильно оформлять код . Да-да, не только писать работающие программы, но ещё и правильно оформленные. Существует целый свод правил, который называется Code Conventions в Java. Так что можете смело скачивать и постепенно изучать. А сейчас мы рассмотрим только часть Code Conventions, а именно правила написания названий переменных. Итак, запоминаем.

5 правил выбора названий для переменных:

Правило №1 - переменные пишутся только латинскими буквами. Никакой кириллицы!!!

Например:

Правило №2 – имя переменной, по возможности, должно быть "говорящим"

Например:

int s; // так можно называть переменную, но когда кода много и все переменные имеют не говорящие названия, код очень тяжело читать

int size; // этот вариант более "говорящий", чем первый вариант int s; поскольку понятно из названия, что переменная отвечает за размер чего-то

Правило №3 - с чего может/не может начинаться имя переменной

Может начинаться с:

1. Любых латинских букв
2. $ или _

Не может начинаться с:

Ниже приводим несколько примеров - правильных и неправильных.

Правильно:

• int square;
• int $money;
• int width;
• int boxSize;
• double sum;
• double sumJune;

Неправильно:

• int 2square;
• int 101dalmatians;

Правило №4 – название переменной, состоящее из 2 и более слов, пишется в CamelStyle

Что такое CamelStyle мы с Вами уже обсудили в этой статьей чуть выше.

Правило №5 – нельзя использовать в названиях переменных эти 54 слова:

abstract, assert, boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum, extends, false, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, null, package, private, protected, public, return, short, static, strictfp, String, super, switch, synchronized, this, throw, throws, transient, true, try, void, volatile, while

Эти 54 слова имеют особое значение при написании кода на Java . Постепенно Вы поймёте где используется каждое слово. Причём после прочтения этой статьи, из 54 слов Вам уже станут знакомы те слова, которые мы выделили синим:

abstract, assert, boolean , break, byte , case, catch, char , class, const, continue, default, do, double , else, enum, extends, false , final, finally, float , for, goto, if, implements, import, instanceof, int , interface, long , native, new, null, package, private, protected, public, return, short , static, strictfp, String , super, switch, synchronized, this, throw, throws, transient, true , try, void, volatile, while

ПОДЫТОЖИМ:

Всего 4 группы переменных:

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

Эти 8 типов переменных (byte, short, int, long, float, double, char, boolean) относятся к там называемым примитивным типам переменных.

Прежде чем использовать переменную, её необходимо объявить:

5 правил выбора названий переменных:

1. Переменные пишутся только латинскими буквами. Никакой кириллицы!!!
2. Имя переменной, по возможности, должно быть "говорящим"
3. Если переменная состоит из 2 и более слов, пишется в CamelStyle (другое название - CamelCase)
4. Есть 54 слова, которые нельзя использовать в названиях переменных
5. Имя переменной:

• может начинаться с любых латинских букв, $ или _
• не может начинаться с цифр

Также есть еще один тип переменных - тип String, о котором мы поговорим в статье "Как присвоить значение переменной в Java"

Надеемся, что наша статья была Вам полезна. Также есть возможность записаться на наши курсы по Java в Киеве. Обучаем с нуля.

По всем вопросам звоните:

38 050 205 77 99

38 098 205 77 99

Или читайте информацию по нашим курсам Java c нуля у нас на .

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

Все типы в Java подразделяются на примитивные и ссылочные . Примитивными являются логический тип boolean , целые числовые типы byte , short , int , long , char и плавающие числовые типы float и double . К ссылочным типам относятся классы , интерфейсы и массивы . Существует также специальный нулевой тип .

Объект в Java — это или динамически созданный экземпляр класса, или динамический созданный массив. Значениями ссылочного типа являются ссылки на объекты. Все объекты, включая массивы, наследуют методы класса Object . Строки представляются объектами класса String .

Переменная — это именованное хранилище данных определенного типа. Точнее говоря:

• Переменная примитивного типа всегда содержит значение именно этого типа.
• Переменная типа класс может содержать либо значение null (нулевую ссылку), либо ссылку на объект данного класса или его наследника.
• Переменная типа интерфейс может содержать либо нулевую ссылку, либо ссылку на объект любого класса, реализующий данный интерфейс.
• Переменная типа " array of T ", где T — примитивный тип, может содержать либо нулевую ссылку, либо ссылку на объект типа " array of T ".
• Переменная типа " array of T ", где T — ссылочный тип, может содержать либо нулевую ссылку, либо ссылку на массив, состоящий из данных, совместимых с T по присваиванию.
• Переменная типа Object может содержать либо нулевую ссылку, либо ссылку на любой объект.

5.3.2. Примитивные типы

5.3.2.1. Тип boolean

Тип boolean состоит из двух логических констант: true (истина) и false (ложь). Логическое значение может быть приведено к типу boolean , другие неявные приведения к данному типу в Java отсутствуют. Логическое значение может быть преобразовано в строку по правилу неявного преобразования строк.

Пример декларации логической переменной:

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

5.3.3.2. Класс Object

Стандартный класс Object является предком всех остальных классов Java, которые наследуют его методы. Подробно эти методы описаны в гл. 5.14 .

5.3.3.3. Класс String

Экземплярами класса String являются текстовые строки, т. е. цепочки символов Unicode. Объект класса String имеет постоянное (неизменяемое) значение. Строковые константы являются ссылками на экземпляры класса String .

Оператор конкатенации строк неявно создает новый объект класса String .

5.3.4. Переменные

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

5.3.4.1. Виды переменных

В Java существуют семь разновидностей переменных:

1. Переменная класса — это статическое поле данных в декларации класса или любое поле данных в декларации интерфейса. Переменная класса создается при загрузке ее класса или интерфейса; сразу после создания ей присваивается значение по умолчанию. Переменная класса уничтожается, когда ее класс или интерфейс выгружается (после завершения его финализации).
2. Переменная реализации — это поле данных в декларации класса, которое не является статическим. Такая переменная создается и получает значение по умолчанию при создании экземпляра данного класса или класса, который является его потомком. Переменная реализации уничтожается, когда соответствующий экземпляр класса удаляется процедурой сборки мусора (после завершения его финализации).
3. Элементы массива — это неименованные переменные, которые создаются и получают значение по умолчанию при создании массива. Эти переменные уничтожаются, когда массив удаляется процедурой сборки мусора.
4. Параметры конструктора — это имена значений аргументов, передаваемых конструктору. Для каждого параметра в декларации конструктора создается новая переменная каждый раз, когда вызывается данный конструктор (явно или неявно). Этой переменной присваивается фактическое значение аргумента, переданное конструктору при вызове. Переменная уничтожается после завершения выполнения тела конструктора.
5. Параметры метода — это имена значений аргументов, передаваемых методу. Для каждого параметра в декларации метода создается новая переменная каждый раз, когда вызывается данный метод. Этой переменной присваивается фактическое значение аргумента, переданное методу при вызове. Переменная уничтожается после завершения выполнения тела метода.
6. Параметр обработчика исключений создается всякий раз, когда выполняется часть catch оператора try . Его значением становится объект, ассоциированный с возникшим исключением. Переменная уничтожается после завершения выполнения блока catch .
7. Локальные переменные . Каждый раз, когда в ходе выполнения программы управление передается новому блоку или оператору for , для каждой декларации переменной внутри этого блока или оператора создается соответствующая локальная переменная. Если декларация содержит начальное значение переменной, то ей присваивается это значение. Локальная переменная уничтожается после завершения выполнения блока или оператора, в котором она объявлена.

Следующий пример содержит декларации нескольких переменных перечисленных разновидностей:

Class Point { static int numPoints; // numPoints - переменная класса int x, y; // x и y - переменные реализации int w = new int; // w - массив целых чисел, w - элемент массива int setX(int x) { // x - параметр метода int oldx = this.x; // oldx - локальная переменная this.x = x; return oldx; } }

5.3.4.2. Начальные значения переменных

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

• Каждой переменной класса, переменной реализации и каждому элементу массива при создании присваивается значение по умолчанию следующим образом:
• переменные типов byte , short , int , long получают значение 0 соответствующего типа;
• переменные типов float и double получают значение +0 соответствующего типа;
• переменные типа char получают значение "\u0000";
• переменные типа boolean получают значение false ;
• переменные ссылочных типов получают значение null ;
• Каждому параметру метода и конструктора присваивается фактическое значение соответствующего аргумента, определенное в момент вызова данного метода или конструктора.
• Параметр обработчика исключений инициализируется соответствующим объектом.
• Локальной переменной перед ее использованием должно быть присвоено значение либо инициализацией в декларации, либо оператором присваивания.

What is a Variable?

A variable can be thought of as a container which holds value for you, during the life of a Java program. Every variable is assigned a data type which designates the type and quantity of value it can hold.

In order to use a variable in a program you to need to perform 2 steps

1. Variable Declaration
2. Variable Initialization

In this tutorial, you will learn-

Variable Declaration:

To declare a variable, you must specify the data type & give the variable a unique name.

Examples of other Valid Declarations are

Int a,b,c; float pi; double d; char a;

Variable Initialization:

To initialize a variable, you must assign it a valid value.

Example of other Valid Initializations are

Pi =3.14f; do =20.22d; a=’v’;

You can combine variable declaration and initialization.

Int a=2,b=4,c=6; float pi=3.14f; double do=20.22d; char a=’v’;

Types of variables

In Java, there are three types of variables:

1. Local Variables
2. Instance Variables
3. Static Variables

1) Local Variables

Local Variables are a variable that are declared inside the body of a method.

2) Instance Variables

Instance variables are defined without the STATIC keyword .They are defined Outside a method declaration. They are Object specific and are known as instance variables.

3) Static Variables

Static variables are initialized only once, at the start of the program execution. These variables should be initialized first, before the initialization of any instance variables.

Example: Types of Variables in Java

class Guru99 { int data = 99; //instance variable static int a = 1; //static variable void method() { int b = 90; //local variable } }

Data Types in Java

Data types classify the different values to be stored in the variable. In java, there are two types of data types:

1. Primitive Data Types
2. Non-primitive Data Types

Primitive Data Types

Primitive Data Types are predefined and available within the Java language. Primitive values do not share state with other primitive values.

There are 8 primitive types: byte, short, int, long, char, float, double, and boolean Integer data types

Byte (1 byte) short (2 bytes) int (4 bytes) long (8 bytes)

Floating Data Type

Float (4 bytes) double (8 bytes)

Textual Data Type

Char (2 bytes)

Boolean (1 byte) (true/false)

Data Type	Default Value	Default size
byte	0	1 byte
short	0	2 bytes
int	0	4 bytes
long	0L	8 bytes
float	0.0f	4 bytes
double	0.0d	8 bytes
boolean	false	1 bit
char	"\u0000"	2 bytes

Points to Remember:

• All numeric data types are signed(+/-).
• The size of data types remain the same on all platforms (standardized)
• char data type in Java is 2 bytes because it uses UNICODE character set. By virtue of it, Java supports internationalization. UNICODE is a character set which covers all known scripts and language in the world

Java Variable Type Conversion & Type Casting

A variable of one type can receive the value of another type. Here there are 2 cases -

Case 1) Variable of smaller capacity is be assigned to another variable of bigger capacity.

This process is Automatic, and non-explicit is known as Conversion

Case 2) Variable of larger capacity is be assigned to another variable of smaller capacity

In such cases, you have to explicitly specify the type cast operator. This process is known as Type Casting.

In case, you do not specify a type cast operator; the compiler gives an error. Since this rule is enforced by the compiler, it makes the programmer aware that the conversion he is about to do may cause some loss in data and prevents accidental losses.

Example: To Understand Type Casting

Step 1) Copy the following code into an editor.

Class Demo { public static void main(String args) { byte x; int a = 270; double b = 128.128; System.out.println("int converted to byte"); x = (byte) a; System.out.println("a and x " + a + " " + x); System.out.println("double converted to int"); a = (int) b; System.out.println("b and a " + b + " " + a); System.out.println("\ndouble converted to byte"); x = (byte)b; System.out.println("b and x " + b + " " + x); } }

Step 2) Save, Compile & Run the code.

Int converted to byte a and x 270 14 double converted to int b and a 128.128 128 double converted to byte b and x 128.128 -128

Java является объектно-ориентированным языком, которому свойственна абстракция, однако для прикладных задач всегда приходится оперировать известными параметрами. В программировании они называются переменными. Чем java переменная отличается от объекта?

Всё просто – переменная является ячейкой в памяти, где хранится её значение. Любое действие – прямая работа с этим участком памяти. Объект же является более комплексной величиной. Он занимает определённый диапазон памяти, взаимодействие осуществляется через некую передаточную функцию (методы), выраженную в параметрах объекта.
В данной статье мы поговорим именно о переменных, здесь это совсем не тривиальное понятие.

Объявляются переменные java так:

тип_данных имя_переменной;

Здесь же при объявлении можно присвоить значение.

тип_данных имя_переменной = значение_переменной;

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

тип_данных имя_переменной1, имя_переменной2…;

Классификация по принадлежности

Выделяется четыре типа java переменных:

• переменные экземпляра (instance variables);
• переменные класса (class variables);
• локальные переменные (local variables);
• параметры (parameters).

Пусть у нас есть несколько объектов одного класса Automobile(). Помимо общих параметров у них есть уникальные, скажем, максимальная скорость maxSpeed(). Их можно инициировать в теле программы, а можно хранить в нестатических полях класса (объявленных без добавления слова static). Таким образом, каждый экземпляр будет обладать индивидуальным параметром, не зависящим от скоростей других объектов.

public class Automobile { public String name; private double maxSpeed ; public Automobile (String autoName ){ name = autoName; }}

Переменная класса, или статическая переменная java, напротив, объявляется исключительно с применением слова static. В данном случае её значение будет одинаковым для всех экземпляров. В случае того же автомобиля, введём параметр gearsNum – число передач. Для всех экземпляров оно будет равно 6.

Необязательный модификатор final позволяет присвоить значение переменной только один раз. За соблюдением этого следит компилятор.

public class Automobile { public String model ; private double maxSpeed ; public static final int gearsNum = 6 ; }

Локальные переменные и методы в java неизменно связаны. В последних часто фигурируют вспомогательные параметры, которые в дальнейшем коде не нужны. Для объявления локальной переменной нет особой формы инициализации, границы её действия зависят лишь от места объявления. В данном случае - в фигурных скобках внутри метода. При выходе из него переменная будет уничтожена, поэтому обратиться к ней будет уже нельзя.

Крайний случай локальных переменных - это параметры. В частности, классический пример «Hello, World!»:

class HelloWorld { public static void main (String args ) { System . out. println("Hello World!" ); } }

Здесь сразу два параметра. Первая - собственно, «Hello, World!», вторая - аргумент строки args в main.

Классификация по видимости

На основании описанного выше, можно проследить ещё одно деление – по видимости переменных. Существует 4 группы:

• Public. Данный модификатор переменных доступен всем классам и объектам программы. Объявляется при помощи ключевого слова public в начале строки.
• Protected. Области видимости java переменных в этом случае ограничены текущим пакетом и подклассами. Объявляется аналогично - ключевым словом protected.
• Package protected. Модификатор переменных, доступных только внутри пакета. Объявления не требуется, отсутствие ключевых слов указывает на package protected.
• Private. Переменные, доступные исключительно внутри класса. В данном случае, определить тип переменной можно по ключевому слову private.

Несмотря на то, что приватные элементы доступны внутри класса, вопрос: «как обращаться к private java переменным?» всё же имеет ответ. Для того, чтобы иметь возможность извне поменять значение приватного параметра, достаточно внутри того же класса создать публичный метод. Например так:

class Drive { private int gears; public void setGears (int val ) { gears = val; } }

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

Указатели - ещё один вариант глобальных переменных. Вспомните, для создания экземпляра объекта мы используем следующую запись:

класс_объекта имя_указателя = new класс_объекта;

Такие переменные называются ссылочными переменными.

Для написания программ на языке Java необходимо знать его синтаксис. С этого урока мы начинаем знакомство с основами языка. В этом уроке мы рассмотрим:

• что такое переменные в java и как их объявлять,
• как правильно именовать переменные,
• какие существуют типы данных в java:
  • примитивные типы данных,
  • ссылочные типы данных,
  • отдельно рассмотрим тип String.

Java переменные

В предыдущих уроках мы говорили о том, что класс в Java состоит из атрибутов и методов. Переменные могут быть атрибутами класса, параметрами метода или могут использоваться в программе для краткосрочного хранения данных. В языке Java все переменные должны быть объявлены, перед тем, как они будут использоваться.

Объявление переменных в java

Int x = 1; int y = 2;

При объявлении переменной, в следующей последовательности указываются:

• тип данных (в данном примере — int — переменная содержит целое число),
• имя переменной (в данном примере имена — x и y),
• начальное значение переменной или, другими словами, инициализация переменной . В данном примере переменным x и y присвоены значения 1 и 2. Однако, это не является обязательным условием при объявлении переменной.

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

После каждой строки при объявлении переменных необходимо ставить точку с запятой «;».

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

Правила именования переменных в java

1. Имя переменной должно начинаться с буквы (маленькой) и состоять из букв (Unicode) цифр и символа подчеркивания «_» . Технически возможно начать имя переменной также с «$» или «_», однако это запрещено соглашением по оформлению кода в Java (Java Code Conventions). Кроме того, символ доллара «$», по соглашению, никогда не используется вообще. В соответствии с соглашением имя переменной должно начинаться именно с маленькой буквы (с заглавной буквы начинаются имена классов). Пробелы при именовании переменных не допускаются.
2. Имя переменной не должно быть .
3. Имя переменной чувствительно к регистру . newVariable и newvariable — разные имена.
4. При выборе имени переменных, следует использовать полные слова вместо загадочных аббревиатур. Это сделает ваш код более удобным для чтения и понимания. Во многих случаях это также сделает ваш код самодокументируемым.
5. Если выбранное вами имя переменной состоит только из одного слова — запишите его маленькими буквами. Если оно состоит из более чем одного слова, то отделяйте каждое последующее слово в имени переменной заглавной буквой. Например: superCounter, myDomesticAnimal
6. Если переменная сохраняет постоянное значение, то каждое слово следует писать заглавными буквами и отделять при помощи символа подчеркивания. Пример: static final int NUMBER_OF_HOURS_IN_A_DAY = 24

Типы данных в java

Каждая переменная и каждое выражение в Java обладает типом и этот тип строго определен.

Примитивные типы данных

В Java существует 8 примитивных типов данных:

• byte (целые числа, 1 байт)
• short (целые числа, 2 байта)
• int (целые числа, 4 байта)
• long (целые числа, 8 байтов)
• float (вещественные числа, 4 байта)
• double (вещественные числа, 8 байтов)
• char (символ Unicode, 2 байта)
• boolean (значение истина/ложь, 1 байт)

Эти 8 типов служат основой для всех остальных типов данных. Примитивные типы обладают явным диапазоном допустимых значений.

byte — диапазон допустимых значений от -128 до 127

//объявление переменных типа byte. byte getByte, putByte; // инициализация переменных getByte = 0; putByte = 0;

Переменные типа byte полезны при работе с потоком данных, который поступает из сети или файла.

short — диапазон допустимых значений от -32768 до 32767

//объявление и инициализация переменной типа short . short employeeID = 0;

int — диапазон допустимых значений от -2147483648 до 2147483647

//объявление и инициализация переменной типа int . int max = 2147483647;

Тип int используется чаще при работе с целочисленными данными, нежели byte и short, даже если их диапазона хватает. Это происходит потому, что при указании значений типа byte и short в выражениях, их тип все равно автоматически повышается до int при вычислении.

long — диапазон допустимых значений от -9223372036854775808 до 9223372036854775807

// Использование переменных типа long . long days = getDays(); long seconds; seconds = days * 24 * 60 * 60;

Тип удобен для работы с большими целыми числами.

float — диапазон допустимых значений от ~1,4*10 -45 до ~3,4*10 38

//Объявление и инициализация переменных типа float. float usd = 31.24f; float eur = 44.03f ;

Удобен для использования, когда не требуется особой точности в дробной части числа.

double — диапазон допустимых значений от ~4,9*10 -324 до ~1,8*10 308

//Объявление и инициализация переменных типа double. double pi = 3.14159;

Математические функции такие как sin(), cos(), sqrt() возвращают значение double

char — символьный тип данных представляет собой один 16-битный Unicode символ. Он имеет минимальное значение ‘\ u0000’ (или 0), и максимальное значение ‘\ uffff’ (или 65535 включительно). Символы char можно задавать также при помощи соответствующих чисел. Например символ ‘Ы’ соответствует числу 1067. Рассмотрим на примере:

Public static void main(String args) { char symb1=1067; char symb2 ="Ы"; System.out.println("symb1 contains "+ symb1); System.out.println("symb2 contains "+ symb2); }

Вывод этой программы будет:

Symb1 contains Ы symb2 contains Ы

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

Public static void main(String args) { char ch = "J"; int intCh = (int) ch; System.out.println("J corresponds with "+ intCh); }

На выводе программа показывает, что символу "J" соответствует число 74.

J corresponds with 74

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

//Объявление и инициализация переменной типа boolean. boolean b = true;

Тип String

Тип String не является примитивным типом данных, однако это один из наиболее используемых типов в Java. String предназначен для хранения строк текста. Несколько примеров использования String

//Создание строки с помощью конструктора String myString = new String("The weather was fine"); //Можно также создать строку используя кавычки "" String myString = "The weather was fine";

Для строк определен оператор «+»

Public static void main(String args) { String s1 = "I have "; String s2 = " apples "; int num = 3; String s = s1 + num + s2; System.out.println(s); }

Вывод программы.

I have 3 apples

Ссылочные типы данных

В ссылочные типы входят все классы, интерфейсы, массивы. Описанный выше тип String также относится к ссылочным типам. Этот класс из стандартной библиотеки Java.

Также существуют классы-оболочки:

• Short
• Integer
• Float
• Double
• Character
• Boolean

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

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

Cat ourcat = new Cat();

На этом закончим наше знакомство с переменными и типами в Java.

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