Перейти к содержимому

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

  • автор:

Введение в базовый синтаксис в Java

Java — это статически типизированный объектно-ориентированный язык программирования. Он также не зависит от платформы — программы на Java можно писать и компилировать на одном типе машины, например на системе Windows, и выполнять на другом, например на MacOS, без каких-либо изменений исходного кода.

В этом уроке мы рассмотрим и поймем основы синтаксиса Java.

2. Типы данных

В Java есть две широкие категории типов данных: примитивные типы и объекты/ссылочные типы .

Примитивные типы — это базовые типы данных, которые хранят простые данные и формируют основу для манипулирования данными. Например, в Java есть примитивные типы для целочисленных значений ( int, long, byte, short ) , значений с плавающей запятой ( float и double ) , символьных значений ( char ) и логических значений ( boolean ).

С другой стороны, ссылочные типы — это объекты, которые содержат ссылки на значения и/или другие объекты или на специальное значение null для обозначения отсутствия значения.

Класс String является хорошим примером ссылочного типа. Экземпляр класса, называемый объектом, представляет собой последовательность символов, например «Hello World».

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

Чтобы объявить переменную в Java, мы должны указать ее имя (также называемое идентификатором) и тип . Давайте посмотрим на простой пример:

 int a;   int b;   double c; 

В приведенном выше примере переменные получат начальные значения по умолчанию на основе их объявленных типов. Поскольку мы объявили наши переменные как int и double , по умолчанию они будут иметь значения 0 и 0.0 соответственно.

В качестве альтернативы мы можем использовать оператор присваивания (=) для инициализации переменных во время объявления:

 int a = 10; 

В приведенном выше примере мы объявляем переменную с идентификатором a типа int и присваиваем ей значение 10 с помощью оператора присваивания (=) и завершаем оператор точкой « с запятой (;) . В Java обязательно, чтобы все операторы заканчивались точкой с запятой. ** ** ** **

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

  • начинается с буквы, символа подчеркивания (_) или знака доллара ($)
  • не может быть зарезервированным ключевым словом
  • не может быть true , false или null

Давайте расширим наш фрагмент кода выше, включив в него простую арифметическую операцию:

 int a = 10;   int b = 5;   double c = a + b;   System.out.println( a + " + " + b + " = " + c); 

Мы можем прочитать первые три строки приведенного выше фрагмента кода как «присвоить значение 10 a, присвоить значение 5 b, суммировать значения a и b и присвоить результат . В последней строке выводим результат операции в консоль:

10 + 5 = 15.0 

Объявление и инициализация переменных других типов следуют тому же синтаксису, который мы показали выше. Например, давайте объявим String , char и логические переменные:

 String name = "ForEach Blog";   char toggler = 'Y';   boolean isVerified = true; 

Для большей ясности отметим , что основное различие в представлении литеральных значений char и String заключается в количестве кавычек, заключающих значения . Следовательно, «а» — это символ , а «а» — это строка.

4. Массивы

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

идентификатор типа [] = новый тип [длина];

Тип может быть любым примитивным или ссылочным типом.

Например, давайте посмотрим, как объявить массив, который может содержать максимум 100 целых чисел:

 int[] numbers = new int[100]; 

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

 numbers[0] = 1;  numbers[1] = 2;  numbers[2] = 3;   int thirdElement = numbers[2]; 

В Java индексы массивов начинаются с нуля. Первый элемент массива имеет индекс 0, второй элемент — индекс 1 и так далее.

Кроме того, мы можем получить длину массива, вызвав number.length :

 int lengthOfNumbersArray = numbers.length; 

5. Ключевые слова Java

Ключевые слова — это зарезервированные слова, которые имеют особое значение в Java.

Например, public, static, class, main, new, instanceof являются ключевыми словами в Java , и поэтому мы не можем использовать их в качестве идентификаторов (имен переменных) .

6. Операторы в Java

Теперь, когда мы рассмотрели оператор присваивания (=) выше, давайте рассмотрим некоторые другие типы операторов в языке Java :

6.1. Арифметические операторы

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

    • (плюс или дополнение; также используется для объединения строк)
    • (умножение)

    Мы использовали оператор плюс (+) в нашем предыдущем примере кода для выполнения сложения двух переменных. Аналогично используются и другие арифметические операторы.

    Еще одно использование плюса (+) для конкатенации (объединения) строк для формирования совершенно новой строки:

     String output = a + " + " + b + " = " + c; 

    6.2. Логические операторы

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

    • && (А ТАКЖЕ)
    • || (ИЛИ ЖЕ)
    • ! (НЕТ)

    Давайте рассмотрим следующие фрагменты кода, демонстрирующие логические операторы И и ИЛИ. В первом примере показан оператор печати, который выполняется, когда числовая переменная делится как на 2, так и на 3:

     int number = 6;    if (number % 2 == 0 && number % 3 == 0)    System.out.println(number + " is divisible by 2 AND 3");   > 

    В то время как второй выполняется, когда число делится на 2 ИЛИ на 5:

     if (number % 2 == 0 || number % 5 == 0)    System.out.println(number + " is divisible by 2 OR 5");   > 

    6.3. Операторы сравнения

    Когда нам нужно сравнить значение одной переменной со значением другой, мы можем использовать операторы сравнения Java :

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

     public boolean canVote(int age)    if(age  18)    return false;   >   return true;   > 

    7. Структура Java-программы

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

    Основной единицей Java-программы является класс . Класс может иметь одно или несколько полей (иногда называемых свойствами) , методов и даже других членов класса, называемых внутренними классами . «

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

    Давайте напишем простой исполняемый класс для реализации одного из фрагментов кода, которые мы рассмотрели ранее:

     public class SimpleAddition     public static void main(String[] args)    int a = 10;   int b = 5;   double c = a + b;   System.out.println( a + " + " + b + " = " + c);   >   > 

    Имя класса — SimpleAddition , и внутри него у нас есть основной метод, в котором находится наша логика. Сегмент кода между открывающей и закрывающей фигурными скобками называется блоком кода.

    Исходный код программы Java хранится в файле с расширением .java .

    8. Компиляция и выполнение программы

    Чтобы выполнить наш исходный код, нам сначала нужно его скомпилировать. Этот процесс создаст двоичный файл с расширением .class . Мы можем выполнить двоичный файл на любой машине, на которой установлена среда выполнения Java (JRE).

    Давайте сохраним наш исходный код из приведенного выше примера в файл с именем SimpleAddition.java и запустим эту команду из каталога, в котором мы сохранили файл:

     javac SimpleAddition.java 

    Чтобы выполнить программу, мы просто запускаем:

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

    В программе использую int переменную. Объявляю её в самом начале класса. Эта переменная будет использоваться только в одном методе этого класса. Но этот метод будет вызываться программой в цикле практически непрерывно. AndroidStudio предлагает мне сделать эту переменную локальной, т.е. объявить её прямо в том методе, где она будет использоваться. Но в результате этого в цикле будет выполняться её циклическая инициализация. Работать программа будет правильно. Но, мне кажется, что в результате программа будет выполнять ненужные действия: постоянно инициализировать переменную. Или я не правильно понимаю принципы работы андроида? Может быть он не тратит на инициализацию никаких вычислительных ресурсов? И правильнее инициализировать переменную именно внутри метода? И дополнительно — если вместо int будет объявляться объект (String, Integer, Point. ), как в этом случае поступать?

    Отслеживать
    18k 11 11 золотых знаков 27 27 серебряных знаков 59 59 бронзовых знаков
    задан 14 мар 2022 в 11:24
    197 1 1 серебряный знак 12 12 бронзовых знаков

    В общем случае — на инициализацию локальных переменных тратится меньше времени чем на создание глобальной 🙂 локальная переменная зачастую не уезжает из регистров\стека никуда, особенно если это инкремент для цикла, т.е. ее создание будет «дешевле» чем вытащить старую переменную из ОЗУ 🙂

    Commented 14 мар 2022 в 11:30

    @ Владимир Клыков, дело в том, что метод выполняется с частотой примерно 60 раз в сек. Т.е. переменная будет заново создаваться с такой же частотой. В этом случае как поступить?

    Commented 14 мар 2022 в 12:11

    @gibsonff В случае если это число, весь машинный код инициализации будет «положить число в регистр процессора», это ерунда. А вот если вы инициализируете сложный объект. Вы уверены, что вам нужно инициализировать этот объект 60 раз в секунду? Что это за объект такой? Что-то не то с вашим кодом в этом случае. И тут дело уже не в области видимости этого объекта, а в архитектуре программы.

    Commented 14 мар 2022 в 12:14

    Процессор вашего телефона выполняет миллиард операций (тактов) в секунду. Инициализация целочисленной переменной — один такт. 60 инициализаций в секунду — вы этого никогда не заметите.

    Как объявить переменную в файле с расширением java, зная только путь к файлу?

    Есть N файлов с расширением .java, в каждом объявлен какой-то класс на Java. Как программно в каждом классе объявить некоторую переменную и инициализировать её требуемым значением? Нужен код (или хотя бы его алгоритм), которому можно было бы передать только путь к файлу. На выходе — отредактированный файл, в котором добавлена строка

    type myvariable = somevalue; 

    Оригинальный текст вопроса: Как объявить переменную в файле с расширением java, зная только путь к файлу? В этом файле нужно объявить эту переменную и задать ей значение, которое мне потребуется.

    Отслеживать
    34.2k 25 25 золотых знаков 131 131 серебряный знак 225 225 бронзовых знаков
    задан 1 фев 2016 в 15:28
    265 3 3 серебряных знака 12 12 бронзовых знаков
    Я, например, не понял, что вы имеете в виду.
    Commented 1 фев 2016 в 15:31

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

    Commented 1 фев 2016 в 16:03

    @user200355 тут зависит от того, что это за файлы, чему принадлежат, и зачем вообще в 5000 файла одинаковая переменная О________________________О может эти файлы у вас все наследуются от чего-то, тогда может быть у родителя можно сделать поле. тут надо задачу смотреть и думать. а то чую вы фигню какую-то задумали 😀

    Commented 1 фев 2016 в 16:12

    @Qwertiy почему никак? это ж обычный текстовый файл. берем перезаписываем его с данными которые нужны.

    Commented 1 фев 2016 в 18:18
    @АлексейШиманский: Похоже, что ваш комментарий — это ответ. Опубликуете?
    Commented 3 фев 2016 в 6:44

    1 ответ 1

    Сортировка: Сброс на вариант по умолчанию

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

    Для получения структурного представления документа, нужно вначале найти какой-нибудь парсер, который даст доступ до модификации AST. Суть в том, что мы загружаем в парсер файл, на выход получаем AST в удобной для модификации форме, создаем и добавляем новое поле, и собираем его назад в java-код.

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

    Как можно понять по коду, нужно запускать этот пример из командной строки. Для разбора аргументов командной строки применяется вполне стандартное решение — Apache Commons CLI.

    Я собрал вам готовый пример прямо в репозитории на гитхабе, его можно собрать с помощью mvn clean install . Список аргументов можно узнать, запустив команду mvn exec:java без параметров в корне проекта. Настоящий запуск можно выполнить, указав все аргументы как-то так: mvn exec:java -Dexec.args=»-s C:\tmp\M.java -d C:\tmp\M3.java -n x -t int -i 10″ (конечно, подставив правильные значения).

    Теперь перейдем к самому коду программы:

    /** * Этот класс содержит в себе исполняемую из терминала программу, * которая читает java-файл, добавляет в него поле согласно параметрам командной строки, * и пишет его в исходящий java-файл. */ public class Main < /** * Главный метод приложения * @param args */ public static void main(String[] args) < //Парсим параметры командной строки OptionalargzOpt = ParsedArgs.parse(args); if (!argzOpt.isPresent()) < System.out.println("Can't parse parameters, terminated."); return; >ParsedArgs argz = argzOpt.get(); //Перезаписываем файл addVariableAndReplaceFile(argz.type, argz.varName, argz.initString, argz.srcFile, argz.destFile); //PROFIT System.out.println("All operations completed."); > /** * Перезаписать файл destFile содержимым srcFile с добавлением поля типа type, с именем name и инициализатором initString */ public static void addVariableAndReplaceFile(String type, String name, String initString, String srcFile, String destFile) < //Добавляем поле, получаем новый текст класса Optionalresult = addVariable(type, name, initString, srcFile); if (result.isPresent()) < try < //Пишем полученный текст в файл Files.write(Paths.get(destFile), result.get().getBytes()); >catch (IOException e) < e.printStackTrace(); >System.out.println(String.format("File was changed and saved to: %s", destFile)); > else < System.out.println("Parser returned an empty response - probably something gone wrong!"); >> /** * Вернуть строку с содержимым srcFile с добавлением поля типа type, с именем name и инициализатором initString */ public static Optional addVariable(String type, String name, String initString, String srcFile) < Optionalresult = Optional.empty(); //С помощью Javaparser конструируем CompilationUnit из файла Optional compilationUnitOpt = Optional.empty(); try(FileInputStream in = new FileInputStream(srcFile)) < compilationUnitOpt = Optional.of(JavaParser.parse(in)); >catch (Exception e) < e.printStackTrace(); >//Определяем параметры добавляемого поля FieldDeclaration fieldDeclaration = new FieldDeclaration( ModifierSet.PUBLIC | ModifierSet.STATIC | ModifierSet.FINAL, new ClassOrInterfaceType(type), new VariableDeclarator(new VariableDeclaratorId(name), new NameExpr(initString)) ); //Добавляем поле в compilation unit if (compilationUnitOpt.isPresent()) < CompilationUnit compilationUnit = compilationUnitOpt.get(); for (TypeDeclaration typ : compilationUnit.getTypes()) < ASTHelper.addMember(typ, fieldDeclaration); >result = Optional.of(compilationUnit.toString()); > return result; > /** * Класс для хранения пачки параметров командной строки для приложния, которое должно выполняться в терминале */ private static class ParsedArgs < public String srcFile; public String destFile; public String type; public String varName; public String initString; public static Optionalparse(String[] args) < Optionalresult = Optional.empty(); try < //Формируем правила Apache Commons CLI ParsedArgs obj = new ParsedArgs(); Options options = new Options(); options.addOption("s", "source", true, "source file"); options.addOption("d", "dest", true, "destination file"); options.addOption("t", "type", true, "type of the variable"); options.addOption("n", "name", true, "name of the variable"); options.addOption("i", "init", true, "initialization string for the variable"); //Парсим аргументы с помощью заготовленных правил CommandLineParser parser = new DefaultParser(); CommandLine cmd = parser.parse( options, args); //Перебрасываем в поля класса obj.srcFile = cmd.getOptionValue("s"); obj.destFile = cmd.getOptionValue("d"); obj.type = cmd.getOptionValue("t"); obj.varName = cmd.getOptionValue("n"); obj.initString = cmd.getOptionValue("i"); //Все переменные строго обязательные - если одна из них пропущена, печатаем help и выходим if (null == obj.srcFile || null == obj.destFile || null == obj.type || null == obj.varName || null == obj.initString) < HelpFormatter formatter = new HelpFormatter(); formatter.printHelp( "jaddfield", options ); System.out.println("ALL PARAMETERS ARE MANDATORY"); return Optional.empty(); >result = Optional.of(obj); > catch (ParseException e) < System.out.println("Error trying to parse options"); e.printStackTrace(); return Optional.empty(); >return result; > > > 

    Конечно же, для сборки данного проекта нужно подключить библиотеки JavaParser и CommonsCLI, и перевести компилятор в режим Java 8. Вот пример POM файла для Maven, который делает все необходимые действия:

      4.0.0 com.olegchir.stackoverflowru q488119 1.0-SNAPSHOT  com.github.javaparser javaparser-core 2.3.0  commons-cli commons-cli 1.3.1     org.apache.maven.plugins maven-compiler-plugin 2.3.2 1.8 1.8      

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

    Для хранения данных в программе предназначены переменные . Переменная представляет именованную область памяти, которая хранит значение определенного типа. Каждая переменная имеет тип, имя и значение. Тип определяет, какую информацию может хранить переменная или диапазон допустимых значений.

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

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

    Например, определим переменную, которая будет называться x и будет иметь тип int :

    int x;

    В этом выражении мы объявляем переменную x типа int . То есть x будет хранить некоторое число не больше 4 байт.

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

    • имя может содержать любые алфавитно-цифровые символы, а также знак подчеркивания, при этом первый символ в имени не должен быть цифрой
    • в имени не должно быть знаков пунктуации и пробелов
    • имя не может быть ключевым словом языка Java

    Кроме того, при объявлении и последующем использовании надо учитывать, что Java — регистрозависимый язык, поэтому следующие объявления int num; и int NUM; будут представлять две разных переменных.

    Объявив переменную, мы можем присвоить ей значение:

    int x; // объявление переменной x = 10; // присвоение значения System.out.println(x); // 10

    Также можно присвоить значение переменной при ее объявлении. Этот процесс называется инициализацией :

    int x = 10; // объявление и инициализация переменной System.out.println(x); // 10

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

    int x; System.out.println(x);

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

    int x, y; x = 10; y = 25; System.out.println(x); // 10 System.out.println(y); // 25

    Также можно их сразу инициализировать:

    int x = 8, y = 15; System.out.println(x); // 8 System.out.println(y); // 15

    Отличительной особенностью переменных является то, что мы можем в процессе работы программы изменять их значение:

    int x = 10; System.out.println(x); // 10 x = 25; System.out.println(x); // 25

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

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

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

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

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

    var x; // ! Ошибка, переменная не инициализирована x = 10;

    Константы

    Кроме переменных, в Java для хранения данных можно использовать константы . В отличие от переменных константам можно присвоить значение только один раз. Константа объявляется также, как и переменная, только вначале идет ключевое слово final :

    final int LIMIT = 5; System.out.println(LIMIT); // 5 // LIMIT=57; // так мы уже не можем написать, так как LIMIT - константа

    Как правило, константы имеют имена в верхнем регистре.

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

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

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