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