public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void makeSound() {
        System.out.println(name + " издает звук.");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println(name + " лает: Гав!");
    }
}

public class Engine {
    private int horsepower;

    public Engine(int horsepower) {
        this.horsepower = horsepower;
    }

    public void start() {
        System.out.println("Двигатель с " + horsepower + " л.с. запущен.");
    }
}

public class Car {
    private String model;
    private Engine engine;  // Композиция: Car "имеет" Engine

    public Car(String model, Engine engine) {
        this.model = model;
        this.engine = engine;
    }

    public void drive() {
        engine.start();
        System.out.println(model + " едет.");
    }
}

public class Main {
    public static void main(String[] args) {
        Engine engine = new Engine(200);
        Car car = new Car("Toyota", engine);
        car.drive();  // Двигатель с 200 л.с. запущен. Toyota едет.
    }
}

public class Vehicle {
    public void move() {
        System.out.println("Движется с помощью двигателя.");
    }
}

public class Car extends Vehicle {
    // Проблема: А если электромобиль или велосипед?
}

Композиция (решение):
public interface Movable {
    void move();
}

public class EngineMovable implements Movable {
    @Override
    public void move() {
        System.out.println("Движется с помощью двигателя.");
    }
}

public class Car {
    private Movable movement;

    public Car(Movable movement) {
        this.movement = movement;
    }

    public void drive() {
        movement.move();
    }
}

Теперь Car может использовать любой Movable (двигатель, электромотор), без привязки к иерархии.

import java.util.function.Function;

public class Task250925 {
    public static void main(String[] args) {
        Function<Integer, Integer> plus5 = x -> x + 5;
        Function<Integer, Integer> times2 = x -> x * 2;
        
        Function<Integer, Integer> composed = plus5.compose(times2);
        System.out.println(composed.apply(3));
    }
}

import reactor.core.publisher.Flux;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;

Flux<Integer> fastPublisher = Flux.range(1, 1000); // Быстрый источник: 1000 элементов

fastPublisher.subscribe(new Subscriber<Integer>() {
    private Subscription sub;

    @Override
    public void onSubscribe(Subscription s) {
        sub = s;
        sub.request(5); // Сначала запрашиваем 5 элементов
    }

    @Override
    public void onNext(Integer item) {
        System.out.println("Обработано: " + item);
        // Симулируем медленную обработку: Thread.sleep(100); (но в реальности избегайте блокировок!)
        sub.request(1); // После каждого — запрашиваем следующий
    }

    @Override
    public void onError(Throwable t) { /* обработка */ }
    @Override
    public void onComplete() { System.out.println("Готово"); }
});

Здесь подписчик контролирует темп: запросил 5 — получил 5, обработал — запросил ещё. Если не request() — поток остановится. Это асинхронно: издатель не блокируется, а ждёт сигналов.

Flux.interval(Duration.ofMillis(1)) // Бесконечный поток: элемент каждую мс
    .onBackpressureDrop(dropped -> System.out.println("Сброшено: " + dropped)) // Стратегия: сбрасываем лишнее
    .subscribe(item -> {
        try { Thread.sleep(100); } catch (InterruptedException e) {} // Медленный подписчик
        System.out.println("Обработано: " + item);
    });

Здесь быстрый Flux "замедляется" под подписчика: лишние элементы сбрасываются, система не падает.

Ещё опция — cancel(): подписчик может полностью отменить подписку, если данных слишком много или не нужно.

public class Task260925 {
    public static void main(String[] args) {
        String a = "hello";
        String b = "he" + "llo";
        String c = "he";
        String d = "llo";
        String e = c + d;
        String f = (c + d).intern();
        
        System.out.print((a == b) + " ");
        System.out.print((a == e) + " ");
        System.out.print((a == f) + " ");
        System.out.print(a.equals(e));
    }
}

xml<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-graphql</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

graphqltype Query {
    bookById(id: ID): Book
    allBooks: [Book]
}

type Book {
    id: ID
    title: String
    author: Author
}

type Author {
    id: ID
    name: String
    books: [Book]
}
Здесь Query — это корневой тип для запросов. ID — уникальный идентификатор, String — текст. [Book] значит список книг. Это позволяет запрашивать книги с авторами, и сервер сам свяжет данные.

javaimport jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.ManyToOne;

@Entity
public class Book {
    @Id
    private Long id;
    private String title;
    @ManyToOne
    private Author author;

    // Геттеры и сеттеры (методы для чтения и записи полей)
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }
    public Author getAuthor() { return author; }
    public void setAuthor(Author author) { this.author = author; }
}

javaimport org.springframework.data.jpa.repository.JpaRepository;

public interface BookRepository extends JpaRepository<Book, Long> {
}
Это интерфейс, который автоматически генерирует методы вроде findById.

javaimport graphql.kickstart.tools.GraphQLQueryResolver;
import org.springframework.beans.factory.annotation.Autowired;

public class QueryResolver implements GraphQLQueryResolver {
    @Autowired
    private BookRepository bookRepository;

    public Book bookById(Long id) {
        return bookRepository.findById(id).orElse(null); // Возвращает книгу или null, если не найдена
    }

    public List<Book> allBooks() {
        return bookRepository.findAll(); // Все книги
    }
}
@Autowired — это инъекция зависимости, Spring сам подставит репозиторий. Для автора аналогично создай AuthorResolver для поля books.

javaimport graphql.kickstart.tools.GraphQLResolver;

public class BookResolver implements GraphQLResolver<Book> {
    public Author author(Book book) {
        return book.getAuthor(); // Просто возвращает автора из модели
    }
}
Это позволяет в запросе GraphQL получить автора без дополнительных усилий.

mvn spring-boot:run.

graphqlquery {
    bookById(id: 1) {
        title
        author {
            name
        }
    }
}

json{
  "data": {
    "bookById": {
      "title": "Война и мир",
      "author": {
        "name": "Лев Толстой"
      }
    }
  }
}

@Bean
public DataLoaderRegistry dataLoaderRegistry(BookRepository bookRepo) {
    DataLoaderRegistry registry = new DataLoaderRegistry();
    registry.register("authorLoader", DataLoader.newDataLoader((List<Long> authorIds) -> 
        CompletableFuture.supplyAsync(() -> bookRepo.findAuthorsByIds(authorIds)))); // Batch-запрос
    return registry;
}