Что хранится в переменной не примитивного типа
Перейти к содержимому

Что хранится в переменной не примитивного типа

  • автор:

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

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

Что же такое переменная

Для того, чтобы тебе было проще понять, что такое переменная, вернемся к школьному курсу и вспомним простую формулу:

Если мы подставим значение к «х», например, х = 1, то значение выражения будет равно «2». Соответственно, если х = 2, значение выражения будет «3» и так далее. Как видишь, все достаточно просто. «Х» в нашем случае переменная, куда мы помещаем любое значение. Подставляя его в формулу, мы получаем определенный результат.

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

Какие типы переменных бывают в Java

В этом языке программирования выделяют четыре типа переменных:

  1. Целочисленные. К этому типу относятся такие переменные, как byte, short, int, long.
  2. С плавающей точкой. Сюда относятся float и double.
  3. Символы.
  4. Логические.

Как видно, всего переменных 8, однако есть еще и девятый тип переменных – void. Но этот тип мы не будем рассматривать в данной статье. Познакомимся поближе с каждым из типов переменных.

Целочисленные

Уже из названия понятно, что в качестве значения таким переменным присваиваются целые числа. Например, это может быть 5, 10, 25, 100 и так далее. Причем они могут быть как положительными, так и отрицательными, в зависимости от потребности разработчика. А теперь рассмотрим подробнее каждый из видов переменных:

  1. Byte – принимает значение от -128 до 127. Размер этой переменной – 1 байт памяти, что вполне логично исходя из названия.
  2. Short – может принимать значения от -32768 до 32767. Размер такой переменной 2 байта.
  3. Int – эта целочисленная переменная может принимать значения от -2147483648 до 2147483647. Ее размер составляет 4 байта.
  4. Long – это самая большая с точки зрения размера переменная (8 байтов памяти). Она может принимать значения от -9223372036854775808 до 9223372036854775807.

В принципе, несложно понять, когда и в какой ситуации использовать каждую из этих переменных. Но для закрепления приведем маленький пример. Предположим, у Васи 5 апельсинов, а у Кати и Ани по 3. Нужно определить сколько всего апельсинов у ребят. Нетрудно догадаться, что здесь требуется использование целочисленных переменных, так как апельсины целые и не предполагается, что их будут делить на дольки.

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

Дальше, представим, что Вася, Катя и Аня выросли и стали заниматься поставками апельсинов. Теперь у каждого больше 1000 единиц этого вкусного фрукта. Объявлять byte мы больше не сможем. Если количество апельсинов не превышает 32767, мы можем работать с short, если больше с int и так далее.

Несмотря на то, что в Java представлено 4 целочисленных переменных, чаще всего будет использоваться только int. Более того этот тип в языке считается по умолчанию. А теперь посмотрим, как в Java объявляются переменные.

Приведем несколько примеров:

Типы данных в Java: какие бывают, чем различаются и что такое ссылки и примитивы

Рассказываем, как джависту не запутаться во всех этих byte, short, boolean, char и String.

Василий Порядин

Василий Порядин
Программист, преподаватель Skillbox. Пишет про Java.

Основа любого языка программирования — данные и опе­рации с ними. Java не исключение. Это строго типизированный язык, поэтому типы данных значат в нём очень многое.

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

Когда код на Java компилируется, машина проверяет соответствие типов операндов во всех методах, конструкторах и других операторах. Если в программе есть хотя бы одна недопустимая операция, компилятор не превратит её в байт-код. Поэтому контроль типов данных помогает уменьшить количество ошибок при написании программы.

В этой статье мы рассмотрим:

  • какие типы данных есть в Java;
  • чем различаются примитивные и ссылочные переменные;
  • какие у переменных бывают значения по умолчанию;
  • как упаковка и распаковка помогают превратить примитивные переменные в объект.

Какие типы данных есть в Java

В Java типы данных делят на две большие группы: примитивные и ссылочные. В состав примитивных типов (или просто примитивов) входят четыре подвида и восемь типов данных:

2) числа с плавающей точкой (float, double);

3) логический (boolean);

4) символьный (char).

Ссылочные типы данных ещё называют ссылками. К ним относятся все классы, интерфейсы, массивы, а также тип данных String.

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

Примитивные переменные Ссылочные переменные
Хранят значение Хранят адрес объекта в памяти, на который ссылаются (отсюда и название).

Вот пример использования примитивных и ссылочных типов данных:

Как используют целочисленные переменные

Целочисленные типы данных различаются только диапазонами значений. Их основная задача — хранить информацию для вычислений.

Тип byte. Эти переменные используют, чтобы работать с потоком данных, который получили из файла или по сети.

//объявляем переменные с типом данных byte byte a; byte b; byte c; //инициализируем переменные значениями a = 0; b = 0; c = -129; //это пример ошибки во вводе данных. Такое значение не входит в диапазон значений byte //выводим данные из переменных System.out.println(a); System.out.println(b);

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

//инициализируем переменную типа short short primerShort = 255;

Тип int. В языке Java int — самый популярный тип целочисленных данных. При вычислениях в виртуальной машине остальные целочисленные типы (byte, short) занимают столько же памяти, сколько int.

//инициализируем переменную типа int int closeToMiddle = 0;

Множество классов в Java обладают значениями типа int — например, длина массива внутри класса String выражается целочисленным значением int:

String[] strings = new String[50]; int arrayLength = strings.length;

Если переменная хранит количество элементов в коллекциях List, Set и Map, она тоже относится к типу int:

ListString> strings = new ArrayList<>(); int listSize = strings.size();

Тип возвращаемого значения подсказывает, сколько элементов можно хранить в списке или множестве. Максимум для int — 2 147 483 647.

Тип long применяют, когда нужно работать с большими целочисленными значениями.

//инициализируем переменные типа long long c = -9223372036854; //при компиляции появится ошибка long right = -9223372036854L;

По умолчанию компилятор воспринимает целое число как int, а 9 223 372 036 854 намного больше его максимального значения, поэтому в коде программы нужно явно указать тип long.

Зачем нужны числа с плавающей точкой

Тип данных double используют для работы с десятичными числами.

//инициализируем переменную типа double double sample = 59.36;

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

Когда переменной присваивают тип float, язык Java воспринимает её как тип данных double. Чтобы этого не происходило, нужно добавлять в конце переменной символ f или F.

Даже если у переменных float и double будут одинаковые значения, язык Java обработает их по-разному, поэтому они будут занимать разный объём памяти.

//инициализация переменных типа float float f = 1.457; //Java воспримет эту переменную как тип данных double и выдаст ошибку компиляции float floatNumber = 27.5f; //правильный способ float otherFloat = (float) 78.64; //другой вариант инициализации переменной типа float во избежание путаницы с double 

Не стоит использовать float, когда в вычислениях нужна точность больше пяти знаков после запятой. Oracle пишет об этом в статье «Primitive Data Types».

Логический и символьный типы данных

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

//инициализируем переменные типа boolean boolean isWorking = true; boolean isAlive = false;

В Java boolean — отдельная переменная. Это не аналог 1 или 0, как, например, в JavaScript и PHP.

Тип данных char используют, чтобы хранить в переменных любые 16-разрядные символы Unicode. Но их нужно записывать строго в одинарные кавычки ‘ ‘, и только по одному.

Не стоит путать символьные и строковые переменные — ‘ж’ не равно «ж», потому что в двойных кавычках хранится тип данных String. А это уже не примитив.

Пример кода

//инициализируем переменные типа char char symbol1 = 1078; //по индексу символа в таблице UTF-8 char symbol2 = 'ж'; //по значению символа char symbol3 = '\u0436'; //через шестнадцатеричную форму Unicode (это всё ещё «ж») //вызываем вывод информации System.out.println("symbol1 contains " + symbol1); System.out.println("symbol2 contains " + symbol2); System.out.println("symbol3 contains " + symbol3); //во всех случаях будет выдан один и тот же символ — «ж»

Вывод в консоли

symbol1 contains ж symbol2 contains ж symbol3 contains ж

Значения по умолчанию для ссылочных типов данных

В плане дефолтных значений ссылочные переменные проще примитивов. По умолчанию их значение — null: это означает отсутствие ссылки или то, что ссылка ни на что не указывает.

Но если вызвать метод объекта от переменной со значением null, это приведёт к ошибке NullPointerException:

Cat barsik = null; barsik.meow(); //здесь появится ошибка NullPointerException, потому что у переменной barsik значение null

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

Пример использования String:

//создаём строку двойными кавычками "" String string = "This day was awesome"; //альтернативный способ создания строки — через конструктор String string = new String ("This day was awesome");

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

Пример кода

String stringFirst = "New adventures "; String stringSecond= "are waiting "; String stringThird = "for you"; String string = stringFirst + stringSecond + stringThird; System.out.println(string);

Вывод в консоли

New adventures are waiting for you

Boxing и unboxing — как превратить примитив в объект

Иногда с примитивами приходится работать как с объектами — например, передавать им значение по ссылке или создавать список из чисел (а списки работают только с объектами).

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

Тип данных Класс-обёртка
byte Byte
short Short
int Integer
long Long
char Character
float Float
double Double
boolean Boolean

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

Чтобы создать ссылку на примитивный тип данных, нужно использовать соответствующую обёртку:

//пример использования классов-оболочек (упаковка) long g = 5509768L; Long boxed; boxed = new Long(g); //обычное создание через конструктор boxed = Long.valueOf (g); //фабричный метод boxed = g; //автоматическая упаковка. Компилятор заменит её на вызов Long.valueOf(g)

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

//пример использования классов-оболочек (распаковка) Long boxed = 200L; long g; g = boxed.longValue(); //явная распаковка g = boxed; //автоматическая распаковка

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

В этой статье мы рассмотрели примитивные типы данных (byte, short, int, long, float, double, char и boolean), ссылочные типы данных (String и остальные). Вы узнали, чем они отличаются друг от друга и какие значения принимают по умолчанию.

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

Читайте также:

  • Ключевое слово var в Java: что, зачем и почему
  • 7 этапов взросления программиста: Михаил Флёнов о пути в профессию
  • Ползай, как муравей, летай, как пчела: алгоритмы, которые придумала сама природа ����

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

В JavaScript определены семь встроенных типов данных. Шесть примитивных типов и один тип, который представляет из себя структуру данных:

    boolean — логический тип данных, который принимает значения true иди false

let val = false; val = true; 
let val = 50; val = 3.14159; val = -200; 

Этот тип представляет из себя число двойной точности, подробнее о нём можно прочитать здесь. Ноль в JavaScript имеет два представления: -0 и +0 . («0» это синоним +0). На практике это имеет малозаметный эффект. Например, выражение +0 === -0 является истинным. А также есть специальные значения, которые по сути не являются числами, но принадлежат к числовому типу данных: Infinity (бесконечность) и NaN (Not a Number — “Не Число”)

let inf = Infinity; // прямое присвоение бесконечности inf = 57 / 0; // Infinity получится при делении на ноль inf = -Infinity; // есть отрицательная бесконечность inf = 57 / -0; // -Infinity let notNumber = NaN; notNumber = "строка" * 5; // При ошибке вычисления вернёт NaN 

Для получения самого большого или самого меньшего доступного значения в пределах +/-Infinity , можно использовать константы Number.MAX_VALUE или Number.MIN_VALUE . А начиная с ECMAScript 2015, вы также можете проверить, находится ли число в безопасном для целых чисел диапазоне, используя метод Number.isSafeInteger() , либо константы Number.MAX_SAFE_INTEGER и Number.MIN_SAFE_INTEGER . За пределами этого диапазона операции с целыми числами будут небезопасными, и возвращать приближённые значения. Например, подумайте над следующей задачей. Какое значение должно быть у переменной value , чтобы после выполнению кода ниже, в консоли отобразились значения, указанные в комментариях?

let value = ? console.log(i * i) // 0 console.log(i + 1) // 1 console.log(i - 1) // -1 console.log(i / i) // 1 
let str = "Это строка"; console.log(str[0]); // Э - первый символ строки console.log(str.length); // 10 console.log(str[str.length - 1]); // а - последний символ строки str = 'А это "строка в двойных кавычках" внутри строки'; 

Также соединения строк (конкатенации) можно использовать оператор + или метод String.concat() . Также для составления строк с использованием значений переменных удобно применять шаблонизацию через обратные кавычки — `строка с переменной $`

let name = "Василий"; let helloMsg = "Привет, " + name + "!"; // Привет, Василий! let newHelloMsg = name.concat(", здравствуйте. ", "Удачного дня!"); // Василий, здравствуйте. Удачного дня! //Для помещения значений переменных в шаблон используется конструкция $ helloMsg = `Привет, $name>`; // Привет, Василий! 
let sym1 = Symbol(); let sym2 = Symbol("foo"); 
let data = null; 
let data; console.log(data); // undefined 

Определение типов оператором typeof

Оператор typeof возвращает строку, указывающую тип операнда. Синтаксис вызова этого оператора: typeof operand . Например:

// Числа console.log(typeof 42); // "number" console.log(typeof Infinity); // "number" console.log(typeof NaN); // "number", несмотря на то, что смысл этого значения "Not-A-Number" (не число) // Строки console.log(typeof "строка"); // "string" let name = "Василий"; console.log(typeof `Привет, $name>`); // "string" // Булевы значения console.log(typeof true); // "boolean" console.log(typeof false); // "boolean" // Символы console.log(typeof Symbol()); // "symbol" // undefined let declaredButUndefinedVariable; console.log(typeof declaredButUndefinedVariable); // "undefined"; // Объекты console.log(typeof  a: 1 >); // "object" console.log(typeof [1, 2, 3]); // такая структура данных, как массив, тоже "object" 

Но есть два значения, для которых оператор typeof не совсем корректно отражает их тип:

    Значение null , для него typeof возвращает тип “object”, что является официально признанной ошибкой в языке, которая сохраняется для совместимости. На самом деле это не объект, а отдельный тип данных null .

// null console.log(typeof null); // "object" 
// function console.log(typeof function() <>); // "function" 

Примитивные и ссылочные типы данных

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

Например рассмотрим следующий код:

// Примитивный тип number let num = 5; // Функция для прибавления двойки к примитиву function addTwo(num)  num = num + 2; > // Вызов функции addTwo(num); console.log(num); // 5 

Что происходит после вызова этой функций?

В первую функцию addTwo в качестве параметра передаётся значение переменной num из глобальной области видимости, то есть 5 . Таким образом Запись Окружения этой функции после вызова будет выглядеть так:

let num = 5; function addTwo(num)  // на этапе создания контекста - , где num, это локальная переменная функции addTwo num = num + 2; // на этапе выполнения контекста, эта строка изменит запись на > addTwo(num); console.log(num); // 5 

Но что же и этом произойдет со значением переменной num из глобальной области видимости? В действительности её значение останется таким же, как и было до вызова функции addTwo , так как в неё просто было скопировано значение этой переменной. И все манипуляции уже производились над другой переменной из области видимости функции addTwo . В текущей ей реализации она просто производит операцию над локальной переменной и не возвращает никакого определенного значения (а точнее она вернёт undefined ).

Если переписать эту функцию, чтобы она возвращала новое значение локальной переменной num и потом присвоить это значение обратно уже в глобальную переменную num , то только в таком случае её значение поменяется:

let num = 5; function addTwo(num)  // на этапе создания контекста - num = num + 2; // на этапе выполнения контекста, эта строка изменит запись на return num; // вернуть результатом функции новое значение > num = addTwo(num); // присвоить результат функции как новое значение переменной console.log(num); // 7 

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

Теперь рассмотрим как передаются значения объектов:

// Ссылочный тип object let obj =  key: 5 >; // Функция для прибавления двойки к свойству объекта function addTwoObj(obj)  obj.key = obj.key + 2; > // Вызов функции addTwoObj(obj); console.log(obj.key); // 7 

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

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

let obj =  key: 5 >; function addTwoObj(obj)  // на этапе создания контекста - >, здесь переменная obj опять же является уже локальной переменной функции addTwoObj obj.key = obj.key + 2; // на этапе выполнения контекста, эта строка сначала по переданной ссылке в obj найдет сам объект < key: 5 >изменит свойство key самого объекта, а не его копии. Запись Окружения станет > > addTwoObj(obj); // переменная obj хранит в себе ссылку а объект < key: 5 >, поэтому параметром передаётся именно эта ссылка console.log(obj.key); // Был изменен сам объект, который был передан по ссылке, поэтому значение его свойства будет 7 

А что выведется в консоль, если изменить локальную переменную obj ?

let obj =  key: 5 >; function addTwoObj(obj)  obj.key = obj.key + 2; obj =  num: 6 >; // присвоить другой объект obj = null; // или же вообще присвоить нулевое значение > addTwoObj(obj); console.log(obj.key); 

Здесь в консоли снова выведется 7 . Так как в функции addTwoObj переменная obj является локальной и затеняет одноименную глобальную переменную, то присваивания ей в функции новых значений никак не отразится на глобальной переменной obj . Это лишь приведет к перезаписи переданной ссылки на объект < key: 5 >новыми значениями.

let obj =  key: 5 >; function addTwoObj(obj)  // на этапе создания контекста - >, здесь переменная obj опять же является уже локальной переменной функции addTwoObj obj.key = obj.key + 2; // на этапе выполнения контекста, эта строка сначала по переданной ссылке в obj найдет сам объект < key: 5 >изменит свойство key самого объекта, а не его копии. Запись Окружения станет > obj =  num: 6 >; // после выполнения этой строки измениться лишь значение локальной переменной в Записи Окружения: > obj = null; // а здесь вообще в локальную переменную запишется значение null примитивного типа > addTwoObj(obj); // переменная obj хранит в себе ссылку а объект < key: 5 >, поэтому параметром передаётся именно эта ссылка console.log(obj.key); // Был изменен сам объект, который был передан по ссылке, поэтому значение его свойства будет 7 

Обертки примитивных типов в JavaScript

В отличие от объектов, у примитивов нет своих методов, но у всех них, за исключением null и undefined , есть объектные аналоги, который оборачивает значение примитивного типа и позволяют производить над ними различные преобразования:

  • String для string примитива.
  • Number для number примитива.
  • Boolean для boolean примитива.
  • Symbol для symbol примитива.

Что происходит когда вызывается какой-либо метод у примитивного типа данных, например:

let char = "текст".charAt(1); // е 

Так как у примитивного типа строки нет своих методов, то сначала создаётся его копия и неявно оборачивается в его объектный аналог с помощью конструктора new String(something) . И уже в рамках этого объекта существует набор различных встроенных методов, дин из них — charAt() , который возвращает символ строки по указанной позиции. После вызова метода возвращается его результат и эта объектная обёртка уничтожается. Поэтому сам вызов метода никак не влияет на изначальное значение примитива, а только возвращает вычисленное значение.

Явно этот код можно записать так:

let char = new String("текст").charAt(1); // "е" 

И именно поэтому вызов следующих методов будет лишь возвращать новые значения и никак не повлияет на исходную переменную str :

let str = "текст"; let upper = str.toUpperCase(); let substr = str.substring(0, 3); console.log(upper); // "ТЕКСТ" console.log(substr); // "тек" console.log(str); // "текст" 

У каждой такой объектной обертки есть метод valueOf() , который возвращает соответствующее значение примитивного типа. Например:

var numObj = new Number(10); console.log(typeof numObj); // object var num = numObj.valueOf(); console.log(num); // 10 console.log(typeof num); // number 

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

Дата изменения: February 26, 2023

Поделиться

Обнаружили ошибку или хотите добавить что-то своё в документацию? Отредактируйте эту страницу на GitHub!

Что хранится в переменной не примитивного типа

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

Что же такое переменная

Для того, чтобы тебе было проще понять, что такое переменная, вернемся к школьному курсу и вспомним простую формулу:

х+1 = y

Если мы подставим значение к «х», например, х = 1, то значение выражения будет равно «2». Соответственно, если х = 2, значение выражения будет «3» и так далее. Как видишь, все достаточно просто. «Х» в нашем случае переменная, куда мы помещаем любое значение. Подставляя его в формулу, мы получаем определенный результат.

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

Какие типы переменных бывают в Java

В этом языке программирования выделяют четыре типа переменных:

    Целочисленные. К этому типу относятся такие переменные, как byte, short, int, long.

Целочисленные

Уже из названия понятно, что в качестве значения таким переменным присваиваются целые числа. Например, это может быть 5, 10, 25, 100 и так далее. Причем они могут быть как положительными, так и отрицательными, в зависимости от потребности разработчика. А теперь рассмотрим подробнее каждый из видов переменных:

    Byte – принимает значение от -128 до 127. Размер этой переменной – 1 байт памяти, что вполне логично исходя из названия.

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

Дальше, представим, что Вася, Катя и Аня выросли и стали заниматься поставками апельсинов. Теперь у каждого больше 1000 единиц этого вкусного фрукта. Объявлять byte мы больше не сможем. Если количество апельсинов не превышает 32767, мы можем работать с short, если больше с int и так далее.

Несмотря на то, что в Java представлено 4 целочисленных переменных, чаще всего будет использоваться только int. Более того этот тип в языке считается по умолчанию. А теперь посмотрим, как в Java объявляются переменные.

Приведем несколько примеров:

int oranges;

В языке Java, как и в любом другом переменные лучше называть выразительно. То есть так, чтобы можно было понять, что именно в ней лежит. Например, если мы просто назовем три переменные byte oranges, не будет понятно, что это за апельсины.

Если речь идет об апельсинах Васи, такую переменную можно было бы назвать int vasyaOranges (или orangesVasya). Заметили одну интересную особенность? Слово vasya мы почему-то написали с маленькой, а Oranges с большой. Такой прием называется CamelCase. Он применяется тогда, когда название переменной или функции состоит из двух и более слов. Применяется исключительно для удобства. Читать переменную vasyaOranges куда удобнее, чем vasyaoranges. А если в названии переменной еще больше слов, то без CamelCase придется туго.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *