В этом видео автор анализирует, насколько Java остаётся актуальной в 2025 году и какие изменения произошли в языке и экосистеме.
Разбираются ключевые области применения Java — от корпоративных систем и Android-разработки до backend-сервисов — и сравнивается её востребованность с другими языками программирования.

public interface MyInterface {
    default void showMessage() {
        print("Default method calling private method");
    }

    static void showStaticMessage() {
        print("Static method calling private method");
    }

    // Private method for reuse
    private static void print(String message) {
        System.out.println(message);
    }
}

class Task implements Comparable<Task> {
    String name;
    Integer priority;

    public Task(String name, Integer priority) {
        this.name = name;
        this.priority = priority;
    }

    @Override
    public int compareTo(@NotNull Task o) {
        return priority - o.priority;
    }
}

public class Test {
    public static void main(String[] args) {
        PriorityQueue<Task> pq = new PriorityQueue<>();

        pq.add(new Task("Task1", 1));
        pq.add(new Task("Task5", 5));
        pq.add(new Task("Task2", 2));
        pq.add(new Task("Task4", 4));
        pq.add(new Task("Task3", 3));

        while (!pq.isEmpty()) {
            System.out.println(pq.poll().name);
            // Выведет: Task1, Task2, Task3, Task4, Task5
        }
    }
}

syntax = "proto3";

message Order {
  string id = 1;
  double amount = 2;
  string status = 3;
}

mvn protobuf:compile

interaction:
  request:
    method: GET
    path: /orders/123
  response:
    status: 200
    body:
      id: "123"
      amount: 50.0

@Pact(consumer = "billing-service")
public RequestResponsePact pact(PactDslWithProvider builder) {
    return builder
      .given("Order exists")
      .uponReceiving("Get order by ID")
      .path("/orders/123").method("GET")
      .willRespondWith()
      .status(200)
      .body("{\"id\":\"123\",\"amount\":50.0}")
      .toPact();
}

@Provider("order-service")
@PactFolder("pacts")
public class ProviderVerificationTest {
    @TestTemplate
    @ExtendWith(PactVerificationInvocationContextProvider.class)
    void verifyPacts(PactVerificationContext context) {
        context.verifyInteraction();
    }
}

docker run -d -p 9292:9292 pactfoundation/pact-broker

mvn verify -Pcontract-tests

body:
  amount: 50.0
  currency: "USD" # новое поле, не ломает старый контракт

@SpringBootTest
@AutoConfigureStubRunner(ids = "com.demo:order-service:+:stubs:8080")
class BillingTest { ... }

implementation("org.wasmtime:wasmtime:17.0.0")

Engine engine = new Engine();
Store store = new Store(engine);
byte[] wasm = Files.readAllBytes(Paths.get("add.wasm"));
Module module = Module.fromBinary(engine, wasm);
Instance instance = new Instance(store, module, new Extern[]{});
Func add = instance.getExport(store, "add").func();
System.out.println(add.call(store, 5L, 3L));

#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}

rustup target add wasm32-unknown-unknown
cargo build --target wasm32-unknown-unknown --release

WasiCtx wasiCtx = WasiCtx.builder()
    .inheritStdout()
    .inheritStderr()
    .build();
wasiCtx.define(store);

Linker linker = new Linker(engine);
Instance instance = linker.instantiate(store, module);
Func main = instance.getExport(store, "_start").func();
main.call(store);

Memory memory = instance.getExport(store, "memory").memory();
byte[] data = "Hello WASM".getBytes();
memory.write(store, 0, data);

Func process = instance.getExport(store, "process").func();
process.call(store, 0L, (long) data.length);

byte[] result = new byte[100];
memory.read(store, 100, result);
System.out.println(new String(result).trim());

#[no_mangle]
pub extern "C" fn matrix_mul(a: *const f64, b: *const f64, 
    c: *mut f64, n: usize) {
    unsafe {
        for i in 0..n {
            for j in 0..n {
                let mut sum = 0.0;
                for k in 0..n {
                    sum += (*a.add(i*n+k)) * (*b.add(k*n+j));
                }
                *c.add(i*n+j) = sum;
            }
        }
    }
}

try (Context context = Context.create("wasm")) {
    Source source = Source.newBuilder("wasm", 
        Files.readAllBytes(Paths.get("calc.wasm")), 
        "module").build();
    Value wasm = context.eval(source);
    System.out.println(wasm.getMember("add").execute(10, 20).asInt());
}

Map<String, Instance> plugins = new HashMap<>();

void loadPlugin(String name, String path) throws Exception {
    byte[] wasm = Files.readAllBytes(Paths.get(path));
    Instance instance = new Instance(new Store(new Engine()), 
        Module.fromBinary(new Engine(), wasm), new Extern[]{});
    plugins.put(name, instance);
}

String executePlugin(String name, String input) {
    Func process = plugins.get(name)
        .getExport(null, "process").func();
    return process.call(null, input).toString();
}

// Java: 2000ms на fib(40)
public static long fib(long n) {
    return n <= 1 ? n : fib(n-1) + fib(n-2);
}

// WASM: 380ms на fib(40)
#[no_mangle]
pub extern "C" fn fib(n: u64) -> u64 {
    match n { 0|1 => n, _ => fib(n-1) + fib(n-2) }
}

В этом видео автор подробно объясняет, что такое вложенные классы и зачем они нужны — как описать дополнительный объект, который принадлежит к основному классу.

Разбирается также работа с анонимными классами, которые позволяют быстро добавить новый функционал к создаваемому объекту прямо на месте, без создания отдельного файла.

sdk install java 23-graal
gu install native-image

mvn -Pnative native:compile

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, native world!");
    }
}

native-image -jar app.jar
./app

Java: ~1.5s, 150MB  
Native: 0.05s, 30MB

mvn -Pnative spring-boot:build-image

[
  { "name": "com.demo.User", "allDeclaredConstructors": true }
]

mvn package -Dpackaging=native-image

FROM scratch
COPY app /
ENTRYPOINT ["/app"]

native-image --verbose --diagnostics-mode ...

В этом видео автор подробно разбирает, как организовывать код с помощью пакетов (packages) и зачем они нужны для структурирования проекта.

Также объясняется принцип перегрузки методов — когда один метод может иметь разные версии с разными параметрами. Разбирается практическое применение модификаторов static и final, которые меняют поведение классов и методов.

// Классический Hello World на Raspberry Pi
java -Xmx512m -jar app.jar
// Результат: 15 секунд запуска, 300 МБ памяти, батарея мрёт

native-image --no-server -H:+StaticExecutableWithDynamics -jar app.jar
./app
# Запуск: 0.05с, память: 30 МБ

public class TemperatureSensor {
    public static void main(String[] args) throws Exception {
        // Читаем температуру каждые 5 сек
        while (true) {
            double temp = readTemp(); // Из GPIO или UART
            System.out.println("Temp: " + temp + "°C");
            Thread.sleep(5000);
        }
    }
    
    static double readTemp() {
        return Math.random() * 50; // Симуляция
    }
}

import org.eclipse.paho.client.mqttv3.*;

public class IotDevice {
    public static void main(String[] args) throws Exception {
        MqttClient client = new MqttClient(
            "tcp://broker.hivemq.com:1883", 
            "device-001"
        );
        client.connect();
        
        String payload = "{\"temp\":25.5,\"humidity\":60}";
        client.publish("sensors/room1", payload.getBytes(), 1, true);
        
        client.disconnect();
    }
}

<!-- pom.xml -->
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-smallrye-mqtt</artifactId>
</dependency>

mvn package -Dnative
# Результат: 80 МБ образ (вместо 500 МБ обычного Spring Boot)

import com.pi4j.io.gpio.*;

public class LedBlink {
    public static void main(String[] args) throws Exception {
        GpioController gpio = GpioFactory.getInstance();
        GpioPinDigitalOutput pin = gpio.provisionDigitalOutputPin(
            RaspiPin.GPIO_01, 
            "LED", 
            PinState.LOW
        );
        
        for (int i = 0; i < 10; i++) {
            pin.toggle();
            Thread.sleep(500);
        }
          gpio.shutdown();
    }
}

import java.sql.*;

public class EdgeDb {
    public static void main(String[] args) throws Exception {
        Connection conn = DriverManager.getConnection(
            "jdbc:sqlite:/tmp/device.db"
        );
        
        Statement stmt = conn.createStatement();
        stmt.execute(
            "CREATE TABLE IF NOT EXISTS readings " +
            "(id INTEGER PRIMARY KEY, temp REAL, time LONG)"
        );
         stmt.execute(
          "INSERT INTO readings (temp, time) VALUES (25.5, " + 
           System.currentTimeMillis() + ")"
        );
         conn.close();
    }
}

import io.micronaut.http.annotation.*;

@Controller("/api")
public class SensorController {
    
    @Get("/temperature")
    public Map<String, Object> getTemp() {
        return Map.of(
            "temp", 25.5,
            "unit", "celsius",
            "timestamp", System.currentTimeMillis()
        );
    }
}

java -XX:+PrintGCDetails \
     -XX:+PrintGCDateStamps \
     -XX:+PrintGCTimeStamps \
     -Xloggc:gc.log \
     -jar app.jar

# Для low-latency (микросервисы, финтех)
java -XX:+UseZGC \
     -XX:ZUncommitDelay=300 \
     -Xms8g -Xmx8g \
     -jar app.jar

# Для throughput (batch, аналитика)
java -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=200 \
     -XX:InitiatingHeapOccupancyPercent=35 \
     -Xms8g -Xmx8g \
     -jar app.jar

java -Xms8g -Xmx8g \
     -XX:+AlwaysPreTouch \
     -XX:+UseTransparentHugePages \
     -jar app.jar

java -XX:NewRatio=3 \
     -XX:SurvivorRatio=8 \
     -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=50 \
     -jar app.jar

java -XX:ParallelGCThreads=8 \
     -XX:ConcGCThreads=4 \
     -XX:+ParallelRefProcEnabled \
     -XX:+UseG1GC \
     -jar app.jar

java -XX:InitiatingHeapOccupancyPercent=35 \
     -XX:G1ReservePercent=10 \
     -XX:+UseG1GC \
     -jar app.jar

java -XX:+UseG1GC \
     -XX:+UseStringDeduplication \
     -XX:StringDeduplicationAgeThreshold=3 \
     -jar app.jar

# Создаём архив классов
java -Xshare:dump \
     -XX:SharedArchiveFile=./app-cds.jsa \
     -cp app.jar

# Боевые запуски
java -Xshare:on \
     -XX:SharedArchiveFile=./app-cds.jsa \
     -jar app.jar

# Общая картина GC
jstat -gc -h10 <pid> 1000

# Детали по поколениям
jstat -gccapacity <pid> 2000

# Причины сборок
jstat -gccause <pid> 1000

public record User(String name, int age) {}

Object obj = "Hello World";

if (obj instanceof String) {
    String s = (String) obj; // 🤢 Лишняя строка и дублирование типа
    System.out.println(s.toUpperCase());
}

if (obj instanceof String s) {
    System.out.println(s.toUpperCase());
}

if (obj instanceof String s && s.length() > 5) {
    System.out.println("Длинная строка: " + s);
}

int days = 0;
switch (month) {
    case FEBRUARY:
        days = 28;
        break; // Забыл break? Получи баг!
    case APRIL: 
    case JUNE:
        days = 30;
        break;
    default:
        days = 31;
}

int days = switch (month) {
    case FEBRUARY -> 28;
    case APRIL, JUNE -> 30;
    default -> 31;
};

int result = switch (input) {
    case "A" -> 1;
    case "B" -> {
        System.out.println("Вычисляем...");
        yield 2; 
    }
    default -> 0;
};

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-validation'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    runtimeOnly 'org.postgresql:postgresql'
}

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

@RestController
@RequestMapping("/api/hello")
public class HelloController {

    @GetMapping
    public Map<String, String> hello() {
        return Map.of("message", "Spring Boot работает!");
    }
}

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/demo
    username: user
    password: pass
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

@Entity
public class User {
    @Id @GeneratedValue
    private Long id;
    private String name;
}

public interface UserRepo extends JpaRepository<User, Long> {}

@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepo repo;

    public User create(String name) {
        var user = new User();
        user.setName(name);
        return repo.save(user);
    }
}

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/users")
public class UserController {

    private final UserService service;

    @PostMapping
    public User create(@RequestParam String name) {
        return service.create(name);
    }
}

@WebMvcTest(UserController.class)
class UserControllerTest {

    @Autowired MockMvc mvc;

    @Test
    void testCreate() throws Exception {
        mvc.perform(post("/api/users?name=Tom"))
           .andExpect(status().isOk());
    }
}

./gradlew bootJar
java -jar build/libs/app.jar

FROM eclipse-temurin:21
COPY build/libs/app.jar app.jar
ENTRYPOINT ["java","-jar","app.jar"]

dependencies {
    implementation 'org.springframework.ai:spring-ai-openai-spring-boot-starter'
}

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        model: gpt-4.1

@RestController
@RequiredArgsConstructor
public class AiController {

    private final ChatClient chatClient;

    @GetMapping("/explain")
    public String explain(@RequestParam String code) {
        return chatClient
                .prompt("Объясни этот код кратко:\n" + code)
                .call()
                .content();
    }
}

record Result(String summary, int score) {}

var response = chatClient
        .prompt("""
            Проанализируй текст. 
            Верни: summary, score (0-10).
        """)
        .responseAs(Result.class);

@AiClient
public interface ReviewAi {

    @SystemPrompt("prompts/system.txt")
    @UserPrompt("prompts/review.txt")
    String analyze(String text);
}

var embedding = embeddingClient.embed("Spring AI makes Java smart");

vectorStore.add("doc-1", embedding);

var answer = ragClient
        .query("Как работает наш биллинг?")
        .call()
        .content();

1. берёт эмбеддинг вопроса,
2. ищет релевантные документы,
3. подаёт всё в LLM.

chatClient
        .prompt("Сгенерируй длинное объяснение")
        .stream()
        .forEach(chunk -> System.out.print(chunk.content()));

spring:
  ai:
    clients:
      local:
        base-url: http://localhost:1234/v1
        chat:
          model: llama3
      openai:
        api-key: ${KEY}
        chat:
          model: gpt-4.1

chatClient
    .withConversation("session-42")
    .prompt("Продолжи диалог")
    .call();