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

class ClassName {
    // Поля
    // Конструкторы
    // Вложенные классы
    // Блоки инициализации
}

class Person {
    String name;
    int age;

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

    void introduce() {
        System.out.println("Меня зовут " + name + ", мне " + age + " лет.");
    }
}

Тип имяПоля;
Тип имяПоля = начальноеЗначение;

class Car {
    String model;             // Поле экземпляра
    int speed = 0;            // Поле с начальным значением
    static int totalCars = 0; // Статическое поле
}

ClassName(параметры) {
    // Инициализация объекта
}

class Student {
    String name;
    int grade;

    Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }

    Student() {
        this("Unknown", 0); // Вызов другого конструктора
    }
}

class Book {
    String title;

    Book(String title) {
        this.title = title;
    }
}

class Outer {
    static class StaticNested {
        void display() {
            System.out.println("Static nested class");
        }
    }
}

class Outer {
    class Inner {
        void display() {
            System.out.println("Inner class");
        }
    }
}

Outer.StaticNested nested = new Outer.StaticNested();

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();

class Example {
    {
        System.out.println("Экземплярный блок инициализации");
    }
}

class Example {
    static {
        System.out.println("Статический блок инициализации");
    }
}

class A {
    // основной класс
}

class B {
    // вспомогательный
}

package my.project;

import java.util.List;

class Example {
    // тело класса
}

[модификаторы] тип_возврата имя_метода(параметры) [throws исключения] {
    // Тело метода
}

class Calculator {
    int calculateSum(int a, int b) {
        return a + b;
    }
}

class Person {
    String name;

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

    void printGreeting() {
        System.out.println("Меня зовут " + name);
    }
}

Person person = new Person("Алексей");
person.printGreeting(); // Вывод: Меня зовут Алексей

class MathUtils {
    static double calculateSquare(double x) {
        return x * x;
    }
}

double result = MathUtils.calculateSquare(5.0); // Вывод: 25.0

тип_параметра имя_параметра [, тип_параметра имя_параметра ...]

class Calculator {
    int calculateProduct(int a, int b) {
        return a * b;
    }
}

class MathUtils {
    int calculateSum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
}

class Example {
    String getWelcomeMessage() {
        return "Привет, мир!";
    }

    void printMessage() {
        System.out.println("Сообщение без возврата");
    }
}

class ArrayUtils {
    int[] generateNumbers() {
        return new int[] {1, 2, 3};
    }
}

class Printer {
    void printMessage(String message) {
        System.out.println(message);
    }

    void printNumber(int number) {
        System.out.println("Число: " + number);
    }

    void printRepeatedMessage(String message, int times) {
        for (int i = 0; i < times; i++) {
            System.out.println(message);
        }
    }
}

Printer printer = new Printer();
printer.printMessage("Привет"); // Вывод: Привет
printer.printNumber(42); // Вывод: Число: 42
printer.printRepeatedMessage("Повтор", 3); // Вывод: Повтор (3 раза)

class FileReader {
    void readFileContent(String path) throws IOException {
        // Код, который может выбросить IOException
    }
}

class Factorial {
    int calculateFactorial(int n) {
        if (n <= 1) {
            return 1;
        }
        return n * calculateFactorial(n - 1);
    }
}

Factorial fact = new Factorial();
int result = fact.calculateFactorial(5); // Вывод: 120

class Example {
    // Правильно: описывает действие, использует camelCase
    String getUserName() {
        return "Алексей";
    }

    // Неправильно: не описывает действие, использует сокращение
    String user() {
        return "Алексей";
    }

    // Правильно: использует is для булевого значения
    boolean isActive() {
        return true;
    }

    // Неправильно: не соответствует соглашению для булевых методов
    boolean active() {
        return true;
    }
}

class StackExample {
    void methodA() {
        methodB();
    }

    void methodB() {
        System.out.println("В методе B");
    }
}

class MemoryExample {
    void modifyObject(StringBuilder sb, int value) {
        sb.append("Изменено"); // Изменяет объект в куче
        value = 100; // Изменяет локальную копию, не влияет на исходное значение
    }
}

StringBuilder sb = new StringBuilder("Привет");
int value = 42;
MemoryExample example = new MemoryExample();
example.modifyObject(sb, value);
System.out.println(sb); // Вывод: ПриветИзменено
System.out.println(value); // Вывод: 42

/**
 * Вычисляет сумму двух чисел.
 * @param firstNumber Первое число
 * @param secondNumber Второе число
 * @return Сумма чисел
 */
int calculateSum(int firstNumber, int secondNumber) {
    return firstNumber + secondNumber;
}

public
protected
package-private (по умолчанию, если модификатор не указан)
private

[идентификатор_доступа] тип_элемента имя_элемента;

public class Example {
    private int privateField;
    protected String protectedField;
    int packagePrivateField; // package-private (по умолчанию)
    public void publicMethod() {
        // Код метода
    }
}

public class PublicClass {
    public int publicField = 42;

    public void publicMethod() {
        System.out.println("Публичный метод");
    }
}

PublicClass obj = new PublicClass();
System.out.println(obj.publicField); // Доступно
obj.publicMethod(); // Доступно

class BaseClass {
    protected String protectedField = "Защищенное поле";

    protected void protectedMethod() {
        System.out.println("Защищенный метод");
    }
}

// В том же пакете
BaseClass obj = new BaseClass();
System.out.println(obj.protectedField); // Доступно
obj.protectedMethod(); // Доступно

// В подклассе в другом пакете
class SubClass extends BaseClass {
    void accessProtected() {
        System.out.println(protectedField); // Доступно через наследование
    }
}

class PackagePrivateClass {
    int packagePrivateField = 100;

    void packagePrivateMethod() {
        System.out.println("Метод с доступом по умолчанию");
    }
}

// В том же пакете
PackagePrivateClass obj = new PackagePrivateClass();
System.out.println(obj.packagePrivateField); // Доступно
obj.packagePrivateMethod(); // Доступно

// В другом пакете
// Ошибка компиляции: PackagePrivateClass не виден

class PrivateExample {
    private int privateField = 10;

    private void privateMethod() {
        System.out.println("Приватный метод");
    }

    public void accessPrivate() {
        System.out.println(privateField); // Доступно внутри класса
        privateMethod(); // Доступно внутри класса
    }
}

PrivateExample obj = new PrivateExample();
// System.out.println(obj.privateField); // Ошибка компиляции
// obj.privateMethod(); // Ошибка компиляции
obj.accessPrivate(); // Доступно

public class OuterClass {
    private class InnerClass {
        // Приватный внутренний класс
    }
}

Пример Singleton:
class Singleton {
    private static final Singleton INSTANCE = new Singleton();

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

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

class Employee {
    private String name;
    private double salary;

    public String getName() {
        return name;
    }

    public void setSalary(double salary) {
        if (salary >= 0) {
            this.salary = salary;
        }
    }
}

class MemoryExample {
    private int privateField = 10;
    public int publicField = 20;

    void accessFields() {
        privateField = 30; // Доступно внутри класса
        publicField = 40; // Доступно везде
    }
}

Поля privateField и publicField занимают одинаковое место в куче (4 байта для int), но private ограничивает доступ, защищая целостность объекта.

class Counter {
    private static int count = 0;

    public static void increment() {
        count++;
    }
}

Поле count хранится в Metaspace, а private модификатор гарантирует, что доступ возможен только через метод increment.

/**
 * Класс для управления данными пользователя.
 */
public class User {
    /**
     * Имя пользователя, доступное только внутри класса.
     */
    private String name;

    /**
     * Возвращает имя пользователя.
     * @return Имя пользователя
     */
    public String getName() {
        return name;
    }
}