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)) { // безопасно
}

public interface Animal {
    void makeSound();
}

public class Dog implements Animal {
    public void makeSound() {
        System.out.println("Woof");
    }
}

public interface Logger {
    default void log(String msg) {
        System.out.println("Log: " + msg);
    }
}

public void processAnimal(Animal animal) {
    animal.makeSound(); // работает с любым классом, реализующим Animal
}

@FunctionalInterface
public interface Converter<F, T> {
    T convert(F from);
}

Animal animal = new Dog();

List<String> list = new ArrayList<>();
Map<String, Integer> map = new HashMap<>();
Здесь List и Map — интерфейсы, а ArrayList и HashMap — конкретные реализации. Это позволяет заменить реализацию без изменения остального кода.

public interface Flyable {
    void fly();
}

public interface Swimmable {
    void swim();
}

public class Duck implements Flyable, Swimmable {
    public void fly() { ... }
    public void swim() { ... }
}
Это решает проблему ограничений одиночного наследования и позволяет композировать поведение.

interface A {
    default void show() { System.out.println("A"); }
}
interface B {
    default void show() { System.out.println("B"); }
}
class C implements A, B {
    public void show() {
        A.super.show(); // Явное разрешение конфликта
    }
}

List<String> list = new LinkedList<>();
list.get(0); // Поведение может отличаться от ArrayList

Runnable r = () -> System.out.println("Run");

public interface Repository<T> {
    void save(T entity);
}

interface A { void a(); }
interface B extends A { void b(); }
Класс, реализующий B, обязан реализовать методы a() и b().

var list = new ArrayList<String>();
var name = "John";
var age = 25;

ArrayList<String> list = new ArrayList<>();
String name = "John";
int age = 25;

var name; // ошибка компиляции

var user = new User("Alice");

User user = new User("Alice");

for (var entry : map.entrySet()) {
    ...
}

try (var stream = Files.lines(path)) {
    ...
}

Map<String, List<User>> usersByRole = new HashMap<>();

var usersByRole = new HashMap<String, List<User>>();

for (var entry : map.entrySet()) { ... }

var x = process(); // Что возвращает process()? Map? List? String?

var data = null; // ошибка компиляции: невозможно вывести тип

var list = Arrays.asList(1, 2, 3); // list: List<Integer>, но неизменяемый!

var x = 42; // int
var y = 42L; // long

// Может быть неожиданным, если x и y пойдут в разные ветви перегрузки

var list = new ArrayList<String>(); // тип легко читается

var result = service.process(); // неясно, что такое result

String name = null;

public class Example {
    String name; // По умолчанию null
}

Person person = null;

String userInput = null; // Пользователь ничего не ввёл

if (userInput == null) {
    System.out.println("Пустой ввод");
}

List<String> list = getList();
if (list != null) {
    list.add("new item");
}

String name = null;
System.out.println(name.length()); // NullPointerException

String result = compute();
if (result != null) {
    ...
}
Если забыть такую проверку — возможна ошибка.

Objects.requireNonNull(input, "Input must not be null");

Optional<String> result = Optional.ofNullable(getName());
result.ifPresent(System.out::println);
Optional помогает избежать null, особенно в возвращаемых значениях.

List<String> list = new ArrayList<>(); // вместо null

if (obj == null) { ... }

obj.equals(null); // Может выбросить NPE, если obj == null

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

String s = null;
System.out.println(s instanceof String); // false

printName(null);
Но важно, чтобы метод корректно это обрабатывал.

Integer x = 5; // int -> Integer автоматически

Integer x = Integer.valueOf(5);

int y = x; // Integer -> int автоматически

int y = x.intValue();

int x = 10;
Integer y = new Integer(x); // вручную

x — хранится в стеке, занимает 4 байта.
y — объект в куче, содержит поле типа int со значением 10 и дополнительную информацию (например, hashCode, class pointer и т.д.).

Integer z = 10;
Компилятор заменит это на Integer.valueOf(10), что использует кэш оберток от -128 до 127.

List<Integer> numbers = new ArrayList<>();
numbers.add(10);  // int -> Integer (autoboxing)
int n = numbers.get(0); // Integer -> int (unboxing)
Это работает, потому что ArrayList хранит только объекты, а int автоматически упаковывается и распаковывается.

List<Integer> list = new ArrayList<>();
list.add(42); // без ручного создания new Integer(42)

Integer sum = 0;
for (int i = 0; i < 10; i++) {
    sum += i; // автораспаковка и автоупаковка
}

Integer x = null;
int y = x; // NullPointerException

Integer sum = 0;
for (int i = 0; i < 1000; i++) {
    sum += i; // каждый шаг — распаковка, сложение, упаковка
}

int sum = 0; // быстрее и без накладных расходов

Integer a = 1000;
Integer b = 1000;
System.out.println(a == b); // false

Integer a = 100;
Integer b = 100;
System.out.println(a == b); // true — значения из кэша

Integer x = 127;
Integer y = 127;
System.out.println(x == y); // true

Integer x = 128;
Integer y = 128;
System.out.println(x == y); // false
Причина — кэш для Integer в диапазоне [-128; 127].

public static Integer valueOf(int i) {
    if (i >= -128 && i <= 127)
        return IntegerCache.cache[i + 128];
    else
        return new Integer(i);
}