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");
    }
}

try (
    Resource1 res1 = new Resource1();
    Resource2 res2 = new Resource2();
) {
    // Работа с ресурсами
}
То сначала будет закрыт res2, а затем — res1. Это важно учитывать при работе с взаимосвязанными ресурсами, например, когда один из них зависит от другого.

try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line = reader.readLine();
    System.out.println(line);
} catch (IOException e) {
    for (Throwable suppressed : e.getSuppressed()) {
        System.out.println("Подавленное исключение: " + suppressed);
    }
    e.printStackTrace();
}
В этом примере, если при чтении файла возникнет исключение, а затем при закрытии ресурса также возникнет ошибка, основное исключение будет сохранено, а исключение, возникшее при закрытии, станет подавленным и может быть получено через getSuppressed().

public class CustomResource implements AutoCloseable {
    private String resourceName;

    public CustomResource(String resourceName) {
        this.resourceName = resourceName;
        System.out.println(resourceName + " открыт.");
    }

    @Override
    public void close() throws Exception {
        System.out.println(resourceName + " закрыт.");
    }
}

public class Main {
    public static void main(String[] args) {
        try (CustomResource res = new CustomResource("Ресурс 1")) {
            System.out.println("Работа с ресурсом.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Ресурс 1 открыт.
Работа с ресурсом.
Ресурс 1 закрыт.
Здесь объект CustomResource автоматически закрывается по завершении блока try, как только завершилась работа с ним.

try (
    Connection conn = DriverManager.getConnection("jdbc:example_url", "user", "password");
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT * FROM table")
) {
    while (rs.next()) {
        System.out.println(rs.getString("column"));
    }
} catch (SQLException e) {
    e.printStackTrace();
}
Здесь все ресурсы — Connection, Statement и ResultSet — будут закрыты автоматически.

try (
    Socket socket = new Socket("localhost", 8080);
    InputStream input = socket.getInputStream();
    OutputStream output = socket.getOutputStream()
) {
    // Чтение и запись данных
} catch (IOException e) {
    e.printStackTrace();
}

try (
    FileInputStream fis = new FileInputStream("source.txt");
    FileOutputStream fos = new FileOutputStream("destination.txt")
) {
    byte[] buffer = new byte[1024];
    int length;
    while ((length = fis.read(buffer)) != -1) {
        fos.write(buffer, 0, length);
    }
} catch (IOException e) {
    e.printStackTrace();
}

class Dog {
    String name;

    Dog(String name) {
        this.name = name;
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog("Buddy");
    }
}
Здесь переменная myDog не содержит сам объект типа Dog. Вместо этого она содержит ссылку на объект Dog, который хранится в динамической памяти (куче).

public class Main {
    public static void main(String[] args) {
        // Примитивный тип
        int a = 5;
        int b = a;
        b = 10;
        System.out.println("a = " + a); // Выведет a = 5, т.к. b — копия значения a

        // Ссылочный тип
        Dog dog1 = new Dog("Buddy");
        Dog dog2 = dog1;
        dog2.name = "Max";
        System.out.println(dog1.name); // Выведет Max, т.к. dog2 и dog1 ссылаются на один объект
    }
}
В случае с примитивными типами значение переменной копируется, а в случае со ссылочными типами переменная хранит ссылку на объект, и при присваивании копируется сама ссылка, а не объект.

public class Main {
    public static void main(String[] args) {
        Dog dog1 = new Dog("Buddy");
        Dog dog2 = dog1;

        dog2.name = "Max";
        System.out.println(dog1.name); // Выведет Max
    }
}
Здесь переменная dog2 является копией ссылки dog1, а не самого объекта. Любые изменения через dog2 отразятся на объекте, на который ссылается dog1.

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        changeName(dog);
        System.out.println(dog.name); // Выведет Max
    }

    public static void changeName(Dog d) {
        d.name = "Max"; // Изменяем поле объекта через ссылку
    }
}
Здесь объект Dog передаётся в метод changeName(), и изменения имени через ссылку d изменяют исходный объект.

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        changeDog(dog);
        System.out.println(dog.name); // Выведет Buddy
    }

    public static void changeDog(Dog d) {
        d = new Dog("Max"); // Переназначаем ссылку, но это не влияет на оригинальную переменную
    }
}
Здесь создание нового объекта внутри метода не изменяет ссылку на оригинальный объект dog в методе main().

Dog dog1 = new Dog("Buddy");
Dog dog2 = new Dog("Buddy");

System.out.println(dog1 == dog2); // Выведет false, так как ссылки разные
System.out.println(dog1.equals(dog2)); // Зависит от реализации метода equals()
По умолчанию метод equals() в классе Object сравнивает ссылки. Чтобы корректно сравнивать объекты по содержимому, необходимо переопределить метод equals().

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }
}

public class Task230924 {
    public static void main(String[] args) {
        Person p1 = new Person("Alice");
        Person p2 = p1;
        p2.name = "Bob";
        System.out.println(p1.name);
    }
}

Dog dog1 = new Dog("Buddy");
Dog dog2 = dog1;
Здесь объект Dog("Buddy") хранится в куче, а ссылки dog1 и dog2 хранятся в стеке. Обе ссылки указывают на один и тот же объект в куче. Когда переменная dog1 выходит из области видимости, её ссылка удаляется, но если на объект всё ещё ссылается dog2, объект остаётся в памяти.

class Dog {
    String name;

    Dog(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Dog dog = (Dog) obj;
        return name.equals(dog.name);
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog1 = new Dog("Buddy");
        Dog dog2 = new Dog("Buddy");

        System.out.println(dog1.equals(dog2)); // Выведет true, т.к. мы переопределили equals
    }
}