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
    }
}

Копировать код
class User {
    String name;
    int age;

    User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        User user = new User("John", 30);
        updateUser(user);
        System.out.println("Updated user: " + user.name + ", age: " + user.age);
    }

    public static void updateUser(User user) {
        user.name = "John Doe"; // Изменение объекта по ссылке
        user.age = 31;
    }
}

import java.util.ArrayList;
import java.util.List;

class Car {
    String model;

    Car(String model) {
        this.model = model;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Car> cars = new ArrayList<>();
        cars.add(new Car("Tesla"));
        cars.add(new Car("BMW"));

        for (Car car : cars) {
            System.out.println(car.model);
        }
// Изменение объекта в коллекции
        cars.get(0).model = "Tesla Model S";

        for (Car car : cars) {
            System.out.println(car.model); // Изменения будут отражены в коллекции
        }
    }
}

class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println(singleton1 == singleton2); // Выведет true, т.к. обе ссылки указывают на один объект
    }
}

public class Main {
    public static void main(String[] args) {
        methodA();
    }

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

    public static void methodB() {
        int result = 10 / 0; // Здесь возникает исключение
    }
}

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Main.methodB(Main.java:12)
    at Main.methodA(Main.java:8)
    at Main.main(Main.java:4)

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            StackTraceElement[] stackTrace = e.getStackTrace();
            for (StackTraceElement element : stackTrace) {
                System.out.println("Class: " + element.getClassName());
                System.out.println("Method: " + element.getMethodName());
                System.out.println("Line: " + element.getLineNumber());
            }
        }
    }
}

Class: Main
Method: main
Line: 5
В этом примере мы вручную обрабатываем каждый элемент StackTrace, выводя информацию о классе, методе и строке, в которой возникла ошибка.

import java.util.logging.Logger;

public class Main {
    private static final Logger logger = Logger.getLogger(Main.class.getName());

    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            logger.severe("Exception occurred: " + e.getMessage());
            for (StackTraceElement element : e.getStackTrace()) {
                logger.severe(element.toString());
            }
        }
    }
}
Здесь мы логируем как само сообщение исключения, так и каждый элемент StackTrace. Это поможет в дальнейшем анализе произошедшей ошибки.