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

Переменные

Java переменные — это основной элемент хранения информации в Java-программе.

Простая форма объявления Java переменных:

тип идентификатор;

Общая форма объявления Java переменных и их инициализации:

тип идентификатор [=значение] [, идентификатор [=значение] . ] ;

Где параметр тип обозначает один из примитивных типов данных в Java, имя класса или интерфейса. А идентификатор — это имя переменной.

• Java — строго типизированный язык. Каждая переменная в Java имеет конкретный тип. Тип определяет размер и размещение переменной в памяти, диапазон значений, которые могут храниться в памяти, а также набор операций, применимых к переменной.
• Необходимо объявить все переменные, прежде чем их использовать.
• Если требуется объявить несколько переменных заданного типа, это можно сделать в виде разделенного запятыми списка имен переменных.
• Переменная может быть инициализирована при объявлении или позже.
• Во время выполнения программы значение переменной может изменяться.
• Инициализирующее выражение должно возвращать значение того же самого (или совместимого) типа, что и у переменной.

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

double d = 2.3;// Объявляет число d и инициализирует его int count = 0, min = 6;// Объявляет два целых числа count и min int max;// Объявляет число max max = 89;// Инициализирует число max

2. Область видимости переменной в Java

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

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

Рассмотрим области действия переменных на следующем примере:

public class VarDemo < String str1 = "Hello!"; String str2 = "Hi!"; public static void main(String[] args) < int x; // переменная x доступна всему коду из метода main ( ) x = 10; if (x == 10) < // начало новой области действия, int у = 20; //int x = 45; // ОШИБКА! Во внутреннем блоке кода нельзя // объявлять переменные с тем же именем, что и во внешней области действия. //обе переменные х и у доступны в этой области действия System.out.println(" x и у : " + x + " " + у); x = у * 2; >// y = 100; // ОШИБКА! переменная у недоступна // в этой области действия // переменная х доступна и эдесь System.out.println(" x равно " + x); > > 

3. Объявление локальных переменных с помощью var

В Java 10 появилась возможность объявлять локальные переменные с помощью ключевого слова Java var без указания типа. Тип выводится компилятором из присваиваемого значения:

public class VarDemo2 < public static void main(String[] args) < var i = 6; var d = 7.8; var s = "some String"; System.out.println(i); System.out.println(d); System.out.println(s); >>

Презентацию с видео можно скачать на Patreon .

Как объявить переменную в java

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

Например, чтобы создать переменную целочисленного типа, назовем ее myNumber и присвоить ей значение 10, можно написать следующий код:

int myNumber = 10; 

• int — это тип переменной,
• myNumber — ее имя,
• 10 — начальное значение.

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

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

В этой статье мы с вами разберемся что такое переменные в 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 » «

8. Java – Типы переменных, объявление и инициализация

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

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

тип данных переменная [ = значение], [переменная [= значение], . ] ;

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

Ниже приведены примеры объявления переменной и инициализации в Java:

int a, b, c; // Объявление трех целых a, b, и c. int a = 10, b = 10; // Пример инициализации. byte b = 22; // Инициализация переменной b типа byte. double pi = 3.14159; // Объявление и присвоение величины пи. char a = 'a'; // Переменной a типа char присваивается значение 'a'. 

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

• локальные переменные;
• переменные экземпляра;
• статические переменные или переменные класса.

Локальные переменные в 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

Переменные экземпляра

• Переменные экземпляра объявляются в классе, но за пределами метода, конструктора или какого-либо блока.
• Когда для объекта в стеке выделяется пространство, создается слот для каждого значения переменной экземпляра.
• В Java переменные экземпляра создаются тогда, когда объект создан с помощью ключевого слова «new» и разрушаются тогда, когда объект уничтожается.
• Переменные содержат значения, которые должны ссылаться более чем на один метод, конструктор или блок, или на основные части состояния объекта, которые должны присутствовать на протяжении всего класса.
• Переменные экземпляра могут быть объявлен на уровне класса, до или после использования.
• Модификаторы доступа могут быть предоставлены для переменных экземпляра.
• Переменные экземпляра в Java являются видимыми для всех методов, конструкторов и блоков в классе. Как правило рекомендуется сделать их private (уровень доступа). Однако можно сделать их видимыми для подклассов этих переменных с помощью модификаторов доступа.
• Переменные экземпляра имеют значения по умолчанию. Для чисел по умолчанию равно 0, для логических – false, для ссылок на объект – null. Значения могут быть присвоены при объявлении или в конструкторе.
• Переменные экземпляра в Java могут быть доступны непосредственно путем вызова имени переменной внутри класса. Однако в статических методах и различных класса (когда к переменным экземпляра дана доступность) должны быть вызваны используя полное имя – 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(1000); empOne.printEmp(); >>

Программа будет будет производить следующий результат:

имя: Олег зарплата: 1000.0

Переменные класса или статические переменные в Java

• Переменные класса, также известные в Java как статические переменные, которые объявляются со статическим ключевым слово в классе, но за пределами метода, конструктора или блока.
• Там будет только одна копия каждой статической переменной в классе, независимо от того, сколько объектов создано из него.
• Статические переменные или переменные класса в Java используются редко, кроме когда объявляются как константы. Константы — переменные, которые объявлены как public/private, final и static. Константы никогда не меняются от первоначального значения.
• В Java статические переменные создаются при запуске программы и уничтожаются, когда выполнение программы остановится.
• Видимость похожа на переменную экземпляра. Однако большинство статических переменных объявляются как public, поскольку они должны быть доступны для пользователей класса.
• Значения по умолчанию такое же, как и у переменных экземпляра. Для чисел по умолчанию равно 0, для данных типа Boolean – false; и для ссылок на объект – null. Значения могут быть присвоены при объявлении или в конструкторе. Кроме того, они могут быть присвоены в специальных блоках статического инициализатора.
• Статические переменные могут быть доступны посредством вызова с именем класса ClassName.VariableName.
• При объявлении переменных класса как public, static, final, имена находятся в верхнем регистре. Если статические переменные такими не являются, синтаксис такой же, как у переменных экземпляра и локальных.

Пример

import java.io.*; public class Employee < // salary(зарплата) переменная private static private static double salary; // DEPARTMENT(отдел) – это константа public static final String DEPARTMENT = "Разработка "; public static void main(String args[])< salary = 1000; System.out.println(DEPARTMENT+"средняя зарплата: "+salary); >> 

Это будет производить следующий результат:

Разработка средняя зарплата: 1000

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

В предыдущих материалах не раз упоминались модификаторы доступа. В следующем уроке мы подробно их рассмотрим.

Оглавление

• 1. Java – Самоучитель для начинающих
• 2. Java – Обзор языка
• 3. Java – Установка и настройка
• 4. Java – Синтаксис
• 5. Java – Классы и объекты
• 6. Java – Конструкторы
• 7. Java – Типы данных и литералы
• 8. Java – Типы переменных
• 9. Java – Модификаторы
• 10. Java – Операторы
• 11. Java – Циклы и операторы цикла
• 11.1. Java – Цикл while
• 11.2. Java – Цикл for
• 11.3. Java – Улучшенный цикл for
• 11.4. Java – Цикл do..while
• 11.5. Java – Оператор break
• 11.6. Java – Оператор continue
• 12. Java – Операторы принятия решений
• 12.1. Java – Оператор if
• 12.2. Java – Оператор if..else
• 12.3. Java – Вложенный оператор if
• 12.4. Java – Оператор switch..case
• 12.5. Java – Условный оператор (? 🙂
• 13. Java – Числа
• 13.1. Java – Методы byteValue(), shortValue(), intValue(), longValue(), floatValue(), doubleValue()
• 13.2. Java – Метод compareTo()
• 13.3. Java – Метод equals()
• 13.4. Java – Метод valueOf()
• 13.5. Java – Метод toString()
• 13.6. Java – Метод parseInt()
• 13.7. Java – Метод Math.abs()
• 13.8. Java – Метод Math.ceil()
• 13.9. Java – Метод Math.floor()
• 13.10. Java – Метод Math.rint()
• 13.11. Java – Метод Math.round()
• 13.12. Java – Метод Math.min()
• 13.13. Java – Метод Math.max()
• 13.14. Java – Метод Math.exp()
• 13.15. Java – Метод Math.log()
• 13.16. Java – Метод Math.pow()
• 13.17. Java – Метод Math.sqrt()
• 13.18. Java – Метод Math.sin()
• 13.19. Java – Метод Math.cos()
• 13.20. Java – Метод Math.tan()
• 13.21. Java – Метод Math.asin()
• 13.22. Java – Метод Math.acos()
• 13.23. Java – Метод Math.atan()
• 13.24. Java – Метод Math.atan2()
• 13.25. Java – Метод Math.toDegrees()
• 13.26. Java – Метод Math.toRadians()
• 13.27. Java – Метод Math.random()
• 14. Java – Символы
• 14.1. Java – Метод Character.isLetter()
• 14.2. Java – Метод Character.isDigit()
• 14.3. Java – Метод Character.isWhitespace()
• 14.4. Java – Метод Character.isUpperCase()
• 14.5. Java – Метод Character.isLowerCase()
• 14.6. Java – Метод Character.toUpperCase()
• 14.7. Java – Метод Character.toLowerCase()
• 14.8. Java – Метод Character.toString()
• 15. Java – Строки
• 15.1. Java – Метод charAt()
• 15.2. Java – Метод compareTo()
• 15.3. Java – Метод compareToIgnoreCase()
• 15.4. Java – Метод concat()
• 15.5. Java – Метод contentEquals()
• 15.6. Java – Метод copyValueOf()
• 15.7. Java – Метод endsWith()
• 15.8. Java – Метод equals()
• 15.9. Java – Метод equalsIgnoreCase()
• 15.10. Java – Метод getBytes()
• 15.11. Java – Метод getChars()
• 15.12. Java – Метод hashCode()
• 15.13. Java – Метод indexOf()
• 15.14. Java – Метод intern()
• 15.15. Java – Метод lastIndexOf()
• 15.16. Java – Метод length()
• 15.17. Java – Метод matches()
• 15.18. Java – Метод regionMatches()
• 15.19. Java – Метод replace()
• 15.20. Java – Метод replaceAll()
• 15.21. Java – Метод replaceFirst()
• 15.22. Java – Метод split()
• 15.23. Java – Метод startsWith()
• 15.24. Java – Метод subSequence()
• 15.25. Java – Метод substring()
• 15.26. Java – Метод toCharArray()
• 15.27. Java – Метод toLowerCase()
• 15.28. Java – Метод toString()
• 15.29. Java – Метод toUpperCase()
• 15.30. Java – Метод trim()
• 15.31. Java – Метод valueOf()
• 15.32. Java – Классы StringBuilder и StringBuffer
• 15.32.1. Java – Метод append()
• 15.32.2. Java – Метод reverse()
• 15.32.3. Java – Метод delete()
• 15.32.4. Java – Метод insert()
• 15.32.5. Java – Метод replace()
• 16. Java – Массивы
• 17. Java – Дата и время
• 18. Java – Регулярные выражения
• 19. Java – Методы
• 20. Java – Потоки ввода/вывода, файлы и каталоги
• 20.1. Java – Класс ByteArrayInputStream
• 20.2. Java – Класс DataInputStream
• 20.3. Java – Класс ByteArrayOutputStream
• 20.4. Java – Класс DataOutputStream
• 20.5. Java – Класс File
• 20.6. Java – Класс FileReader
• 20.7. Java – Класс FileWriter
• 21. Java – Исключения
• 21.1. Java – Встроенные исключения
• 22. Java – Вложенные и внутренние классы
• 23. Java – Наследование
• 24. Java – Переопределение
• 25. Java – Полиморфизм
• 26. Java – Абстракция
• 27. Java – Инкапсуляция
• 28. Java – Интерфейсы
• 29. Java – Пакеты
• 30. Java – Структуры данных
• 30.1. Java – Интерфейс Enumeration
• 30.2. Java – Класс BitSet
• 30.3. Java – Класс Vector
• 30.4. Java – Класс Stack
• 30.5. Java – Класс Dictionary
• 30.6. Java – Класс Hashtable
• 30.7. Java – Класс Properties
• 31. Java – Коллекции
• 31.1. Java – Интерфейс Collection
• 31.2. Java – Интерфейс List
• 31.3. Java – Интерфейс Set
• 31.4. Java – Интерфейс SortedSet
• 31.5. Java – Интерфейс Map
• 31.6. Java – Интерфейс Map.Entry
• 31.7. Java – Интерфейс SortedMap
• 31.8. Java – Класс LinkedList
• 31.9. Java – Класс ArrayList
• 31.10. Java – Класс HashSet
• 31.11. Java – Класс LinkedHashSet
• 31.12. Java – Класс TreeSet
• 31.13. Java – Класс HashMap
• 31.14. Java – Класс TreeMap
• 31.15. Java – Класс WeakHashMap
• 31.16. Java – Класс LinkedHashMap
• 31.17. Java – Класс IdentityHashMap
• 31.18. Java – Алгоритмы Collection
• 31.19. Java – Iterator и ListIterator
• 31.20. Java – Comparator
• 32. Java – Дженерики
• 33. Java – Сериализация
• 34. Java – Сеть
• 34.1. Java – Обработка URL
• 35. Java – Отправка Email
• 36. Java – Многопоточность
• 36.1. Java – Синхронизация потоков
• 36.2. Java – Межпоточная связь
• 36.3. Java – Взаимная блокировка потоков
• 36.4. Java – Управление потоками
• 37. Java – Основы работы с апплетами
• 38. Java – Javadoc