【完全ガイド】Javaの継承を理解して設計力を高める！現場で使える7つの実践テクニック

　● テストしやすい継承構造の設計方法がわからない

// 基本的な従業員クラス
public class Employee {
    protected String name;
    protected int employeeId;

    public void work() {
        System.out.println("仕事を行います");
    }
}

// 営業職員クラス（Employeeクラスを継承）
public class SalesEmployee extends Employee {
    private int salesTarget;

    // 親クラスのメソッドを利用しながら、新しい機能を追加
    public void meetCustomer() {
        work();  // 親クラスのメソッドを利用
        System.out.println("顧客との商談を行います");
    }
}

// 図形の基本クラス
public abstract class Shape {
    protected double area;

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

// 円クラス
public class Circle extends Shape {
    private double radius;

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

// 四角形クラス
public class Rectangle extends Shape {
    private double width;
    private double height;

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

// 基本的なロガークラス
public class Logger {
    public void log(String message) {
        System.out.println(message);
    }
}

// タイムスタンプ付きロガー
public class TimestampLogger extends Logger {
    @Override
    public void log(String message) {
        String timestamp = new java.util.Date().toString();
        super.log(timestamp + ": " + message);  // 親クラスのメソッドを拡張
    }
}

// 基本的な継承の例
public class Animal {
    protected String name;

    public void eat() {
        System.out.println(name + "が食事をしています");
    }

    public void sleep() {
        System.out.println(name + "が睡眠をとっています");
    }
}

// Animalクラスを継承した犬クラス
public class Dog extends Animal {
    // コンストラクタ
    public Dog(String name) {
        this.name = name;
    }

    // 独自のメソッドを追加
    public void bark() {
        System.out.println(name + "が吠えています");
    }

    // 親クラスのメソッドをオーバーライド
    @Override
    public void eat() {
        System.out.println(name + "が骨を食べています");
    }
}

// 使用例
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("ポチ");
        dog.eat();    // "ポチが骨を食べています"
        dog.sleep();  // "ポチが睡眠をとっています"
        dog.bark();   // "ポチが吠えています"
    }
}

// 基本クラス
public class Vehicle {
    protected String brand;
    protected int year;

    public void start() {
        System.out.println("エンジンを始動します");
    }

    public void stop() {
        System.out.println("エンジンを停止します");
    }
}

// クラス継承の例
public class Car extends Vehicle {
    private int numberOfDoors;

    public void openTrunk() {
        System.out.println("トランクを開きます");
    }
}

// インターフェースの定義
public interface Drawable {
    void draw();  // 抽象メソッド

    // デフォルトメソッド（Java 8以降）
    default void prepare() {
        System.out.println("描画の準備をします");
    }
}

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

// 複数のインターフェースを実装可能
public class Rectangle implements Drawable, Resizable {
    @Override
    public void draw() {
        System.out.println("四角形を描画します");
    }

    @Override
    public void resize(int factor) {
        System.out.println("サイズを" + factor + "倍に変更します");
    }
}

// 抽象クラスの例
public abstract class DatabaseConnection {
    protected String connectionString;
    protected boolean isConnected;

    // 具象メソッド
    public void disconnect() {
        isConnected = false;
        System.out.println("データベース接続を切断しました");
    }

    // 抽象メソッド
    public abstract void connect();
    public abstract void executeQuery(String query);
}

// 具象クラスでの実装
public class MySQLConnection extends DatabaseConnection {
    @Override
    public void connect() {
        // MySQL固有の接続処理
        isConnected = true;
        System.out.println("MySQLに接続しました");
    }

    @Override
    public void executeQuery(String query) {
        // MySQL固有のクエリ実行処理
        System.out.println("MySQLでクエリを実行: " + query);
    }
}

// 複数のインターフェースとデフォルトメソッド
public interface Printable {
    default void print() {
        System.out.println("文書を印刷します");
    }
}

public interface Scannable {
    default void scan() {
        System.out.println("文書をスキャンします");
    }
}

// 複数のインターフェースを実装
public class MultiFunctionPrinter implements Printable, Scannable {
    // 両方のインターフェースの機能を利用可能
    public void copyDocument() {
        scan();  // Scannableから
        print(); // Printableから
    }
}

public interface A {
    default void process() {
        System.out.println("A's process");
    }
}

public interface B {
    default void process() {
        System.out.println("B's process");
    }
}

// 衝突を解決するには明示的な実装が必要
public class C implements A, B {
    @Override
    public void process() {
        // 特定のインターフェースの実装を選択
        A.super.process();
        // または独自の実装を提供
    }
}

　　● 一部の実装を強制したい

// データ処理の基本クラス
public abstract class DataProcessor {
    // テンプレートメソッド
    public final void processData() {
        readData();        // データ読み込み
        validateData();    // データ検証
        transform();      // データ変換（サブクラスで実装）
        save();          // データ保存（サブクラスで実装）
        notify("処理が完了しました");
    }

    // 共通の実装
    private void readData() {
        System.out.println("データを読み込みます");
    }

    private void validateData() {
        System.out.println("データを検証します");
    }

    // サブクラスで実装が必要なメソッド
    protected abstract void transform();
    protected abstract void save();

    // フック用のデフォルト実装
    protected void notify(String message) {
        System.out.println(message);
    }
}

// CSV処理用の具象クラス
public class CSVProcessor extends DataProcessor {
    @Override
    protected void transform() {
        System.out.println("CSVデータを変換します");
    }

    @Override
    protected void save() {
        System.out.println("変換したデータをCSV形式で保存します");
    }
}

// 支払い戦略のインターフェース
public interface PaymentStrategy {
    void pay(int amount);
}

// クレジットカード支払い
public class CreditCardPayment implements PaymentStrategy {
    private String cardNumber;

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

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

// 電子マネー支払い
public class ElectronicMoneyPayment implements PaymentStrategy {
    private String accountId;

    public ElectronicMoneyPayment(String accountId) {
        this.accountId = accountId;
    }

    @Override
    public void pay(int amount) {
        System.out.println(amount + "円を電子マネー" + accountId + "で支払いました");
    }
}

// 支払い処理クラス
public class PaymentProcessor {
    private PaymentStrategy paymentStrategy;

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

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

// 共通インターフェース
public interface FileSystemComponent {
    void showInfo();
    int getSize();
}

// ファイルクラス（リーフ）
public class File implements FileSystemComponent {
    private String name;
    private int size;

    public File(String name, int size) {
        this.name = name;
        this.size = size;
    }

    @Override
    public void showInfo() {
        System.out.println("File: " + name + " (Size: " + size + "KB)");
    }

    @Override
    public int getSize() {
        return size;
    }
}

// ディレクトリクラス（コンポジット）
public class Directory implements FileSystemComponent {
    private String name;
    private List<FileSystemComponent> components = new ArrayList<>();

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

    public void addComponent(FileSystemComponent component) {
        components.add(component);
    }

    @Override
    public void showInfo() {
        System.out.println("Directory: " + name);
        components.forEach(FileSystemComponent::showInfo);
    }

    @Override
    public int getSize() {
        return components.stream()
                .mapToInt(FileSystemComponent::getSize)
                .sum();
    }
}

// 製品インターフェース
public interface Document {
    void open();
    void save();
}

// 具体的な製品クラス
public class PDFDocument implements Document {
    @Override
    public void open() {
        System.out.println("PDFドキュメントを開きます");
    }

    @Override
    public void save() {
        System.out.println("PDFドキュメントを保存します");
    }
}

public class WordDocument implements Document {
    @Override
    public void open() {
        System.out.println("Wordドキュメントを開きます");
    }

    @Override
    public void save() {
        System.out.println("Wordドキュメントを保存します");
    }
}

// 抽象ファクトリー
public abstract class DocumentCreator {
    // ファクトリーメソッド
    protected abstract Document createDocument();

    // テンプレートメソッド
    public Document openDocument() {
        Document doc = createDocument();
        doc.open();
        return doc;
    }
}

// 具体的なファクトリー
public class PDFDocumentCreator extends DocumentCreator {
    @Override
    protected Document createDocument() {
        return new PDFDocument();
    }
}

// 状態インターフェース
public interface OrderState {
    void nextState(Order order);
    void cancel(Order order);
    String getStatus();
}

// 具体的な状態クラス
public class NewOrderState implements OrderState {
    @Override
    public void nextState(Order order) {
        order.setState(new ProcessingState());
    }

    @Override
    public void cancel(Order order) {
        order.setState(new CancelledState());
    }

    @Override
    public String getStatus() {
        return "注文受付";
    }
}

public class ProcessingState implements OrderState {
    @Override
    public void nextState(Order order) {
        order.setState(new ShippedState());
    }

    @Override
    public void cancel(Order order) {
        System.out.println("処理中の注文はキャンセルできません");
    }

    @Override
    public String getStatus() {
        return "処理中";
    }
}

// コンテキストクラス
public class Order {
    private OrderState state;
    private String orderNumber;

    public Order(String orderNumber) {
        this.orderNumber = orderNumber;
        this.state = new NewOrderState();
    }

    public void setState(OrderState state) {
        this.state = state;
    }

    public void nextState() {
        state.nextState(this);
    }

    public void cancel() {
        state.cancel(this);
    }

    public String getStatus() {
        return state.getStatus();
    }
}

// 基本インターフェース
public interface Notifier {
    void send(String message);
}

// 基本実装
public class BasicNotifier implements Notifier {
    @Override
    public void send(String message) {
        System.out.println("基本通知: " + message);
    }
}

// デコレーター基底クラス
public abstract class NotifierDecorator implements Notifier {
    protected Notifier notifier;

    public NotifierDecorator(Notifier notifier) {
        this.notifier = notifier;
    }

    @Override
    public void send(String message) {
        notifier.send(message);
    }
}

// 具体的なデコレーター
public class SlackNotifier extends NotifierDecorator {
    public SlackNotifier(Notifier notifier) {
        super(notifier);
    }

    @Override
    public void send(String message) {
        super.send(message);
        System.out.println("Slack通知: " + message);
    }
}

public class EmailNotifier extends NotifierDecorator {
    public EmailNotifier(Notifier notifier) {
        super(notifier);
    }

    @Override
    public void send(String message) {
        super.send(message);
        System.out.println("メール通知: " + message);
    }
}

// オブザーバーインターフェース
public interface Observer {
    void update(String event);
}

// サブジェクト（観察対象）インターフェース
public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 具体的なサブジェクト
public class NewsAgency implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String news;

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        observers.forEach(observer -> observer.update(news));
    }

    public void setNews(String news) {
        this.news = news;
        notifyObservers();
    }
}

// 具体的なオブザーバー
public class NewsChannel implements Observer {
    private String name;

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

    @Override
    public void update(String news) {
        System.out.println(name + "が次のニュースを受信: " + news);
    }
}

// 継承が深すぎる例
public class Vehicle { }
public class LandVehicle extends Vehicle { }
public class Car extends LandVehicle { }
public class SportsCar extends Car { }
public class RaceCar extends SportsCar { }
public class FormulaOneCar extends RaceCar { }

// 改善例：継承階層を浅くし、コンポジションを活用
public class Vehicle {
    protected Engine engine;
    protected Transmission transmission;
}

public class Car extends Vehicle {
    private CarType type;
    private PerformanceSpec specs;
}

// LSP違反の例
public class Rectangle {
    protected int width;
    protected int height;

    public void setWidth(int width) {
        this.width = width;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public int getArea() {
        return width * height;
    }
}

public class Square extends Rectangle {
    // 正方形は常に幅と高さが同じであるべきだが...
    @Override
    public void setWidth(int width) {
        super.setWidth(width);
        super.setHeight(width);  // LSP違反！
    }

    @Override
    public void setHeight(int height) {
        super.setWidth(height);
        super.setHeight(height);  // LSP違反！
    }
}

// LSP違反を解消した例
public interface Shape {
    int getArea();
}

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

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

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

public class Square implements Shape {
    private int side;

    public Square(int side) {
        this.side = side;
    }

    @Override
    public int getArea() {
        return side * side;
    }
}

// 継承を使った問題のある実装
public class EmailSender {
    public void send(String message) {
        // メール送信ロジック
    }
}

public class LoggingEmailSender extends EmailSender {
    @Override
    public void send(String message) {
        System.out.println("送信開始: " + message);
        super.send(message);
        System.out.println("送信完了");
    }
}

// コンポジションを使った改善実装
public interface MessageSender {
    void send(String message);
}

public class EmailSender implements MessageSender {
    @Override
    public void send(String message) {
        // メール送信ロジック
    }
}

public class LoggingDecorator implements MessageSender {
    private final MessageSender wrapped;

    public LoggingDecorator(MessageSender wrapped) {
        this.wrapped = wrapped;
    }

    @Override
    public void send(String message) {
        System.out.println("送信開始: " + message);
        wrapped.send(message);
        System.out.println("送信完了");
    }
}

// 使用例
MessageSender sender = new LoggingDecorator(new EmailSender());

// テストが困難な実装
public class DataProcessor {
    private Database database = new Database();  // 強結合

    public void process(Data data) {
        database.save(data);
    }
}

// テスタブルな実装
public class DataProcessor {
    private DatabaseInterface database;  // インターフェースを使用

    // コンストラクタインジェクション
    public DataProcessor(DatabaseInterface database) {
        this.database = database;
    }

    public void process(Data data) {
        database.save(data);
    }
}

// テストコード
public class DataProcessorTest {
    @Test
    public void testProcess() {
        // モックデータベースを使用
        DatabaseInterface mockDb = mock(DatabaseInterface.class);
        DataProcessor processor = new DataProcessor(mockDb);

        Data testData = new Data();
        processor.process(testData);

        verify(mockDb).save(testData);
    }
}

// テスト用のサブクラスを作成
public class TestableBaseClass extends BaseClass {
    // protectedメソッドをテスト用に公開
    public void publicTestMethod() {
        super.protectedMethod();
    }
}

@Test
public void testProtectedMethod() {
    TestableBaseClass testInstance = new TestableBaseClass();
    testInstance.publicTestMethod();
    // アサーションを実行
}

// 良くない例：複数の責任を持つクラス
public class UserManager extends DatabaseConnection {
    public void createUser(User user) {
        connect();
        // ユーザー作成ロジック
        disconnect();
    }

    public void sendEmail(User user) {
        // メール送信ロジック
    }
}

// 改善例：責任を分割
public class UserRepository {
    private DatabaseConnection connection;

    public UserRepository(DatabaseConnection connection) {
        this.connection = connection;
    }

    public void createUser(User user) {
        connection.connect();
        // ユーザー作成ロジック
        connection.disconnect();
    }
}

public class EmailService {
    public void sendEmail(User user) {
        // メール送信ロジック
    }
}

// 大きすぎるインターフェース
public interface UserService {
    User createUser(UserData data);
    void updateUser(User user);
    void deleteUser(User user);
    void sendWelcomeEmail(User user);
    void generateReport(User user);
}

// 分割したインターフェース
public interface UserCrudOperations {
    User createUser(UserData data);
    void updateUser(User user);
    void deleteUser(User user);
}

public interface UserNotificationService {
    void sendWelcomeEmail(User user);
}

public interface UserReportService {
    void generateReport(User user);
}

// 必要なインターフェースのみを実装
public class UserManager implements UserCrudOperations, UserNotificationService {
    // 必要な機能のみを実装
}

// レビュー対象の例
public class ElectronicDevice {
    protected boolean isOn;
    protected int volume;

    public void turnOn() {
        isOn = true;
    }

    public void turnOff() {
        isOn = false;
    }
}

public class Television extends ElectronicDevice {
    private int channel;

    public void changeChannel(int newChannel) {
        if (isOn) {  // 親クラスの状態を適切に使用
            this.channel = newChannel;
        }
    }
}

## 継承設計レビューチェックリスト

### 基本設計
- [ ] 継承の深さは3階層以内に収まっているか
- [ ] インターフェースを適切に使用しているか
- [ ] 抽象クラスの使用は適切か

### コードの品質
- [ ] DRY原則は守られているか
- [ ] メソッドの可視性は適切か
- [ ] 命名は意図を適切に表現しているか

### テスタビリティ
- [ ] ユニットテストは書きやすい設計か
- [ ] モック/スタブの作成は容易か
- [ ] テストシナリオは網羅的か

### メンテナンス性
- [ ] 将来の拡張性は確保されているか
- [ ] ドキュメントは十分か
- [ ] 技術的負債の蓄積はないか

　　● 初期化コスト

// 基本的なジェネリック継承
public abstract class BaseRepository<T> {
    protected List<T> items = new ArrayList<>();

    public void add(T item) {
        items.add(item);
    }

    public List<T> findAll() {
        return new ArrayList<>(items);
    }

    // サブクラスで実装する抽象メソッド
    protected abstract boolean matches(T item, String criteria);

    public List<T> findByCriteria(String criteria) {
        return items.stream()
            .filter(item -> matches(item, criteria))
            .collect(Collectors.toList());
    }
}

// 具体的な実装例
public class UserRepository extends BaseRepository<User> {
    @Override
    protected boolean matches(User user, String criteria) {
        return user.getName().contains(criteria) ||
               user.getEmail().contains(criteria);
    }
}

// 境界型パラメータを使用した例
public abstract class ComparableRepository<T extends Comparable<T>> {
    protected List<T> items = new ArrayList<>();

    public void addSorted(T item) {
        items.add(item);
        Collections.sort(items);
    }

    public T findMax() {
        return Collections.max(items);
    }
}

// カスタムアノテーションの定義
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface EntityTable {
    String name();
    String schema() default "public";
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Cacheable {
    int timeToLiveSeconds() default 300;
}

// アノテーションを使用した基底クラス
public abstract class BaseEntity {
    @Id
    protected Long id;

    protected LocalDateTime createdAt;
    protected LocalDateTime updatedAt;

    @PrePersist
    protected void onCreate() {
        createdAt = LocalDateTime.now();
        updatedAt = LocalDateTime.now();
    }

    @PreUpdate
    protected void onUpdate() {
        updatedAt = LocalDateTime.now();
    }
}

// アノテーションを活用した実装例
@EntityTable(name = "users", schema = "app")
public class User extends BaseEntity {
    private String name;
    private String email;

    @Cacheable(timeToLiveSeconds = 600)
    public String getDisplayName() {
        return name + " <" + email + ">";
    }
}

// アノテーション処理の実装
public class EntityProcessor {
    public String getTableName(Class<?> entityClass) {
        EntityTable annotation = entityClass.getAnnotation(EntityTable.class);
        if (annotation != null) {
            return annotation.schema() + "." + annotation.name();
        }
        throw new IllegalArgumentException("Entity must be annotated with @EntityTable");
    }
}

// 共通のコントローラー機能を提供する基底クラス
@Slf4j
public abstract class BaseController<T, ID> {
    @Autowired
    protected JpaRepository<T, ID> repository;

    @GetMapping
    public ResponseEntity<List<T>> findAll() {
        try {
            List<T> items = repository.findAll();
            return ResponseEntity.ok(items);
        } catch (Exception e) {
            log.error("Error fetching items", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    @GetMapping("/{id}")
    public ResponseEntity<T> findById(@PathVariable ID id) {
        return repository.findById(id)
            .map(ResponseEntity::ok)
            .orElse(ResponseEntity.notFound().build());
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteById(@PathVariable ID id) {
        if (repository.existsById(id)) {
            repository.deleteById(id);
            return ResponseEntity.noContent().build();
        }
        return ResponseEntity.notFound().build();
    }
}

// 具体的なコントローラーの実装
@RestController
@RequestMapping("/api/users")
public class UserController extends BaseController<User, Long> {
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody @Valid User user) {
        User savedUser = repository.save(user);
        return ResponseEntity
            .created(URI.create("/api/users/" + savedUser.getId()))
            .body(savedUser);
    }

    @GetMapping("/search")
    public ResponseEntity<List<User>> searchByEmail(@RequestParam String email) {
        List<User> users = ((UserRepository) repository).findByEmailContaining(email);
        return ResponseEntity.ok(users);
    }
}

// サービス層での継承活用例
@Service
@Transactional
public abstract class BaseService<T, ID> {
    @Autowired
    protected JpaRepository<T, ID> repository;

    @Cacheable(value = "entities", key = "#id")
    public Optional<T> findById(ID id) {
        return repository.findById(id);
    }

    @CachePut(value = "entities", key = "#result.id")
    public T save(T entity) {
        return repository.save(entity);
    }

    @CacheEvict(value = "entities", key = "#id")
    public void deleteById(ID id) {
        repository.deleteById(id);
    }
}

// 具体的なサービスの実装
@Service
public class UserService extends BaseService<User, Long> {
    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public User save(User user) {
        user.setPassword(passwordEncoder.encode(user.getPassword()));
        return super.save(user);
    }
}

　● Java言語仕様