int a = 1_000_000_000;
int b = 3;
long result = a * b; // результат может быть неверным!

long result = (long) a * b; // безопасно

long x = Long.MAX_VALUE;
x++;
System.out.println(x); // выведет отрицательное число: Long.MIN_VALUE
Это поведение аналогично тому, что происходит с int, short и byte, но требует повышенного внимания при работе с предельными значениями.

long l = -1L;
String binary = Long.toBinaryString(l); // все 64 бита — единицы

int x = 5;
double y = 2.5;
double z = x + y; // x автоматически превращается в double

int i = (int) y; // i = 2, дробная часть отбрасывается

double x = Double.MAX_VALUE;
System.out.println(x * 2); // Infinity

float pi = 3.1415927f;
Без этого литерал будет воспринят как double по умолчанию, что приведет к ошибке компиляции при попытке неявного присваивания.

float a = 0.1f + 0.2f;
System.out.println(a == 0.3f); // false
Это связано с тем, что не все десятичные дроби можно точно представить в двоичной системе.

float a = 1_000_000;
float b = a + 0.0001f;
System.out.println(a == b); // true — потерялась дробная часть

float a = 0.1f + 0.2f;
float b = 0.3f;
if (Math.abs(a - b) < 1e-6) {
    System.out.println("Равны с учетом погрешности");
}

int x = 3;
float y = 2.5f;
float result = x + y; // x преобразован в float
Это не вызывает проблем, но может повлиять на точность, если целое число очень большое.

String s = "😀";
System.out.println(s.length()); // 2, а не 1
Здесь length() возвращает 2, потому что символ представлен двумя char.

char c = 'A';

char c = 'A';
int x = c + 1; // x == 66

char next = (char)(c + 1); // 'B'
Аналогично, попытка присвоить результат арифметики напрямую переменной типа char вызовет ошибку компиляции без приведения.

com.example.myapp
├── controller
├── service
│   └── impl
├── repository
├── dto
├── model
├── config

public class UserResponse {
    private Long id;
    private String name;
}

public class UserCreateRequest {
    private String name;
    private String email;
}

int x = true; // Ошибка компиляции
if (1) { ... } // Тоже ошибка

Boolean obj = true;     // упаковка
boolean val = obj;      // распаковка
Также есть кэширование значений: Boolean.TRUE и Boolean.FALSE — это единственные экземпляры класса Boolean, которые обычно и используются.

List<String> names = new ArrayList<>(); // ссылка на объект ArrayList

String a = "Hello";
String b = a;
Обе переменные a и b ссылаются на один и тот же объект "Hello" в куче (heap). Изменение объекта (если он мутабелен) через одну ссылку отразится на другой.

List<Integer> list1 = new ArrayList<>();
List<Integer> list2 = list1;
list1.add(10);
System.out.println(list2); // [10]

class User {
    String name;
}

User user1 = new User();
User user2 = user1;
user1 = null; // объект всё ещё доступен через user2

String a = new String("Java");
String b = new String("Java");
System.out.println(a == b);      // false — разные объекты
System.out.println(a.equals(b)); // true — сравнение содержимого
== сравнивает ссылки, а equals() — содержимое (если метод переопределён корректно).

String s = null;
System.out.println(s.length()); // исключение
Поэтому рекомендуется использовать Objects.requireNonNull, Optional, или делать явные проверки на null.

int[] nums = {1, 2, 3};
System.out.println(nums.length); // 3
Массивы имеют поля и методы (length — поле, а не метод), и их тип — int[], String[] и т.д.

List<Integer> list = new ArrayList<>();

List<int> wrongList; // ошибка
Поэтому применяются классы-обёртки: Integer, Double, Boolean и т.д.

Person person1 = new Person("John", 25);

Person person1 = new Person("John", 25);
Person person2 = person1;   // person2 ссылается на тот же самый объект
person1 = null;            // теперь единственная ссылка на объект — person2

person1.sayHello();       // вызов метода объекта
int age = person1.getAge(); // чтение свойства через геттер

void modifyList(List<Integer> list) {
    list.add(10);                    // модифицирует оригинальный список
    list = new ArrayList<>();        // переприсвоение локальной переменной — не влияет на внешний список
    list.add(20);                    // меняет уже новый (локальный) список
}

List<Integer> numbers = new ArrayList<>();
modifyList(numbers);
System.out.println(numbers);         // [10], но не [10, 20]

String s = null;
int length = s.length(); // NullPointerException

String a = new String("hello");
String b = new String("hello");

System.out.println(a == b);      // false (разные объекты)
System.out.println(a.equals(b)); // true  (одинаковое содержимое)
Неверное использование == вместо equals() приводит к тому, что два «логически одинаковых» объекта будут считаться разными.

List<String> list = new ArrayList<>();
list.add("A");
List<String> another = list;
another.clear();              // очищает список для обеих ссылок
System.out.println(list);     // []

public class Cache {
    private static final Map<String, Object> CACHE = new HashMap<>();

    public static void put(String key, Object value) {
        CACHE.put(key, value);
    }

    // Если не реализовать метод удаления из CACHE, то объекты будут храниться в памяти постоянно
}

// Плохо:
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i;                  // каждый раз создаётся новый String
}

// Лучше:
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}
String result = sb.toString();

class Address {
    String street;
}

class Person implements Cloneable {
    String name;
    Address address;

    @Override
    protected Person clone() throws CloneNotSupportedException {
        Person cloned = (Person) super.clone();    // поверхностное копирование
        cloned.address = new Address();            // нужно вручную создать новый адрес
        cloned.address.street = this.address.street;
        return cloned;
    }
}
Если не учитывать глубокое копирование, можно случайно разделить внутреннее состояние между двумя объектами, что приведёт к трудноотлавливаемым ошибкам.

int[] nums = new int[5];
System.out.println(nums.length); // 5

String[] names = null;
System.out.println(names.length); // NullPointerException

List<Integer> integers = new ArrayList<>();
integers.add(10); // автоупаковка: int → Integer

class Point {
    int x, y;

    @Override
    public String toString() {
        return "Point(" + x + ", " + y + ")";
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Point)) return false;
        Point other = (Point) obj;
        return x == other.x && y == other.y;
    }

    @Override
    public int hashCode() {
        return 31 * x + y;
    }
}

int[] numbers = new int[5];

String[] names = {"Alice", "Bob", "Charlie"};

int[] data = new int[100];
data = null; // массив станет доступен для удаления

numbers[0] = 10;
System.out.println(numbers[0]); // выводит 10

void fill(int[] arr) {
    arr[0] = 42;
}
После вызова fill(numbers) значение numbers[0] станет 42.

int[] a = new int[3];
a[3] = 5; // ошибка: допустимые индексы — 0, 1, 2

int[] a = null;
System.out.println(a.length); // ошибка

int[] a = {1, 2, 3};
int[] b = a;
b[0] = 99;
System.out.println(a[0]); // выведет 99

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(a == b); // false
System.out.println(Arrays.equals(a, b)); // true

String s1 = "Hello";
String s2 = new String("Hello");

char[] chars = {'J', 'a', 'v', 'a'};
String s3 = new String(chars);

String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); // true — обе ссылаются на одну строку из пула

String s1 = new String("abc");
String s2 = "abc";
System.out.println(s1 == s2); // false

String s1 = new String("abc").intern();
String s2 = "abc";
System.out.println(s1 == s2); // true

String s = "Hello, World!";
int length = s.length();
char ch = s.charAt(0);
String lower = s.toLowerCase();
boolean contains = s.contains("World");

String original = "Java";
String modified = original.replace("J", "K");
System.out.println(original); // Java
System.out.println(modified); // Kava

String a = "hello";
String b = new String("hello");

System.out.println(a == b);          // false — разные объекты
System.out.println(a.equals(b));     // true — одинаковое содержимое
Оператор == сравнивает ссылки, а метод equals() — содержимое.

String result = "";
for (int i = 0; i < 1000; i++) {
    result += "a"; // создается 1000 новых строк
}

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append("a");
}
String result = sb.toString();

String name = null;
if (name.equals("admin")) { // ошибка
}

if ("admin".equals(name)) { // безопасно
}