public class AssignmentExample {
    public static void main(String[] args) {
        int x = 10;  // присваивание 10 переменной x
        System.out.println("x = " + x);
    }
}
Здесь переменной x присваивается значение 10. Это базовый пример присваивания, где переменная получает конкретное значение, которое позже может быть использовано в программе. Данный оператор является основой для дальнейших операций с переменными.

public class ExpressionAssignmentExample {
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        int c = a + b;  // c присваивается результат сложения a и b
        System.out.println("c = " + c); // c равно 15
    }
}
В этом примере переменной c присваивается результат сложения переменных a и b. Это демонстрирует, что оператор присваивания может работать с выражениями и вычислениями, упрощая процесс программирования.

public class CompoundAssignmentExample {
    public static void main(String[] args) {
        int x = 10;
        x += 5;  // эквивалентно x = x + 5
        System.out.println("x = " + x); // теперь x равно 15
    }
}
Здесь используется оператор +=, который одновременно добавляет значение к переменной x и присваивает результат. Это сокращает запись x = x + 5 до более компактной формы.

public class CompoundAssignmentExample2 {
    public static void main(String[] args) {
        int a = 6;
        a *= 3;  // эквивалентно a = a * 3
        System.out.println("a = " + a); // a равно 18

        int b = 18;
        b /= 6;  // эквивалентно b = b / 6
        System.out.println("b = " + b); // b равно 3
    }
}
Операторы *= и /= работают аналогично: они выполняют умножение и деление соответственно, а затем присваивают результат переменной.

public class IncrementExample {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {  // инкремент i после каждой итерации
            System.out.println("i = " + i);
        }
    }
}
В этом примере цикл for использует постфиксный инкремент i++ для увеличения счётчика на 1 после каждой итерации. Это классический случай использования оператора инкремента в циклах.

public class DecrementExample {
    public static void main(String[] args) {
        int count = 5;
        while (count > 0) {
            System.out.println("Count = " + count);
            count--;  // декремент после каждой итерации
        }
    }
}
Здесь оператор декремента count-- уменьшает значение переменной count на единицу после каждой итерации цикла. Цикл продолжается до тех пор, пока значение переменной не станет меньше или равно нулю.

public class PrefixPostfixExample {
    public static void main(String[] args) {
        int x = 5;
        
        // Постфиксный инкремент
        int y = x++;  // сначала y присваивается 5, затем x увеличивается до 6
        System.out.println("x = " + x); // x равно 6
        System.out.println("y = " + y); // y равно 5
        
        // Префиксный инкремент
        int z = ++x;  // сначала x увеличивается до 7, затем z присваивается 7
        System.out.println("x = " + x); // x равно 7
        System.out.println("z = " + z); // z равно 7
    }
}
В этом примере видно, как постфиксная форма x++ возвращает текущее значение переменной, а затем увеличивает его, в то время как префиксная форма ++x сначала увеличивает значение, а затем возвращает его. Это может быть важно при работе с выражениями, где последовательность вычислений имеет значение.

public class ComplexExpressionExample {
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        int result = a++ + ++b;  // a увеличивается после вычисления, b - до
        System.out.println("a = " + a); // a теперь равно 6
        System.out.println("b = " + b); // b теперь равно 11
        System.out.println("result = " + result); // результат равен 16 (5 + 11)
    }
}
Этот пример показывает, как операторы инкремента могут взаимодействовать с другими операторами в сложных выражениях. Здесь постфиксный инкремент a++ использует старое значение a в выражении, а префиксный инкремент ++b сразу увеличивает значение b.

public class MethodAssignmentExample {
    public static void main(String[] args) {
        int x = 10;
        int y = increment(x);  // вызов метода increment
        System.out.println("x = " + x); // x не изменилось, так как примитивы передаются по значению
        System.out.println("y = " + y); // результат работы метода y равно 11
    }

    public static int increment(int num) {
        return ++num;  // префиксный инкремент увеличивает значение num
    }
}
В этом примере метод increment() использует префиксный инкремент для увеличения значения аргумента. Однако важно отметить, что изменения, произведенные внутри метода, не влияют на исходное значение переменной x, так как примитивные типы в Java передаются по значению.

public class ArrayAssignmentExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] += 1;  // увеличиваем каждый элемент массива на 1
        }
        
        for (int num : numbers) {
            System.out.println(num);  // вывод обновленных значений
        }
    }
}
Здесь оператор присваивания += используется для изменения значений элементов массива. Каждый элемент увеличивается на 1, и результат выводится на экран.

public class ImplicitCastingExample {
    public static void main(String[] args) {
        int intValue = 100;
        double doubleValue = intValue;  // неявное приведение от int к double
        System.out.println("int value: " + intValue);
        System.out.println("double value: " + doubleValue);  // выводится 100.0
    }
}
В этом примере значение переменной intValue типа int автоматически преобразуется в doubleValue типа double без потери данных.

public class ExplicitCastingExample {
    public static void main(String[] args) {
        double doubleValue = 9.78;
        int intValue = (int) doubleValue;  // явное приведение от double к int
        System.out.println("double value: " + doubleValue);
        System.out.println("int value: " + intValue);  // выводится 9 (часть дроби теряется)
    }
}
Здесь мы явно привели тип double к типу int. В результате теряется дробная часть, и остаётся только целое значение.

public class PrimitiveCastingExample {
    public static void main(String[] args) {
        byte byteValue = 10;
        int intValue = byteValue;  // неявное приведение от byte к int
        System.out.println("int value: " + intValue);

        int anotherIntValue = 100;
        byte anotherByteValue = (byte) anotherIntValue;  // явное приведение от int к byte
        System.out.println("byte value: " + anotherByteValue);
    }
}
В первом случае происходит автоматическое расширение типа, так как int больше, чем byte. Во втором случае требуется явное приведение, поскольку возможна потеря данных при сужении типа int до byte.

class Animal {
    public void makeSound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

public class UpcastingExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Animal animal = dog;  // неявное приведение Dog к Animal (upcasting)
        animal.makeSound();  // выводится "Bark", так как объект на самом деле Dog
    }
}
В данном случае объект Dog приводится к типу Animal. Это возможно, так как Dog является наследником Animal, и вызов метода makeSound() все равно приведет к выполнению метода класса Dog.

class Animal {
    public void makeSound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("Bark");
    }
}

public class DowncastingExample {
    public static void main(String[] args) {
        Animal animal = new Dog();  // upcasting
        Dog dog = (Dog) animal;  // downcasting
        dog.bark();  // теперь можно вызвать методы класса Dog
    }
}
Здесь объект типа Animal приводится к Dog. Такое приведение должно быть явным, потому что не каждый объект Animal может быть приведен к Dog. Если бы объект на самом деле не был экземпляром Dog, это вызвало бы ошибку во время выполнения.

interface Walkable {
    void walk();
}

class Human implements Walkable {
    @Override
    public void walk() {
        System.out.println("Human walking");
    }
}

public class InterfaceCastingExample {
    public static void main(String[] args) {
        Human human = new Human();
        Walkable walkable = human;  // неявное приведение к интерфейсу
        walkable.walk();  // вызов метода интерфейса
    }
}
В этом примере объект класса Human приводится к интерфейсу Walkable, что позволяет вызвать методы интерфейса, реализованные в классе.

public class Task170924 {
    static class Animal {
        public void sound() {
            System.out.println("Animal sound");
        }
    }

    static class Dog extends Animal {
        @Override
        public void sound() {
            System.out.println("Dog barks");
        }
    }


    public static void main(String[] args) {
        Animal animal = new Dog();
        Dog dog = (Dog) animal;
        animal.sound();
        dog.sound();
    }
}

object instanceof ClassName

public class InstanceofExample {
    public static void main(String[] args) {
        Animal animal = new Dog();  // Dog является подклассом Animal
        System.out.println(animal instanceof Animal);  // true
        System.out.println(animal instanceof Dog);     // true
        System.out.println(animal instanceof Cat);     // false
    }
}

class Animal { }

class Dog extends Animal { }

class Cat extends Animal { }
В этом примере объект animal создан из класса Dog, который является подклассом Animal. Оператор instanceof показывает, что объект принадлежит как классу Dog, так и его родительскому классу Animal, но не принадлежит классу Cat.

public class InterfaceExample {
    public static void main(String[] args) {
        Flyable bird = new Bird();  // Bird реализует интерфейс Flyable
        if (bird instanceof Flyable) {
            bird.fly();
        }
    }
}

interface Flyable {
    void fly();
}

class Bird implements Flyable {
    public void fly() {
        System.out.println("Bird is flying");
    }
}
Здесь класс Bird реализует интерфейс Flyable, и объект bird проверяется с помощью оператора instanceof перед вызовом метода fly.

class Animal {
}

class Dog extends Animal {
}

public class Task180924 {
    public static void main(String[] args) {
        Animal animal = new Dog();
        Dog dog = new Dog();
        System.out.println(animal instanceof Animal);
        System.out.println(animal instanceof Dog);
        System.out.println(dog instanceof Animal);
        System.out.println(dog instanceof Dog);
    }
}

try {
    // Код, который может вызвать исключение
} catch (ExceptionType e) {
    // Обработка исключения
}

try {
    int[] array = new int[5];
    array[10] = 25; // Может вызвать ArrayIndexOutOfBoundsException
} catch (ArithmeticException e) {
    System.out.println("Арифметическая ошибка.");
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Выход за пределы массива.");
} catch (Exception e) {
    System.out.println("Произошла ошибка.");
}

try {
    int num = Integer.parseInt("ABC");
} catch (Exception e) {
    System.out.println("Произошло исключение: " + e.getMessage());
}
Здесь мы пытаемся преобразовать строку "ABC" в число, что вызовет исключение NumberFormatException. Поскольку мы перехватываем общее исключение Exception, мы сможем обработать его универсально.

public class Task190924 {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Caught ArithmeticException");
        } finally {
            System.out.println("Finally block executed");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Результат: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Ошибка: Деление на ноль!");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}
В данном примере исключение ArithmeticException возникает в методе divide, но обработка происходит в методе main, потому что блок catch для этого исключения находится именно там.

public class Main {
    public static void main(String[] args) {
        try {
            methodA();
        } catch (ArithmeticException e) {
            System.out.println("Ошибка: Деление на ноль!");
        }
    }

    public static void methodA() {
        methodB();
    }

    public static void methodB() {
        int result = 10 / 0; // Исключение здесь
    }
}
Исключение ArithmeticException возникло в методе methodB, но оно было перехвачено и обработано в методе main. Это демонстрирует механизм распространения исключений.

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Ошибка: Деление на ноль!");
        } finally {
            System.out.println("Этот блок выполнится в любом случае.");
        }
    }
}

Результат выполнения:
Ошибка: Деление на ноль!
Этот блок выполнится в любом случае.