Как объявить переменную в 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 целочисленные переменные и выведите их сумму на экран:

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

 public class Main < public static void main(String[] args) < int x = 100; int y = 1; int z = x + y; System.out.println(z); >> 

Другой вариант решения

 public class Main < public static void main(String[] args) < int x = 100; int y = 1; System.out.println(x + y); //как видим, мы можем в команду вывода в консоль писать сразу выражение >> 

Задача 2

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

99.0 + 0.9 = 100 - это false 

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

 public class Main < public static void main(String[] args) < double x = 99.0; double y = 0.9; boolean isTrue = false; String plus = " + "; System.out.print(x); System.out.print(plus); System.out.print(y); System.out.print(" = 100 - это "); System.out.print(isTrue); >> 

results matching » «

No results matching » «

Переменные в Java

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

18 октября 2017 2 минуты 19307

Автор статьи
Илья Бубнов

Автор статьи
Илья Бубнов
https://gbcdn.mrgcdn.ru/uploads/post/1253/og_cover_image/b2aa61ba3c6c8d4572b0a0f99d7b1547

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

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

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

Виды переменных в Java

Существуют следующие типы переменных в Java: 1) примитивные (целые — byte, short, char, int, long; дробные или с плавающей точкой — float, double, логические — boolean); 2) ссылочные (создаются с применением конструкторов классов и нужны для доступа к объектам).

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

Как объявлять переменные в Java?

Перед использованием переменной нужно её объявить. Для объявления переменной в Java используют следующий синтаксис:

 
тип данных переменная [ = значение], [переменная [= значение], . ] ;
Идём дальше: если нужно объявить больше чем одну переменную указанного типа, допускается применение списка с запятыми:
 
int a, b, c; // объявление трёх целых переменных a, b и c
Инициализация переменной
Перед использованием переменной, нужно задать ей начальное значение. Этот процесс называется инициализация. Без инициализации мы можем получить ошибку во время выполнения программы, поэтому инициализация очень важна. Для инициализации переменной используют оператор присваивания. Слева указывается имя переменной, справа её значение.
Вот пример инициализации:
 
int x = 10; // объявление и инициализация переменной System.out.println(x); // 10
Ниже посмотрим другие примеры инициализации и объявления переменных в Java:
 
int a = 10, b = 10; // Пример инициализации переменных double pi = 3.14159; // Объявление переменной pi и присвоение ей величины «пи» byte b = 22; // Инициализация переменной b типа byte char a = 'a'; // Переменной a типа char присваиваем значение 'a'
Типы переменных в Java
Продолжаем наш небольшой урок для начинающих, посвящённый инициализации переменных в Java. Итак, можно выделить 3 типа переменных: - локальные; - статические (переменные класса); - переменные экземпляра.
Теперь давайте рассмотрим их подробнее.
Локальные переменные в Java
Свойства локальных переменных: - объявляются в методах, блоках или конструкторах; - создаются, когда метод, блок или конструктор запускаются; - уничтожаются после завершения метода, конструктора либо блока; - видимы лишь в пределах объявленного метода, блока либо конструктора; - реализуются на уровне стека внутри; - в Java не существует значений по умолчанию для локальных переменных, поэтому они должны объявляться и проходить этап инициализации непосредственно перед первым использованием; - для переменной нельзя использовать модификаторы доступа.
Пример локальных переменных
Итак, «age» — это наша переменная, определяемая внутри метода pupAge() , причём область её действия ограничивается лишь этим методом:






 
public class Test < public void pupAge()< int age = 0; age = age + 7; System.out.println("Возраст собаки: " + age); >public static void main(String args[]) < Test test = new Test(); test.pupAge(); >>
В итоге мы получим следующий результат:
 
Возраст собаки: 7
Пример локальных переменных без инициализации
Мы уже говорили о том, что переменная без инициализации приведёт к ошибке компиляции и упоминали о важности такой процедуры, как инициализация. Давайте чуть-чуть изменим код и попробуем выполнить нашу программу без инициализации переменной «age»:
 
public class Test < public void pupAge()< int age; //начальное значение не задано, значит, инициализация отсутствует age = age + 7; System.out.println("Возраст собаки: " + age); >public static void main(String args[]) < Test test = new Test(); test.pupAge(); >>
Запустив компиляцию без инициализации, мы увидим следующую ошибку:
 
Test.java:4:variable number might not have been initialized age = age + 7; ^ 1 error //так как инициализация отсутствует, программа не «может понять», к чему прибавлять цифру 7
Пожалуй, об инициализации уже поговорили достаточно. Идём дальше.
Переменные экземпляра
Для начала рассмотрим основные свойства переменных экземпляра: - объявляются в классе, однако за пределами метода, блока, конструктора; - когда в стеке выделяется пространство для объекта, создаётся слот для всех значений переменных экземпляра; - в Java эти переменные создаются тогда, когда объект создаётся посредством ключевого слова «new», а удаляются, когда объект уничтожается; - переменные включают значения, ссылающиеся более чем на один метод, блок или конструктор; - переменные экземпляра можно объявить на уровне класса, а также до и после использования; - для переменных экземпляра могут быть предоставлены модификаторы доступа; - эти переменные в Java видимы для всех методов, блоков и конструкторов в классе. Рекомендуется делать их private. Также можно делать их видимыми для подклассов данных переменных посредством модификаторов доступа; - переменные имеют значения по умолчанию: 0 — для чисел, false — для логических значений, null — для ссылок на объект. Значения можно присвоить в конструкторе либо при объявлении; - переменные могут быть доступны при вызове имени переменной внутри класса. При этом в статических методах и разных классах они вызываются посредством полного имени — ObjectReference.VariableName .
 
import java.io.*; public class Employee < // Переменная экземпляра открыта для дочернего класса (любого) public String name; // Переменная salary видна лишь в Employee private double salary; // Имя переменной присваивается в конструкторе public Employee (String empName)< name = empName; >// Переменной salary присваивается значение public void setSalary(double empSal) < salary = empSal; >// Метод выводит на экран данные сотрудников public void printEmp() < System.out.println("имя: " + name ); System.out.println("зарплата:" + salary); >public static void main(String args[]) < Employee empOne = new Employee("Сергей"); empOne.setSalary(2000); empOne.printEmp(); >>
Результат работы нашей программы следующий:
 
имя: Сергей зарплата: 2000.0
Рассмотрение переменных класса (статических переменных в Java) выходит за рамки нашей статьи. Давайте лучше поговорим о том, что такое константа и зачем нужны константы в Java.
Для чего используются константы?
Константы применяются в Java для хранения данных. Константа отличается от переменной. Главное отличие в том, что при использовании константы мы можем присвоить значение лишь один раз.
В остальном константа объявляется так же, как и переменная. Правда, в случае использования константы сначала идёт ключевое слово final:






 
final int LIMIT = 5; System.out.println(LIMIT); // 5 // LIMIT=57; // данный синтаксис возможен потому, что LIMIT — это константа
Как правило, при записи имени константы применяют верхний регистр.
Константы позволяют задать переменные, которые больше не должны меняться. Допустим, у нас существует переменная для хранения числа «пи». При инициализации мы можем сразу же объявить, что она константа, ведь её значение постоянно.
На этом пока всё. Если хотите знать больше, чем объявление, инициализация и использование переменной, записывайтесь на курс «Разработчик 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 группы:

Целочисленные (к ним относятся byte, short, int, long)
С плавающей точкой (к ним относятся float, double)
Символы (char)
Логические (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 и т.д.

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

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






 Задача 1: 
У Димы 3 яблока, у Ани 2 яблока. Сколько яблок у Димы и Ани вместе?
Как видите, в задаче речь идет о целых яблоках. Не предполагается, что яблоки будут делить на части.
Значит, если бы мы писали код в Java, который бы предполагал решение данной задачи, мы бы использовали для переменных целочисленный тип. Остается понять только какой именно мы бы использовали: byte, short, int или long?
Всегда необходимо отталкиваться от контекста.

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


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

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

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







Видите, названия примеров переменных состоят из 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 и т.д.

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

float может принимать значения от -3.4Е +38 до 3.4Е +38 и при этом занимает 4 байта памяти
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 - с чего может/не может начинаться имя переменной 
 Может начинаться с :

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

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

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 группы переменных: 

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


Эти 8 типов переменных (byte, short, int, long, float, double, char, boolean) относятся к там называемым примитивным типам переменных. 
 
Прежде чем использовать переменную, её необходимо объявить: 

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

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


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

Также есть еще один тип переменных - тип String, о котором мы поговорим в статье "Как присвоить значение переменной в Java"
Надеемся, что наша статья была Вам полезна. Также есть возможность записаться на наши курсы по Java в Киеве. Обучаем с нуля. 
По всем вопросам звоните:
+38 050 205 77 99
+38 098 205 77 99
Или читайте информацию по нашим курсам Java c нуля у нас на сайте.

← Что такое CamelCase или CamelStyle?
Как создать первую веб-страницу →



Похожие публикации:

Как обновить apple pay
Как удалить эпл стор
Почему instagram работает через wifi
Софт тач пластик стал липким что делать