Skip to content

Latest commit

 

History

History
625 lines (486 loc) · 29.3 KB

L02.md

File metadata and controls

625 lines (486 loc) · 29.3 KB

Занятие 2. Синтаксис Java (I)

Лексемы

Лексемы (Токены) — это минимальные значимые единицы исходного кода, которые распознаются компилятором на этапе лексического анализа.

Основные типы лексем в Java:

  • Ключевые слова
  • Идентификаторы
  • Литералы
  • Разделители
  • Операторы

Ключевые слова

Ключевые слова — это зарезервированные слова языка программирования.

Список ключевых слов Java:

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

Идентификаторы

Идентификаторы — это имена, которые программист задает сам:

  • Имена классов: MyClass, Calculator.
  • Имена переменных: count, userName.
  • Имена методов: calculateSum(), getUserName().

Правила именования:

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

Литералы

Литералы — это константные значения:

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

123, 0xFF, 0b1010, 100L

Вещественные:

3.14, 2.0f, 1.23e-5

Символьные:

'a', '\n', '\u0041'

Строковые:

"Hello", "Java\tProgramming"

Логические:

true, false

Null-литерал:

null

Разделители

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

Основные разделители в Java:

Символ Название Назначение Примеры использования
; Точка с запятой Завершение инструкций int x = 10;
System.out.println();
, Запятая Разделение элементов int a, b, c;
method(param1, param2);
. Точка Доступ к членам класса System.out
object.method()
Math.PI
() Круглые скобки Группировка выражений, параметры (a + b) * c
method()
if (condition)
{} Фигурные скобки Блоки кода, инициализация { code }
int[] arr = {1, 2, 3};
[] Квадратные скобки Массивы int[] array;
array[0] = 10;
"" Двойные кавычки Строковые литералы String s = "Hello";
'' Одинарные кавычки Символьные литералы char c = 'A';

Специальные разделители в Java:

Символ Название Назначение Примеры
@ At-символ Аннотации @Override
@SuppressWarnings
:: Двойное двоеточие Ссылки на методы System.out::println
... Многоточие Varargs параметры void method(String... args)
<> Diamond оператор Вывод типа дженериков List<String> list = new ArrayList<>();

Переменные

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

Объявление переменной включает ее тип данных и имя:

int age;
String name;
double salary;
boolean isActive;

Инициализация переменной — это процесс присвоения начального значения переменной при её создании.

Инициализация при объявлении переменной:

int count = 0;
double price = 99.99;
boolean isActive = true;

Отложенная инициализация переменной:

int result; // объявление переменной
// ... какие-то инструкции
result = calculateResult(); // инициализация позже

Завершенные переменные

Завершенные переменные — это переменные, которые были проинициализированы и больше не могут быть изменены.

В Java завершенные переменные объявляются с модификатором final.

final int MAX_VALUE = 100;
final String GREETING = "Hello";
final double PI = 3.14159;

Простые (примитивные ) типы данных

Тип данных — это множество значений и операций над этими значениями.

Простые типы данных предназначены для хранения непосредственно значений, а не ссылок на объекты. Они занимают фиксированный объем памяти и имеют значения по умолчанию.

Числовые типы данных

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

Ключевое слово Описание Размер Диапазон Значение по умолчанию
byte Байт 8 бит -128 до 127 0
short Короткое целое 16 бит -32,768 до 32,767 0
int Целое число 32 бит -2³¹ до 2³¹-1 0
long Длинное целое 64 бит -2⁶³ до 2⁶³-1 0L
float Число с плавающей точкой 32 бит ±3.4e⁻³⁸ до ±3.4e³⁸ 0.0F
double Двойной точности 64 бит ±1.7e⁻³⁰⁸ до ±1.7e³⁰⁸ 0.0

Объявление и инициализация переменных числовых типов данных.

byte b = 100;     // Создание байта
short s = 1000;   // Создание короткого целого числа
int i = 100000;   // Создание целого числа
long l = 100000L; // Создание длинного целого числа
float f = 3.14F;  // Создание вещественного числа
double d = 3.14;  // Создание вещественного числа двойной точностью

Преобразование числовых типов данных с расширением емкости.

byte b = 1;
short s = b;
int i = s;
long l = i;
float f = l;
double d = f;

Преобразование числовых типов данных с сужением емкости.

f = (float) d;
l = (long) f;
i = (int) l;
s = (short) i;
b = (byte) s;

Cимвольный тип данных

Простой символьный тип данных в Java:

Ключевое слово Описание Размер Диапазон Значение по умолчанию
char Символ 16 бит '\u0000' до '\uffff' '\u0000'

Объявление и инициализация переменной символьного типа.

char c = 'A'; // Создание символа с помощью символьного литерала
c = 65; // Создание символа с помощью числового литерала

Преобразование числа в символ и наоборот.

int i = 97;
c = (char) i; // Преобразование числа в символ
i = c; // Преобразование символа в число

Операции сравнения символов.

char c1 = 'a';
char c2 = 'b';
boolean f = c1 < c2;

Арифметические операции с символами.

c1 ++;

Логический (булевский) тип данных

Простой логический тип данных в Java:

Ключевое слово Описание Размер Диапазон Значение по умолчанию
boolean Логический ~1 бит (зависит от конкретной JVM) true или false false

Объявление и инициализация переменной логического типа.

boolean flag = true;
boolean isActive = false;

Операторы

Оператор выполняет операцию над одним или несколькими операндами (т. е. переменными, литералами, выражениями) и возвращает результат.

Арифметические операции

int x = 10, y = 5, z;
z = x + y; // Сложение
z = x - y; // Вычитание
z = x * y; // Умножение
z = x / y; // Деление
z = x % y; // Остаток от деления
z = x ++; z = ++ x; // Инкремент
z = x --; z = -- x; // Декремент

Операции сравнения

double x = 1.0, y = 2.5;
boolean f = false;
f = x < y;  // Меньше
f = x <= y; // Меньше или равно
f = x > y;  // Больше
f = x >= y; // Больше или равно
f = x == y; // Равно
f = x != y; // Не равно

Логические операции

Логические операции — это операции, которые работают с булевыми значениями (true и false) и возвращают булево значение.

a b a&&b a||b a^b !a
true true true true false false
true false false true true false
false true false true true true
false false false false false true

Тернарный оператор «? :»

<условие> ? <выражение 1> : <выражение 2> выполняет <выражение 1>, если <условие> истинно, и <выражение 2> в противном случае.

char c = args[0].charAt(0);
String s = Character.isDigit(c) ? "цифра" : "не цифра";
System.out.println(s);

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

Оператор присваивания (=) используется для присвоения значения переменной.

int x;
x = 10; // Присваивание значения 10 переменной x

Составной оператор присваивания объединяет арифметическую или двоичною операцию с присваиванием.

Арифметические составные операторы:

int a = 10;

a += 5;  // эквивалентно: a = a + 5 → 15
a -= 3;  // эквивалентно: a = a - 3 → 12
a *= 2;  // эквивалентно: a = a * 2 → 24
a /= 4;  // эквивалентно: a = a / 4 → 6
a %= 5;  // эквивалентно: a = a % 5 → 1

Побитовые составные операторы:

int b = 12; // 1100 в двоичной

b &= 5;  // 1100 & 0101 = 0100 → 4
b |= 3;  // 0100 | 0011 = 0111 → 7
b ^= 2;  // 0111 ^ 0010 = 0101 → 5
b <<= 1; // 0101 << 1 = 1010 → 10
b >>= 2; // 1010 >> 2 = 0010 → 2
b >>>= 1; // 0010 >>> 1 = 0001 → 1

Множественное присваивание:

// Присваивание нескольких переменных
int x, y, z;
x = y = z = 0;

// При инициализации
int a = 1, b = 2, c = 3;

Присваивание в выражениях:

int value;
if ((value = 0) != -1) {
    System.out.println(value);
}

Cтроки

В Java строки являются объектами класса String.

Объявление и инициализация строк.

// Создать строку с помощью строкового литерала
String s1 = "my text";

// Создание строку с помощью конструктора
String s2 = new String("Hello World!");

Строка хранит массив символов. Получить ее символ по индексу в массиве можно с помощью метода charAt(int i).

String s = "my text";

for (int i = 0; i < s.length(); i++) {
    char c = s.charAt(i);
    System.out.println(c);
}

Конкатенация строк

Конкатенация (соединение) строк выполняется с помощью оператора +

String fullName = "Мария" + " " + "Ивановна";

или метода concat

String greeting = "Hello".concat(" World!");

Оператора + может конкатенировать строку со значением простого типа данных:

String taskName = "Task" + 1; // Конкатенация с целым числом
System.out.println("value=" + true); // Конкатенация с логическим значением

Неизменяемость строк

Строки в Java неизменяемы

String original = "Hello";
original.concat(" World!"); // Не изменит оригинальную строку
System.out.println(original); // Вывод: "Hello"

// Правильное использование:
String modified = original.concat(" World!");
System.out.println(modified); // Вывод: "Hello World!"

Эквивалентность строк

Проверка строк на равенство.

String s1 = "my text";
String s2 = "my text";
boolean b;

// Сравнение двух объектных ссылок
b = s1 == s2;

// Сравнение двух строк по состоянию
b = s1.equals(s2);

// Сравнение двух строк без учета регистра
b = s1.equalsIgnoreCase(s2);

Java использует пул строк для оптимизации памяти:

String s1 = "Hello"; // Попадает в пул
String s2 = "Hello"; // Используется существующая строка из пула
String s3 = new String("Hello"); // Создается новый объект в куче

System.out.println(s1 == s2); // true - один объект в пуле
System.out.println(s1 == s3); // false - разные объекты
System.out.println(s1.equals(s3)); // true - содержимое одинаковое

Преобразование между строками и простыми типами данных

Преобразование чисел в строки.

int i = 1; double d = 2.5;

String s2 = String.valueOf(i); // Преобразование целого числа в строку
String s3 = String.valueOf(d); // Преобразование вещественного числа в строку
String s4 = Integer.toString(i); // Преобразование целого числа в строку
String s5 = Double.toString(d); // Преобразование вещественного числа в строку
String s6 = "" + i; // Преобразование числа в строку через конкатенацию

Преобразование строк в числа.

int i = Integer.parseInt("0"); // Преобразование строки в целое число
long l = Long.parseLong("1"); // Преобразование строки в длинное целое число
float f = Float.parseFloat("2.5"); // Преобразование строки в вещественное число
double d = Double.parseDouble("10"); // Преобразование строки в вещественное число с удвоенной точностью

Преобразование строк в значения логического типа.

boolean b = Boolean.parseBoolean("false");

Токенизация строк

Токенизация строк с помощью метода split.

String s = "my text";
String[] tokens = s.split(" ");

for (int i = 0; i < tokens.length; i++) {
    System.out.println(tokens[i]);
}

Токенизация строк с помощью класса StringTokenizer.

String s = "my text";
StringTokenizer st = new StringTokenizer(s);

while (st.hasMoreTokens()) {
    System.out.println(st.nextToken());
}

Комментарии

// Однострочный комментарий

/* Многострочный
комментарий */

/** Javadoc комментарий */

Задания

Задание 2-1 — 1 балл

  • Разработать калькулятор командной строки для двух операндов и одной операции.
  • Арифметическое выражение должно вводиться пользователем в командной строке в инфиксной записи, например, 2 + 3.
  • Должны поддерживаться по крайней мере: сложение, вычитание, умножение, деление, остаток от деления.
  • Сопроводить исходный код программы комментариями.

Задание 2-2 — 1 балл

  • Разработать калькулятор командной строки для обратной польской нотации.
  • Арифметическое выражение должно вводиться пользователем в командной строке в обратной польской нотации, например, 2 3 +.
  • Реализовать поддержку произвольного количества операндов и операций.
  • Должны поддерживаться по крайней мере: сложение, вычитание, умножение, деление, остаток от деления.
  • Сопроводить исходный код программы комментариями.

Задание 2-3 — 2 балла

  • Разработать калькулятор командной строки для инфиксной записи с произвольным количеством операндов и операций со скобками и приоритетом операций.
  • Арифметическое выражение должно вводиться пользователем в командной строке в инфиксной записи, например, (2 + 3) * 2.
  • Должны поддерживаться по крайней мере: сложение, вычитание, умножение, деление, остаток от деления.
  • Сопроводить исходный код программы Javadoc-комментариями.
  • Сгенерировать HTML-документацию по Javadoc-комментариями (с помощью команды javadoc).
  • Собрать проект в виде запускаемого JAR-файла.
  • Запустить полученный JAR-файл из командной строки.

Вопросы

  1. Какие лексемы есть в вашем коде?
  2. Какие литералы есть в вашем коде?
  3. Какие разделители есть в вашем коде?
  4. Какие идентификаторы есть в вашем коде?
  5. Как вы сопроводили ваш код комментариями?
  6. Какие простые типы данных используются в вашем коде?
  7. Какие размеры имеют использованные вами простые типы данных?
  8. Какой тип данный имеет наибольшую (наименьшую) емкость среди тех, которые вы использовали в вашем коде?
  9. Как вы преобразуете строки в числа?
  10. Как вы разделяете строки на токены?
  11. Какие локальные переменные есть в вашем коде?
  12. Какие инициализации переменных есть в вашем коде?
  13. Есть ли завершенные переменные в вашем коде?
  14. Какие типы данных имеют ваши локальные переменные?
  15. Как вы проверяете равенство строк?
  16. Какие ветвления есть в вашем коде?
  17. Какие циклы есть в вашем коде?
  18. Какие операции есть в вашем коде?
  19. Какие операнды есть в вашем коде?
  20. Как вы считываете данные с командной строки?
  21. Какие комментарии есть в вашем коде?
  22. В каком пакете находится ваш файл с исходным кодом?
  23. Какие классы были импортированы вами?
  24. Как устроен ваш Main-класс?
  25. Как устроен ваш Main-метод?
  26. Как вы инициализировали ваши локальные переменные?
  27. Какие блоки кода есть в вашем исходном коде?
  28. Как вы сравниваете строки, почему именно так?
  29. Как вы вычисляете результат арифметического выражения в постфиксной записи?
  30. Как вы переводите инфиксную запись в постфиксную?

Рекомендации по выполнению заданий

Калькулятор командной строки

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

  • Инфиксная запись со скобками и приоритетом операций, например (A - B) * (C / (D + E) + F)
  • Обратная польская нотация (постфиксная запись): оператор помещается после пары операндов, скобки не используются, например, A B - C D E + / F + *

Реализация калькулятора командной строки для двух операндов и одного оператора:

  • Разобрать строку (арифметическое выражение) на токены (операнды и оператор).
  • Определить: какой оператор задан и применить соответствующую операцию к заданным операндам.

Реализация калькулятора командной строки для постфиксной записи:

  • Разобрать строку (арифметическое выражение) на токены (операнды и операторы).
  • Перебрать токены в порядке их появления в строке.
    • При встрече с операндом, добавить его в стек
    • При встрече с оператором, изъять пару операндов из стека и применить к ним соответствующую операцию. Результат добавить в стек.
  • Конечный результат остается на вершине стека.

Реализация калькулятора командной строки для инфиксной записи:

  • Преобразовать арифметическое выражение из инфиксной записи в обратную польскую нотацию с помощью алгоритма сортировочной станции.
  • Вычислить значение арифметического выражения в обратной польской записи.

Работа со стеком

Стек — это структура данных, представляющая из себя упорядоченный набор элементов, в которой добавление новых элементов и изъятие существующих производится с конца. Первым из стека удаляется элемент, который был помещен туда последним — стратегия LIFO (Last-In, First-Out).

package ru.isu.math.example;

import java.util.Stack;

public class MyMainClass {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>(); // Создать стек
        int result = 0;

        stack.push("10"); // Добавить "10"
        stack.push("20"); // Добавить "20"
        stack.push("+");  // Добавить "+"

        String item = stack.pop(); // Изъять последний элемент

        if (item.equals("+")) {
            int op1 = Integer.parseInt(stack.pop()); // Изъять последний элемент
            int op2 = Integer.parseInt(stack.pop()); // Изъять последний элемент
            result = op1 + op2;
        }
        System.out.println("Результат: " + result);
    }
}

Алгоритм сортировочной станции

Алгоритм сортировочной станции — это алгоритм для разбора математических выражений, разработанный Эдсгером Дейкстрой в 1961 году. Он преобразует инфиксную нотацию (обычную запись) в обратную польскую нотацию, которая легче вычисляется.

Алгоритм использует:

  1. Выходную очередь для конечного результата
  2. Стек операторов для временного хранения операторов

Шаги алгоритма:

Пока есть токены для чтения:

  1. Прочитать токен
  2. Если токен является числом: добавить в выходную очередь
  3. Если токен является оператором: Пока есть оператор на вершине стека с большим или равным приоритетом: Переложить его в выходную очередь Положить токен в стек
  4. Если токен является открывающей скобкой: положить в стек
  5. Если токен является закрывающей скобкой: Пока на вершине стека не открывающая скобка: Переложить оператор в выходную очередь Удалить открывающую скобку из стека

После обработки всех токенов переложить все операторы из стека в выходную очередь

Дополнительные ресурсы

  1. Arithmetic expression evaluation
  2. Evaluate the Value of an Arithmetic Expression in Reverse Polish Notation in Java
  3. Evaluate the value of an arithmetic expression in reverse polish notation in Java
  4. Java program to implement shunting yard algorithm