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 {
    // тело класса
}

class A300625 {
    { System.out.print("1"); }
    public A300625() { System.out.print("2"); }
}

class B300625 extends A300625 {
    { System.out.print("3"); }
    public B300625() { System.out.print("4"); }
}

public class Task300625 {
    public static void main(String[] args) {
        new B300625();
    }
}

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.10.1</version>
</plugin>

<executions>
    <execution>
        <id>custom-compile</id>
        <phase>compile</phase>
        <goals>
            <goal>compile</goal>
        </goals>
        <configuration>
            <source>17</source>
            <target>17</target>
        </configuration>
    </execution>
</executions>

Каждая <execution> создает отдельный экземпляр Mojo в памяти, что может увеличить потребление ресурсов при сложных конфигурациях.

<pluginManagement>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.10.1</version>
            <configuration>
                <source>11</source>
                <target>11</target>
            </configuration>
        </plugin>
    </plugins>
</pluginManagement>

<plugin>
    <groupId>com.github.spotbugs</groupId>
    <artifactId>spotbugs-maven-plugin</artifactId>
    <version>4.7.3.0</version>
    <executions>
        <execution>
            <phase>verify</phase>
            <goals>
                <goal>check</goal>
            </goals>
        </execution>
    </executions>
</plugin>

package com.example;

import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;

@Mojo(name = "say-hello")
public class HelloMojo extends AbstractMojo {
    @Parameter(property = "message", defaultValue = "Hello, Maven!")
    private String message;

    public void execute() throws MojoExecutionException {
        getLog().info(message);
    }
}

mvn clean install

<plugin>
    <groupId>com.example</groupId>
    <artifactId>custom-maven-plugin</artifactId>
    <version>1.0-SNAPSHOT</version>
    <executions>
        <execution>
            <phase>compile</phase>
            <goals>
                <goal>say-hello</goal>
            </goals>
        </execution>
    </executions>
</plugin>

public class Task010725 {
    public static void main(String[] args) {
        final int a = 10;
        final int b = 20;
        byte c = a + b;
        System.out.println(c);
    }
}

[модификаторы] тип_возврата имя_метода(параметры) [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;
}