Интерфейсы в Java

public abstract class ChessItem {
    int x;
    int y;

    abstract void move();
}

public interface Flyable {
    void fly();
}

public interface Throwable {
    void throwSomething();
}

public class Bishop extends ChessItem implements Flyable {
    @Override
    void move() {
        // обычный ход слона
    }

    @Override
    public void fly() {
        // полёт
    }
}

public class Knight extends ChessItem implements Flyable, Throwable {
    @Override
    void move() {
        // обычный ход коня
    }

    @Override
    public void fly() {
        // полёт
    }

    @Override
    public void throwSomething() {
        // швыряние пешкой
    }
}

interface Drawable {
    void draw();
}

interface Moveable {
    void move(int x, int y);
}

interface Clickable {
    void onClick();
}

// Множественное наследование интерфейсов
interface InteractiveElement extends Drawable, Moveable, Clickable {
    void highlight();
}

interface Drawable {
    void draw();
}

interface Movable {
    void move(int x, int y);
}

// Класс реализует ДВА интерфейса
class Circle implements Drawable, Movable {
    private int x, y, radius;

    @Override
    public void draw() {
        System.out.println("Рисуем круг радиусом " + radius);
    }

    @Override
    public void move(int dx, int dy) {
        x += dx;
        y += dy;
    }
}

// Человек - это сущность → абстрактный класс
abstract class Person {
    String name;
    int age;
    abstract void speak();
}

// Способности → интерфейсы
interface Swimmer { void swim(); }
interface Runner { void run(); }
interface Coder { void writeCode(); }

// Конкретный класс реализует способности
class Developer extends Person implements Coder, Swimmer {
    @Override
    void speak() { System.out.println("Hello!"); }
    @Override
    public void writeCode() { System.out.println("Writing Java..."); }
    @Override
    public void swim() { System.out.println("Swimming..."); }
}

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}

// Использование через лямбду
Calculator add = (a, b) -> a + b;
Calculator multiply = (a, b) -> a * b;

System.out.println(add.calculate(5, 3));    // 8
System.out.println(multiply.calculate(5, 3)); // 15

import java.util.*;
import java.util.function.*;

public class Main {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("cat", "elephant", "dog", "giraffe");        
        words.stream()
             .filter(s -> s.length() > 3)      // Predicate
             .map(String::toUpperCase)          // Function
             .forEach(System.out::println);     // Consumer
             // ELEPHANT
             // GIRAFFE
    }
}

interface Drawable {
    void draw();

    // default метод - общая логика для всех реализаций
    default void drawTwice() {
        draw();
        draw();
    }

    // static метод - утилитарный
    static void printDrawingInfo() {
        System.out.println("Рисуем фигуру...");
    }
}

// Обычный класс-реализация
class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Рисуем круг");
    }
}

// Ещё одна реализация
class Square implements Drawable {
    @Override
    public void draw() {
        System.out.println("Рисуем квадрат");
    }
}

public class Main {
    public static void main(String[] args) {
        Drawable.printDrawingInfo(); // static метод

        Circle circle = new Circle();
        circle.drawTwice(); // default метод

        // Полиморфизм через интерфейс
        Drawable drawable = new Circle();
        drawable.draw(); // Рисуем круг

        drawable = new Square();
        drawable.draw(); // Рисуем квадрат
    }
}

@FunctionalInterface
interface Drawable {
    void draw();

    default void drawWithBorder() {
        draw();
        drawBorder();
    }

    // private метод (Java 9+) - вспомогательный
    private void drawBorder() {
        System.out.println("Рисуем границу");
    }
}

public class Main {
    public static void main(String[] args) {
        Drawable circle = () -> System.out.println("Рисуем круг");
        Drawable square = () -> System.out.println("Рисуем квадрат");

        circle.drawWithBorder();
        // Рисуем круг
        // Рисуем границу

        square.drawWithBorder();
        // Рисуем квадрат
        // Рисуем границу
    }
}

interface A {
    default void print() {
        System.out.println("A");
    }
}

interface B {
    default void print() {
        System.out.println("B");
    }
}

// Класс реализует два интерфейса с одинаковым default-методом
// Обязательно переопределяем метод или пишем свою реализацию, чтобы разрешить конфликт
class Test implements A, B {
    @Override
    public void print() {
        A.super.print(); // явно выбираем реализацию из интерфейса A
        // или B.super.print(); // или можно выбрать B
        // или System.out.println("C"); // написать свою реализацию 
    }
}

public class Main {
    public static void main(String[] args) {
        Test test = new Test();
        test.print(); // A
    }
}

// 1. Serializable - помечает, что объект можно преобразовать в байты для сохранения/передачи
public interface Serializable {
    // Полностью пустой!
}

// 2. Cloneable - разрешает клонирование объекта через Object.clone()
public interface Cloneable {
    // Тоже пустой!
}

// 3. RandomAccess - сигнализирует, что доступ к элементам коллекции быстрый (O(1))
public interface RandomAccess {
    // Пустой интерфейс
}

import java.io.*;

// Маркерный интерфейс Serializable
class User implements Serializable {
    String name;
    int age;

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

public class Main {
    public static void main(String[] args) throws IOException {
        User user = new User("Alice", 25);

        // Проверка маркера
        if (user instanceof Serializable) {
            System.out.println("Объект можно сериализовать!");
        }
    }
}

// 1. Интерфейс с множеством методов
interface MouseListener {
    void onClick();
    void onDoubleClick();
    void onRightClick();
    void onHover();
    void onDrag();
}

// 2. Адаптер - пустая реализация всех методов
abstract class MouseAdapter implements MouseListener {
    @Override public void onClick() {}
    @Override public void onDoubleClick() {}
    @Override public void onRightClick() {}
    @Override public void onHover() {}
    @Override public void onDrag() {}
}

// 3. Клиент - переопределяет только нужные методы
class MyMouseHandler extends MouseAdapter {
    @Override
    public void onClick() {
        System.out.println("Клик обработан!");
    }

    @Override
    public void onDoubleClick() {
        System.out.println("Двойной клик!");
    }
}

public class Main {
    public static void main(String[] args) {
        MyMouseHandler handler = new MyMouseHandler();
        handler.onClick();        // Клик обработан!
        handler.onDoubleClick();  // Двойной клик!
        handler.onRightClick();   // ничего не делает
        handler.onHover();        // ничего не делает
    }
}

List<String> list = new ArrayList<>(); // через интерфейс - ГУД
// ArrayList<String> list = new ArrayList<>(); // не есть ГУД

class Dog extends Animal implements Runnable {
    // Сначала extends (класс), потом implements (интерфейсы)
}