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("Этот блок выполнится в любом случае.");
        }
    }
}

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

import java.io.*;

public class Main {
    public static void main(String[] args) {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader("file.txt"));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            System.out.println("Файл не найден.");
        } catch (IOException e) {
            System.out.println("Ошибка чтения файла.");
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                    System.out.println("Файл закрыт.");
                }
            } catch (IOException e) {
                System.out.println("Ошибка при закрытии файла.");
            }
        }
    }
}
Здесь, даже если возникает исключение при чтении файла, блок finally гарантирует, что файл будет закрыт. Это важно для освобождения системных ресурсов и предотвращения утечек.

public class Main {
    public static void main(String[] args) {
        try {
            try {
                int result = 10 / 0;
            } catch (ArithmeticException e) {
                System.out.println("Внутренний блок: Деление на ноль.");
            }
            
            String str = null;
            System.out.println(str.length());
        } catch (NullPointerException e) {
            System.out.println("Внешний блок: NullPointerException.");
        }
    }
}
В этом примере два исключения обрабатываются в разных блоках try-catch. Первое исключение (деление на ноль) перехватывается внутренним блоком, а второе — внешним.

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

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

import java.io.*;
import java.sql.*;

public class Main {
    public static void main(String[] args) {
        try {
            readFile("file.txt");
            connectToDatabase();
        } catch (IOException | SQLException e) {
            System.out.println("Ошибка при работе с файлом или базой данных: " + e.getMessage());
        }
    }

    public static void readFile(String fileName) throws IOException {
        // Чтение из файла
        throw new IOException("Ошибка чтения файла");
    }

    public static void connectToDatabase() throws SQLException {
        // Подключение к базе данных
        throw new SQLException("Ошибка подключения к базе данных");
    }
}
Здесь блок catch перехватывает как IOException, так и SQLException, обрабатывая их одним сообщением. Если бы не было возможности использовать multi-catch, нам пришлось бы писать два отдельных блока catch, что увеличило бы количество строк кода.

try {
    // Код
} catch (IOException | Exception e) {
    // Ошибка компиляции
}

try {
    // Код
} catch (Exception e) {
    // Обработка всех исключений
}

try {
    // Код
} catch (IOException | SQLException e) {
    e = new Exception(); // Ошибка: переменная e final
}
Это ограничение незначительно, так как в большинстве случаев переменная e используется только для чтения информации об исключении, например, вызова метода getMessage().

try {
    // Код, который может вызвать любое исключение
} catch (Exception e) {
    System.out.println("Произошла ошибка: " + e.getMessage());
}
Здесь Exception охватывает любые исключения, унаследованные от этого класса. Это полезно, если не нужно точно обрабатывать специфические типы ошибок.

import java.io.*;
import java.net.*;

public class Main {
    public static void main(String[] args) {
        try {
            readFile("file.txt");
            connectToServer("http://example.com");
        } catch (IOException | MalformedURLException e) {
            System.out.println("Ошибка ввода-вывода или неверный URL: " + e.getMessage());
        }
    }

    public static void readFile(String fileName) throws IOException {
        // Чтение из файла
        throw new IOException("Файл не найден");
    }

    public static void connectToServer(String url) throws MalformedURLException {
        // Подключение к серверу
        throw new MalformedURLException("Неверный URL");
    }
}
Здесь мы можем одновременно обработать исключения, возникающие при работе с файлами и URL, поскольку они оба являются подклассами IOException. В результате мы сокращаем количество блоков catch и делаем код более читаемым.