public class StackExample {
    public static void main(String[] args) {
        int a = 5;
        int b = sum(a, 10);
    }

    public static int sum(int x, int y) {
        return x + y;
    }
}

while (true) {
    ClassLoader loader = new MyClassLoader();
    Class<?> clazz = loader.loadClass("MyDynamicClass");
}

public class NativeExample {
    public native void callCMethod();
}

void myMethod();

default void defaultMethod() {
    // Реализация
}

static void staticMethod() {
    // Реализация
}

private void privateMethod() {
    // Реализация
}

public interface MyInterface {
    // Абстрактный метод
    void abstractMethod();
    
    // Default метод
    default void defaultMethod() {
        System.out.println("Default implementation");
    }
    
    // Static метод
    static void staticMethod() {
        System.out.println("Static implementation");
    }
    
    // Private метод (используется внутри интерфейса)
    private void privateMethod() {
        System.out.println("Private helper method");
    }
}

import java.util.function.ObjDoubleConsumer;

class User {
    String name;
    double discount;

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

    void setDiscount(double discount) {
        this.discount = discount;
    }
}

public class Main {
    public static void main(String[] args) {
        ObjDoubleConsumer<User> applyDiscount = (user, discount) -> user.setDiscount(discount);

        User user = new User("Иван");
        applyDiscount.accept(user, 10.5); // Применяем скидку

        System.out.println(user.name + " получил скидку " + user.discount + "%"); 
        // Иван получил скидку 10.5%
    }
}

import java.util.function.ObjIntConsumer;

class Person {
    String name;
    int age;

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

    void setAge(int age) {
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        ObjIntConsumer<Person> setPersonAge = (person, age) -> person.setAge(age);

        Person person = new Person("Анна");
        setPersonAge.accept(person, 30); // Устанавливаем возраст

        System.out.println(person.name + " теперь " + person.age + " лет");
        // Анна теперь 30 лет
    }
}

import java.util.function.ObjLongConsumer;

class Account {
    String username;
    long id;

    Account(String username) {
        this.username = username;
    }

    void setId(long id) {
        this.id = id;
    }
}

public class Main {
    public static void main(String[] args) {
        ObjLongConsumer<Account> setAccountId = (account, id) -> account.setId(id);

        Account account = new Account("user123");
        setAccountId.accept(account, 100000L); // Присваиваем ID

        System.out.println("Аккаунт " + account.username + " имеет ID " + account.id);
        // Аккаунт user123 имеет ID 100000
    }
}

String message = "Hello";
String newMessage = message.replace("H", "J");

System.out.println(message); // Hello
System.out.println(newMessage); // Jello

class BankAccount {
    private final String accountNumber;

    public BankAccount(String accountNumber) {
        this.accountNumber = accountNumber;
    }

    public String getAccountNumber() {
        return accountNumber;
    }
}

List<String> list = new ArrayList<>();
list.add("Java");

modifyList(list); // Метод может изменить список!

System.out.println(list); // Ожидаем ["Java"], но может быть что угодно!

Map<String, String> map = new HashMap<>();
map.put("key", "value");

System.out.println(map.get("key")); // Всегда "value", так как String неизменяемый

final class Person {
    private final String name;
    private final int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

class MyThread extends Thread {
    public MyThread(String name, int priority) {
        super(name);
        setPriority(priority);
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(getName() + " выполняется с приоритетом " + getPriority());
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread low = new MyThread("Low Priority", Thread.MIN_PRIORITY);
        MyThread high = new MyThread("High Priority", Thread.MAX_PRIORITY);

        low.start();
        high.start();
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread high = new MyThread("High Priority", Thread.MAX_PRIORITY);
        Thread low = new MyThread("Low Priority", Thread.MIN_PRIORITY);

        high.start();
        high.join(); // Ждём, пока high завершится

        low.start(); // Теперь запускается low
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        executor.submit(() -> System.out.println("Задача 1"));
        executor.submit(() -> System.out.println("Задача 2"));

        executor.shutdown();
    }
}

import org.springframework.stereotype.Component;

@Component
public class Car {
    public void drive() {
        System.out.println("Машина едет...");
    }
}

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        Car car = context.getBean(Car.class);
        car.drive();
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
    @Bean
    public Car car() {
        return new Car(); // Создаём объект вручную
    }
}

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
Car car = context.getBean(Car.class);

String s1 = new String("Hello"); // В куче (Heap)
String s2 = new String("Hello");

System.out.println(s1 == s2); // false (разные объекты)

String s1 = new String("Hello").intern();
String s2 = new String("Hello").intern();

System.out.println(s1 == s2); // true (одна строка в String Pool)

String s1 = "Hello"; // В String Pool
String s2 = "Hello"; // Ссылается на тот же объект

System.out.println(s1 == s2); // true

List<String> names = new ArrayList<>();
for (int i = 0; i < 100000; i++) {
    names.add(("User" + (i % 100)).intern()); // Используем String Pool
}