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. Это поможет в дальнейшем анализе произошедшей ошибки.

public class Task240924 {
    public static void main(String[] args) {
        try {
            methodA();
        } catch (Exception e) {
            StackTraceElement[] stackTrace = e.getStackTrace();
            System.out.println(stackTrace[0].getMethodName());
        }
    }

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

    public static void methodB() throws Exception {
        throw new Exception("Error occurred");
    }
}

public class Main {
    public static void main(String[] args) {
        methodA(); // Точка входа
    }

    public static void methodA() {
        methodB(); // Вызов метода B
    }

    public static void methodB() {
        methodC(); // Вызов метода C
    }

    public static void methodC() {
        int result = 10 / 0; // Ошибка деления на ноль
    }
}

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

public class Calculator {
    public static void main(String[] args) {
        try {
            performCalculation();
        } catch (ArithmeticException e) {
            System.out.println("Exception caught: " + e.getMessage());
            e.printStackTrace(); // Вывод StackTrace
        }
    }

    public static void performCalculation() {
        divideNumbers(10, 0);
    }

    public static void divideNumbers(int a, int b) {
        int result = a / b; // Ошибка: деление на ноль
    }
}

Exception caught: / by zero
java.lang.ArithmeticException: / by zero
    at Calculator.divideNumbers(Calculator.java:15)
    at Calculator.performCalculation(Calculator.java:10)
    at Calculator.main(Calculator.java:5)
Как видно из StackTrace, ошибка произошла в методе divideNumbers на строке 15. Но StackTrace также показывает, что вызов метода произошёл из performCalculation на строке 10, а тот, в свою очередь, был вызван из main на строке 5.

public class Main {
    public static void main(String[] args) {
        try {
            causeError();
        } catch (Exception 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());
                System.out.println("----------------------------");
            }
        }
    }

    public static void causeError() {
        int result = 10 / 0; // Ошибка
    }
}

Class: Main
Method: causeError
Line: 15
----------------------------
Class: Main
Method: main
Line: 5
----------------------------

public final class Math {
    // Весь функционал класса
}

int result = Math.max(5, 10); // Возвращает 10

private Math() {
    // Приватный конструктор
}

public static int max(int a, int b) {
    return (a >= b) ? a : b;
}
Здесь используется тернарный оператор для сравнения двух значений. Если первое значение больше либо равно второму, возвращается первое значение, иначе — второе.

public static int min(int a, int b) {
    return (a <= b) ? a : b;
}

public static double sqrt(double a) {
    return StrictMath.sqrt(a); // Вызов аналогичного метода из StrictMath
}

public static double sin(double a) {
    return StrictMath.sin(a);
}

public static final double PI = 3.141592653589793;

public static final double E = 2.718281828459045;

double result = Math.sqrt(-10); // Возвращает NaN, так как корень из отрицательного числа не существует
System.out.println(result); // Выводит NaN

if (Double.isNaN(result)) {
    System.out.println("Результат не является числом");
}

double result = 10.0 / 0.0; // Возвращает Infinity
System.out.println(result); // Выводит Infinity
Для проверки значений бесконечности можно использовать методы Double.isInfinite() и Double.isFinite().

public class Task250924 {
    public static void main(String[] args) {
        double result = Math.max(Math.min(5, 10), Math.sqrt(16));
        System.out.println(result);
    }
}