Javaインターフェースの基礎から応用まで：7つの実践的な使い方と設計のコツ

public interface Drawable {
    void draw();
}

public class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("円を描画");
    }
}

public class Square implements Drawable {
    @Override
    public void draw() {
        System.out.println("四角を描画");
    }
}

Drawable shape1 = new Circle();
Drawable shape2 = new Square();
shape1.draw(); // 出力: 円を描画
shape2.draw(); // 出力: 四角を描画

public interface Drawable {
    void draw();  // 抽象メソッド（自動的に public abstract）
    Color getColor();  // 別の抽象メソッド

    int MAX_SIZE = 100;  // 定数（自動的に public static final）
}

public class Circle implements Drawable {
    private Color color;

    @Override
    public void draw() {
        System.out.println("円を描画します");
    }

    @Override
    public Color getColor() {
        return this.color;
    }
}

public interface Drawable {
    void draw();

    default void printInfo() {
        System.out.println("これは描画可能なオブジェクトです");
    }

    static Drawable createDefault() {
        return new DefaultDrawable();
    }
}

public class DrawingApp {
    private Drawable shape;

    public DrawingApp(Drawable shape) {
        this.shape = shape;
    }

    public void drawShape() {
        shape.draw();
    }
}

// インターフェース
public interface Drawable {
    void draw();  // 抽象メソッド
    default void printInfo() {  // デフォルトメソッド
        System.out.println("This is a drawable object");
    }
}

// 抽象クラス
public abstract class Shape {
    protected String color;

    public Shape(String color) {
        this.color = color;
    }

    public abstract double getArea();  // 抽象メソッド

    public void displayColor() {  // 具象メソッド
        System.out.println("Color: " + color);
    }
}

// インターフェースの適切な使用例
public interface Sortable {
    int compareTo(Sortable other);
}

public class Student implements Sortable {
    private String name;
    private int score;

    // コンストラクタ、getterなどは省略

    @Override
    public int compareTo(Sortable other) {
        if (other instanceof Student) {
            return Integer.compare(this.score, ((Student) other).score);
        }
        return 0;
    }
}

// 抽象クラスの適切な使用例
public abstract class Animal {
    protected String name;

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

    public abstract void makeSound();

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

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

    @Override
    public void makeSound() {
        System.out.println(name + " barks: Woof!");
    }
}

public interface Drawable {
    void draw();
}

public abstract class Shape implements Drawable {
    protected String color;

    public Shape(String color) {
        this.color = color;
    }

    // Drawableインターフェースのデフォルト実装
    @Override
    public void draw() {
        System.out.println("Drawing a " + color + " shape.");
    }

    // 抽象メソッド
    public abstract double getArea();
}

public class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

// ストラテジーインターフェース
public interface SortStrategy {
    void sort(int[] array);
}

// 具体的なストラテジークラス
public class BubbleSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        // バブルソートの実装
    }
}

public class QuickSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        // クイックソートの実装
    }
}

// コンテキストクラス
public class Sorter {
    private SortStrategy strategy;

    public void setStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }

    public void performSort(int[] array) {
        strategy.sort(array);
    }
}

// 使用例
Sorter sorter = new Sorter();
sorter.setStrategy(new BubbleSort());
sorter.performSort(array);  // バブルソートを実行

sorter.setStrategy(new QuickSort());
sorter.performSort(array);  // クイックソートを実行

// コールバックインターフェース
@FunctionalInterface
public interface Callback {
    void onComplete(String result);
}

// 非同期処理を行うクラス
public class AsyncProcessor {
    public void processAsync(String input, Callback callback) {
        new Thread(() -> {
            // 非同期処理
            String result = input.toUpperCase();
            // 処理完了後、コールバックを呼び出す
            callback.onComplete(result);
        }).start();
    }
}

// 使用例
AsyncProcessor processor = new AsyncProcessor();
processor.processAsync("hello", result -> {
    System.out.println("処理結果: " + result);
});

// 共通インターフェース
public interface Shape {
    double getArea();
    void draw();
}

// 具体的な実装
public class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }

    @Override
    public void draw() {
        System.out.println("円を描画");
    }
}

public class Rectangle implements Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double getArea() {
        return width * height;
    }

    @Override
    public void draw() {
        System.out.println("四角形を描画");
    }
}

// 使用例
public class ShapeProcessor {
    public void processShape(Shape shape) {
        System.out.println("面積: " + shape.getArea());
        shape.draw();
    }
}

ShapeProcessor processor = new ShapeProcessor();
processor.processShape(new Circle(5));
processor.processShape(new Rectangle(4, 6));

// データアクセスインターフェース
public interface UserRepository {
    User findById(int id);
    void save(User user);
}

// 具体的な実装
public class MySQLUserRepository implements UserRepository {
    @Override
    public User findById(int id) {
        // MySQLからユーザーを検索する実装
    }

    @Override
    public void save(User user) {
        // MySQLにユーザーを保存する実装
    }
}

// サービスクラス
public class UserService {
    private UserRepository userRepository;

    // コンストラクタインジェクション
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User getUser(int id) {
        return userRepository.findById(id);
    }

    public void registerUser(User user) {
        userRepository.save(user);
    }
}

// 使用例
UserRepository repository = new MySQLUserRepository();
UserService service = new UserService(repository);
User user = service.getUser(1);

// イベントリスナーインターフェース
public interface ButtonClickListener {
    void onClick(String buttonName);
}

// ボタンクラス
public class Button {
    private String name;
    private ButtonClickListener listener;

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

    public void setClickListener(ButtonClickListener listener) {
        this.listener = listener;
    }

    public void click() {
        if (listener != null) {
            listener.onClick(name);
        }
    }
}

// 使用例
Button button = new Button("送信");
button.setClickListener(buttonName -> {
    System.out.println(buttonName + "ボタンがクリックされました");
    // 送信処理を実行
});

button.click();  // "送信ボタンがクリックされました" と表示され、送信処理が実行される

public interface List<E> extends Collection<E> {
    default void sort(Comparator<? super E> c) {
        Collections.sort(this, c);
    }
    // その他のメソッド...
}

public interface A {
    default void hello() {
        System.out.println("Hello from A");
    }
}

public interface B {
    default void hello() {
        System.out.println("Hello from B");
    }
}

public class C implements A, B {
    @Override
    public void hello() {
        A.super.hello(); // Aのデフォルトメソッドを呼び出す
    }
}

public interface Comparator<T> {
    int compare(T o1, T o2);

    static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor) {
        return (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }
    // その他のメソッド...
}

public interface Logger {
    void log(String message);

    static Logger getFileLogger(String fileName) {
        // ファイルロガーの実装を返す
    }

    static Logger getConsoleLogger() {
        // コンソールロガーの実装を返す
    }

    default void logInfo(String message) {
        log("INFO: " + message);
    }

    default void logError(String message) {
        log("ERROR: " + message);
    }
}

// 良くない例：1つの大きなインターフェース
public interface Worker {
    void work();
    void eat();
    void sleep();
}

// 良い例：機能ごとに分割されたインターフェース
public interface Workable {
    void work();
}

public interface Eatable {
    void eat();
}

public interface Sleepable {
    void sleep();
}

// 必要な機能だけを実装
public class HumanWorker implements Workable, Eatable, Sleepable {
    // 実装
}

public class RobotWorker implements Workable {
    // 実装（eat()とsleep()は不要）
}

// 良くない例：直接具象クラスに依存
public class OrderProcessor {
    private MySQLDatabase database;

    public OrderProcessor() {
        this.database = new MySQLDatabase();
    }

    public void processOrder(Order order) {
        database.save(order);
    }
}

// 良い例：インターフェースに依存
public interface Database {
    void save(Order order);
}

public class OrderProcessor {
    private Database database;

    public OrderProcessor(Database database) {
        this.database = database;
    }

    public void processOrder(Order order) {
        database.save(order);
    }
}

単一責任の原則を守る：インターフェースは一つの責任のみを持つべきです。これにより、インターフェースの目的が明確になり、変更の影響範囲を最小限に抑えられます。
適切な命名：インターフェース名には通常、形容詞や能力を表す名詞を使用します（例：Comparable, Runnable, Serializable）。
適切な粒度を選択：インターフェースは必要以上に細かく分割せず、関連する操作をまとめるべきです。ただし、ISPに反しないよう注意が必要です。
デフォルトメソッドの活用：Java 8以降では、デフォルトメソッドを使って既存のインターフェースに新しい機能を追加できます。ただし、既存の実装に影響を与えないよう慎重に設計する必要があります。

public interface Logger {
    void log(String message);

    default void logInfo(String message) {
        log("INFO: " + message);
    }

    default void logError(String message) {
        log("ERROR: " + message);
    }
}

静的メソッドの活用：ユーティリティメソッドやファクトリーメソッドを提供するのに適しています。

public interface ShapeFactory {
    static Shape createCircle(double radius) {
        return new Circle(radius);
    }

    static Shape createRectangle(double width, double height) {
        return new Rectangle(width, height);
    }
}

バージョニングの考慮：新しいメソッドを追加する際は、既存のクライアントに影響を与えないようデフォルトメソッドを使用するか、新しいインターフェースを作成することを検討します。
テスト容易性の向上：インターフェースを使用することで、モックオブジェクトの作成が容易になり、ユニットテストの品質が向上します。

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

// ラムダ式の使用例
Predicate<String> isLongString = s -> s.length() > 10;
System.out.println(isLongString.test("Hello, World!")); // true

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println("Hello, " + name));

List<Integer> lengths = names.stream()
    .map(String::length)
    .collect(Collectors.toList());

public interface Serializable {}

public class User implements Serializable {
    private String name;
    private int age;
    // ...
}

public interface Auditable {}

public class AuditingAspect {
    @Before("execution(* *(..)) && this(Auditable)")
    public void audit(JoinPoint joinPoint) {
        // 監査ログを記録
    }
}

interface DrawAPI {
    void drawCircle(int x, int y, int radius);
}

abstract class Shape {
    protected DrawAPI drawAPI;
    protected Shape(DrawAPI drawAPI) {
        this.drawAPI = drawAPI;
    }
    public abstract void draw();
}

class Circle extends Shape {
    private int x, y, radius;
    public Circle(int x, int y, int radius, DrawAPI drawAPI) {
        super(drawAPI);
        this.x = x; this.y = y; this.radius = radius;
    }
    public void draw() {
        drawAPI.drawCircle(x, y, radius);
    }
}

Proxyパターン：オブジェクトへのアクセスを制御します。

interface Image {
    void display();
}

class RealImage implements Image {
    private String fileName;
    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk();
    }
    private void loadFromDisk() {
        System.out.println("Loading " + fileName);
    }
    public void display() {
        System.out.println("Displaying " + fileName);
    }
}

class ProxyImage implements Image {
    private RealImage realImage;
    private String fileName;
    public ProxyImage(String fileName) {
        this.fileName = fileName;
    }
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName);
        }
        realImage.display();
    }
}

public interface Comparable<T> {
    int compareTo(T other);
}

public class Box<T extends Comparable<T>> {
    private T content;
    public void setContent(T content) {
        this.content = content;
    }
    public boolean isContentGreaterThan(Box<T> other) {
        return this.content.compareTo(other.content) > 0;
    }
}

public interface Plugin {
    void execute();
}

public class PluginManager {
    private List<Plugin> plugins = new ArrayList<>();
    public void registerPlugin(Plugin plugin) {
        plugins.add(plugin);
    }
    public void executePlugins() {
        for (Plugin plugin : plugins) {
            plugin.execute();
        }
    }
}

// テストコード
@Test
public void testPluginExecution() {
    PluginManager manager = new PluginManager();
    Plugin mockPlugin = mock(Plugin.class);
    manager.registerPlugin(mockPlugin);
    manager.executePlugins();
    verify(mockPlugin).execute();
}