【完全解説】Java interfaceの使い方マスター講座：基礎から応用まで7つのステップ

public interface Animal {
    void makeSound();
    void move();
}

public interface Seatable {
    void sit();
    void standUp();
}

public interface InterfaceName {
    // 抽象メソッドの宣言
    returnType methodName(parameters);

    // 定数の宣言（必要な場合）
    public static final dataType CONSTANT_NAME = value;
}

public class ClassName implements InterfaceName {
    // interfaceで宣言された全ての抽象メソッドを実装する
    @Override
    public returnType methodName(parameters) {
        // メソッドの具体的な実装
    }
}

// インターフェースの宣言
public interface Drawable {
    void draw();
}

// インターフェースの実装
public class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("円を描画します");
    }
}

public interface Colorable {
    void setColor(String color);
}

public class ColorfulCircle implements Drawable, Colorable {
    private String color;

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

    @Override
    public void setColor(String color) {
        this.color = color;
    }
}

public interface Calculator {
    double add(double a, double b);
    double subtract(double a, double b);
    double multiply(double a, double b);
    double divide(double a, double b);
}

public class BasicCalculator implements Calculator {
    @Override
    public double add(double a, double b) {
        return a + b;
    }

    @Override
    public double subtract(double a, double b) {
        return a - b;
    }

    @Override
    public double multiply(double a, double b) {
        return a * b;
    }

    @Override
    public double divide(double a, double b) {
        if (b == 0) {
            throw new ArithmeticException("除算の分母に0は使用できません");
        }
        return a / b;
    }
}

public interface AdvancedCalculator {
    double sqrt(double a);
    double power(double base, double exponent);
}

public class ScientificCalculator implements Calculator, AdvancedCalculator {
    // Calculatorインターフェースのメソッドを実装
    // (BasicCalculatorと同じ実装なので省略)

    @Override
    public double sqrt(double a) {
        if (a < 0) {
            throw new IllegalArgumentException("負の数の平方根は実数では定義されていません");
        }
        return Math.sqrt(a);
    }

    @Override
    public double power(double base, double exponent) {
        return Math.pow(base, exponent);
    }
}

public class Person implements Comparable<Person>, Cloneable {
    private String name;
    private int age;

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

    @Override
    public int compareTo(Person other) {
        return this.age - other.age;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }

    // getterとsetterは省略
}

Comparableインターフェースの実装により、Personオブジェクトを年齢順にソートすることができます。
Cloneableインターフェースの実装により、Personオブジェクトの複製が可能になります。

public interface DatabaseConnection {
    void connect(String url, String username, String password);
    void disconnect();
    ResultSet executeQuery(String query);
    int executeUpdate(String query);
}

public interface Logger {
    void log(String message);
    void logError(String message, Exception e);
}

public interface MyInterface {
    default void newMethod() {
        System.out.println("This is a default method");
    }
}

public interface Iterable<T> {
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
    // 他のメソッド...
}

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

public interface MyInterface {
    static void staticMethod() {
        System.out.println("This is a static method");
    }
}

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

List<Person> people = Arrays.asList(
    new Person("Alice", 30),
    new Person("Bob", 25),
    new Person("Charlie", 35)
);

people.sort(Comparator.comparing(Person::getAge));

public interface PaymentStrategy {
    void pay(int amount);
}

public class CreditCardPayment implements PaymentStrategy {
    private String name;
    private String cardNumber;

    public CreditCardPayment(String name, String cardNumber) {
        this.name = name;
        this.cardNumber = cardNumber;
    }

    @Override
    public void pay(int amount) {
        System.out.println(amount + "円をクレジットカードで支払いました。");
    }
}

public class PayPalPayment implements PaymentStrategy {
    private String email;

    public PayPalPayment(String email) {
        this.email = email;
    }

    @Override
    public void pay(int amount) {
        System.out.println(amount + "円をPayPalで支払いました。");
    }
}

public class BankTransferPayment implements PaymentStrategy {
    private String bankAccount;

    public BankTransferPayment(String bankAccount) {
        this.bankAccount = bankAccount;
    }

    @Override
    public void pay(int amount) {
        System.out.println(amount + "円を銀行振込で支払いました。");
    }
}

public class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(int amount) {
        paymentStrategy.pay(amount);
    }
}

public class Main {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();

        // クレジットカードでの支払い
        cart.setPaymentStrategy(new CreditCardPayment("John Doe", "1234-5678-9012-3456"));
        cart.checkout(10000);

        // PayPalでの支払い
        cart.setPaymentStrategy(new PayPalPayment("john.doe@example.com"));
        cart.checkout(5000);

        // 銀行振込での支払い
        cart.setPaymentStrategy(new BankTransferPayment("JP12345678"));
        cart.checkout(15000);
    }
}

Strategy patternの利点と注意点

public interface MessageService {
    String getMessage();
}

public class EmailService implements MessageService {
    @Override
    public String getMessage() {
        return "This is an email message.";
    }
}

public class SMSService implements MessageService {
    @Override
    public String getMessage() {
        return "This is an SMS message.";
    }
}

public class NotificationService {
    private MessageService messageService;

    // コンストラクタインジェクション
    public NotificationService(MessageService messageService) {
        this.messageService = messageService;
    }

    public void sendNotification() {
        System.out.println(messageService.getMessage());
    }
}

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import static org.mockito.Mockito.*;

public class NotificationServiceTest {

    @Test
    public void testSendNotification() {
        // モックオブジェクトの作成
        MessageService mockMessageService = mock(MessageService.class);
        when(mockMessageService.getMessage()).thenReturn("Test message");

        // テスト対象のオブジェクトにモックを注入
        NotificationService notificationService = new NotificationService(mockMessageService);

        // メソッドの実行
        notificationService.sendNotification();

        // モックオブジェクトのメソッドが呼ばれたことを確認
        verify(mockMessageService).getMessage();
    }
}

public interface PaymentProcessor {
    void processPayment(double amount);
}

public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        // クレジットカード決済の処理
    }
}

public class PayPalProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        // PayPal決済の処理
    }
}

// 過剰に細分化されたinterface
public interface Logger {
    void log(String message);
}

// 単一の実装しか存在しない
public class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println(message);
    }
}

Java interfaceのマスターは、より柔軟で保守性の高いコードを書くための重要なステップです。この記事で学んだ知識を基に、実践を重ね、よりクリーンで効率的なJavaプログラムを作成する能力を磨いていってください。interfaceの適切な使用は、あなたのプログラミングスキルを次のレベルへと引き上げるでしょう。