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

Введение

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

Skills Graph

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

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

Сначала мы создадим файл на Java, чтобы продемонстрировать объявление и использование переменных. В WebIDE (который похож на VS Code) создайте новый файл с именем VariableDemo.java. Вы можете сделать это, щелкнув правой кнопкой мыши в области проводника файлов, выбрав "Новый файл" и введя имя файла.

Скопируйте и вставьте следующий код в файл:

public class VariableDemo {
    public static void main(String[] args) {
        // Declaring and initializing variables of different types
        byte smallNumber = 127;
        short mediumNumber = 32000;
        int largeNumber = 2000000000;
        long veryLargeNumber = 9000000000000000000L;
        float decimalNumber = 3.14f;
        double preciseDecimal = 3.14159265359;
        char singleCharacter = 'A';
        boolean isJavaFun = true;

        // Printing the values
        System.out.println("byte: " + smallNumber);
        System.out.println("short: " + mediumNumber);
        System.out.println("int: " + largeNumber);
        System.out.println("long: " + veryLargeNumber);
        System.out.println("float: " + decimalNumber);
        System.out.println("double: " + preciseDecimal);
        System.out.println("char: " + singleCharacter);
        System.out.println("boolean: " + isJavaFun);
    }
}

Разберем этот код для лучшего понимания:

1. Мы начинаем с объявления класса с именем VariableDemo. В Java каждая программа должна иметь как минимум один класс.

2. Внутри класса у нас есть метод main. Это точка входа в нашу программу на Java, откуда начинается выполнение.

3. Затем мы объявляем и инициализируем переменные различных примитивных типов данных:

   • byte: Используется для очень маленьких целочисленных значений (-128 до 127)
   • short: Используется для маленьких целочисленных значений (-32 768 до 32 767)
   • int: Используется для целочисленных значений (примерно от -2 миллиарда до 2 миллиардов)
   • long: Используется для очень больших целочисленных значений (примерно от -9 квинтиллионов до 9 квинтиллионов)
   • float: Используется для десятичных чисел (одинарная точность)
   • double: Используется для десятичных чисел с большей точностью
   • char: Используется для одиночных символов
   • boolean: Используется для значений true/false

4. Обратите внимание на суффикс L для значения типа long и суффикс f для значения типа float. Они необходимы, чтобы сообщить Java, что эти литералы должны быть восприниматься соответственно как long и float.

5. Наконец, мы выводим каждую переменную с помощью System.out.println(). Оператор + здесь используется для конкатенации строк, объединяя описательную строку со значением переменной.

Теперь давайте запустим эту программу. В WebIDE откройте панель терминала и выполните следующую команду:

javac VariableDemo.java
java VariableDemo

В панели консоли вы должны увидеть вывод, похожий на следующий:

byte: 127
short: 32000
int: 2000000000
long: 9000000000000000000
float: 3.14
double: 3.14159265359
char: A
boolean: true

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

Работа с арифметическими операторами

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

В WebIDE создайте новый файл с именем ArithmeticDemo.java. Скопируйте и вставьте следующий код:

public class ArithmeticDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;

        System.out.println("Addition: " + (a + b));
        System.out.println("Subtraction: " + (a - b));
        System.out.println("Multiplication: " + (a * b));
        System.out.println("Division: " + (a / b));
        System.out.println("Modulus: " + (a % b));

        // Increment and decrement
        int c = 5;
        System.out.println("c before increment: " + c);
        System.out.println("c after increment: " + (++c));
        System.out.println("c after decrement: " + (--c));
    }
}

Разберем этот код:

1. Мы объявляем две целочисленные переменные, a и b, и присваиваем им значения 10 и 3 соответственно.

2. Затем мы выполняем различные арифметические операции:

   • Сложение (+): складывает два числа
   • Вычитание (-): вычитает правый операнд из левого операнда
   • Умножение (*): умножает два числа
   • Деление (/): делит левый операнд на правый операнд
   • Остаток от деления (%): возвращает остаток от деления левого операнда на правый операнд

3. Мы также демонстрируем операторы инкремента (++) и декремента (--):

   • ++c увеличивает значение c на 1 перед использованием в выражении
   • --c уменьшает значение c на 1 перед использованием в выражении

Запустите эту программу в WebIDE. Вы должны увидеть вывод, похожий на следующий:

Addition: 13
Subtraction: 7
Multiplication: 30
Division: 3
Modulus: 1
c before increment: 5
c after increment: 6
c after decrement: 5

Обратите внимание, что при делении целых чисел (a / b) Java выполняет целочисленное деление, отбрасывая любую дробную часть. Вот почему 10 / 3 дает 3, а не 3.33333....

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

Понимание битовых операторов

Битовые операторы в Java позволяют манипулировать отдельными битами целочисленных типов. Эти операторы реже используются в повседневном программировании, но они важны в определенных сценариях, например, при работе с бинарными данными или оптимизации определенных алгоритмов.

В WebIDE создайте новый файл с именем BitwiseDemo.java. Скопируйте и вставьте следующий код:

public class BitwiseDemo {
    public static void main(String[] args) {
        int a = 60;  // 60 = 0011 1100 in binary
        int b = 13;  // 13 = 0000 1101 in binary

        System.out.println("a & b = " + (a & b));   // AND
        System.out.println("a | b = " + (a | b));   // OR
        System.out.println("a ^ b = " + (a ^ b));   // XOR
        System.out.println("~a = " + (~a));         // NOT
        System.out.println("a << 2 = " + (a << 2)); // Left Shift
        System.out.println("a >> 2 = " + (a >> 2)); // Right Shift
    }
}

Разберем эти битовые операции:

1. Побитовое И (&): Возвращает 1, если оба бита равны 1, в противном случае 0.

   • 60 & 13 = 0011 1100 & 0000 1101 = 0000 1100 (12 в десятичной системе)

2. Побитовое ИЛИ (|): Возвращает 1, если хотя бы один бит равен 1, в противном случае 0.

   • 60 | 13 = 0011 1100 | 0000 1101 = 0011 1101 (61 в десятичной системе)

3. Побитовое исключающее ИЛИ (^): Возвращает 1, если биты различны, 0, если они одинаковы.

   • 60 ^ 13 = 0011 1100 ^ 0000 1101 = 0011 0001 (49 в десятичной системе)

4. Побитовое НЕ (~): Инвертирует все биты.

   • ~60 = ~0011 1100 = 1100 0011 (-61 в десятичной системе, из - за представления в дополнительном коде)

5. Сдвиг влево (<<): Сдвигает все биты влево на указанное количество позиций.

   • 60 << 2 = 0011 1100 << 2 = 1111 0000 (240 в десятичной системе)

6. Сдвиг вправо (>>): Сдвигает все биты вправо на указанное количество позиций.

   • 60 >> 2 = 0011 1100 >> 2 = 0000 1111 (15 в десятичной системе)

Запустите эту программу в WebIDE. Вы должны увидеть вывод, похожий на следующий:

a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15

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

Исследование логических операторов

Логические операторы в Java используются для выполнения логических операций над булевыми значениями. Эти операторы являются важными для создания сложных условий в ваших программах.

В WebIDE создайте новый файл с именем LogicalDemo.java. Скопируйте и вставьте следующий код:

public class LogicalDemo {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        System.out.println("a && b = " + (a && b)); // Logical AND
        System.out.println("a || b = " + (a || b)); // Logical OR
        System.out.println("!a = " + (!a));         // Logical NOT

        // Short-circuit evaluation
        int x = 5;
        int y = 10;
        System.out.println("x < 0 && y++ > 5 = " + (x < 0 && y++ > 5));
        System.out.println("y after evaluation: " + y);
    }
}

Разберем эти логические операции:

1. Логическое И (&&): Возвращает true, если оба операнда равны true, в противном случае false.

   • true && false = false

2. Логическое ИЛИ (||): Возвращает true, если хотя бы один операнд равен true, в противном случае false.

   • true || false = true

3. Логическое НЕ (!): Инвертирует булево значение.

   • !true = false

4. Короткое замыкание (Short - circuit evaluation): В выражении x < 0 && y++ > 5 Java сначала оценивает x < 0. Поскольку это false, она не тратит время на оценку второй части (y++ > 5), так как общий результат должен быть false в любом случае. Вот почему y остается равным 10 после оценки.

Запустите эту программу в WebIDE. Вы должны увидеть вывод, похожий на следующий:

a && b = false
a || b = true
!a = false
x < 0 && y++ > 5 = false
y after evaluation: 10

Понимание логических операторов является важным для создания условий в ваших программах, например, в операторах if или циклах while. Поведение короткого замыкания операторов && и || также может быть использовано для оптимизации вашего кода в определенных ситуациях.

Сборка всего вместе

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

В WebIDE создайте новый файл с именем SimpleCalculator.java. Скопируйте и вставьте следующий код:

public class SimpleCalculator {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        // Arithmetic operations
        System.out.println("Arithmetic Operations:");
        System.out.println("a + b = " + (a + b));
        System.out.println("a - b = " + (a - b));
        System.out.println("a * b = " + (a * b));
        System.out.println("a / b = " + (a / b));
        System.out.println("a % b = " + (a % b));

        // Bitwise operations
        System.out.println("\nBitwise Operations:");
        System.out.println("a & b = " + (a & b));
        System.out.println("a | b = " + (a | b));
        System.out.println("a ^ b = " + (a ^ b));
        System.out.println("~a = " + (~a));

        // Logical operations
        boolean x = a > b;
        boolean y = a < b;
        System.out.println("\nLogical Operations:");
        System.out.println("x && y = " + (x && y));
        System.out.println("x || y = " + (x || y));
        System.out.println("!x = " + (!x));

        // Combining operations
        System.out.println("\nCombined Operations:");
        System.out.println("(a + b) * 2 = " + ((a + b) * 2));
        System.out.println("(a > b) && (a % b == 0) = " + ((a > b) && (a % b == 0)));
    }
}

Разберем этот код и объясним каждую часть:

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

   • Мы выполняем основные арифметические операции (сложение, вычитание, умножение, деление и взятие остатка от деления) над a и b.
   • Эти операции демонстрируют, как использовать арифметические операторы, которые мы изучили ранее.

2. Битовые операции:

   • Мы выполняем битовые операции И, ИЛИ, исключающее ИЛИ и НЕ над a и b.
   • Эти операции показывают, как битовые операторы работают с бинарными представлениями целых чисел.

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

   • Мы создаем две булевы переменные, x и y, на основе сравнений между a и b.
   • Затем мы демонстрируем логические операции И, ИЛИ и НЕ над этими булевыми значениями.

4. Комбинированные операции:

   • Мы показываем, как различные типы операторов могут быть объединены в более сложные выражения.
   • (a + b) * 2 демонстрирует использование скобок для управления порядком выполнения операций.
   • (a > b) && (a % b == 0) объединяет сравнение, операцию взятия остатка от деления и логическую операцию И.

Запустите эту программу в WebIDE. Вы должны увидеть вывод, похожий на следующий:

Arithmetic Operations:
a + b = 15
a - b = 5
a * b = 50
a / b = 2
a % b = 0

Bitwise Operations:
a & b = 0
a | b = 15
a ^ b = 15
~a = -11

Logical Operations:
x && y = false
x || y = true
!x = false

Combined Operations:
(a + b) * 2 = 30
(a > b) && (a % b == 0) = true

Этот вывод демонстрирует, как работает каждый тип оператора:

• Арифметические операции дают ожидаемые математические результаты.
• Битовые операции показывают результаты манипуляций с бинарными представлениями a и b.
• Логические операции показывают, как можно комбинировать булевы значения.
• Комбинированные операции демонстрируют, как можно создавать более сложные выражения, используя несколько типов операторов.

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

Резюме

В этом практическом занятии (лабораторной работе) мы изучили основные концепции программирования на Java: переменные и операторы. Мы узнали, как объявлять и использовать различные типы переменных, в том числе примитивные типы данных, такие как int, boolean и char. Затем мы углубились в изучение различных операторов в Java:

1. Арифметические операторы для выполнения основных математических вычислений
2. Битовые операторы для манипулирования отдельными битами целочисленных типов
3. Логические операторы для работы с булевыми значениями

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