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 и делаем код более читаемым.

BufferedReader reader = null;
try {
    reader = new BufferedReader(new FileReader("file.txt"));
    String line = reader.readLine();
    System.out.println(line);
} catch (IOException e) {
    e.printStackTrace();
} finally {
    try {
        if (reader != null) {
            reader.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}
В этом примере ресурсы (файл) явно закрываются в блоке finally, что добавляет сложности и может привести к ошибкам, если закрытие файла не будет выполнено правильно.

try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line = reader.readLine();
    System.out.println(line);
} catch (IOException e) {
    e.printStackTrace();
}
Теперь ресурс (BufferedReader) автоматически закрывается, как только выполнение блока try завершено. Если возникает исключение, ресурс всё равно будет закрыт.

public interface AutoCloseable {
    void close() throws Exception;
}
Когда вы используете класс, реализующий этот интерфейс в try-with-resources, JVM автоматически вызывает метод close() после завершения блока try.

public class Task200924 {
    public static void main(String[] args) {
        try (MyResource resource = new MyResource()) {
            resource.doSomething();
        } catch (Exception e) {
            System.out.println("Exception caught");
        } finally {
            System.out.println("Finally block executed");
        }
    }
}

class MyResource implements AutoCloseable {
    @Override
    public void close() throws Exception {
        System.out.println("Resource closed");
    }

    public void doSomething() throws Exception {
        System.out.println("Doing something");
        throw new Exception("Error occurred");
    }
}