Java extendsマスター講座：継承の基礎から応用まで完全解説【2024年最新版】

class 子クラス名 extends 親クラス名 {
    // 子クラスの内容
}

public class Animal {
    protected String name;

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

public class Dog extends Animal {
    public void bark() {
        System.out.println(name + " is barking.");
    }
}

public class Animal {
    protected String name;
    protected int age;

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

    public void makeSound() {
        System.out.println("The animal makes a sound");
    }
}

public class Dog extends Animal {
    private String breed;

    public Dog(String name, int age, String breed) {
        super(name, age);
        this.breed = breed;
    }

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

    public void fetch() {
        System.out.println(name + " is fetching the ball");
    }
}

// 深い継承階層を避ける例
interface Vehicle {
    void move();
}

class Car implements Vehicle {
    @Override
    public void move() {
        System.out.println("Car is moving on the road");
    }
}

class Bicycle implements Vehicle {
    @Override
    public void move() {
        System.out.println("Bicycle is pedaling");
    }
}

// コンポジションの例
class Engine {
    void start() {
        System.out.println("Engine started");
    }
}

class Car {
    private Engine engine; // コンポジション

    public Car() {
        this.engine = new Engine();
    }

    void start() {
        engine.start();
        System.out.println("Car is ready to go");
    }
}

final class ImmutableClass {
    // この例は継承できません
}

class BaseClass {
    final void finalMethod() {
        // このメソッドはオーバーライドできません
    }
}

interface Swimmable {
    void swim();
}

class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

class Fish extends Animal implements Swimmable {
    @Override
    public void swim() {
        System.out.println("Fish is swimming");
    }
}

abstract class BeverageMaker {
    // テンプレートメソッド
    final void prepareBeverage() {
        boilWater();
        brew();
        pourInCup();
        if (customerWantsCondiments()) {
            addCondiments();
        }
    }

    abstract void brew();
    abstract void addCondiments();

    void boilWater() {
        System.out.println("Boiling water");
    }

    void pourInCup() {
        System.out.println("Pouring into cup");
    }

    boolean customerWantsCondiments() {
        return true;
    }
}

class CoffeeMaker extends BeverageMaker {
    @Override
    void brew() {
        System.out.println("Dripping coffee through filter");
    }

    @Override
    void addCondiments() {
        System.out.println("Adding sugar and milk");
    }
}

interface Flyable {
    default void fly() {
        System.out.println("Flying");
    }
}

interface Swimmable {
    default void swim() {
        System.out.println("Swimming");
    }
}

class Duck implements Flyable, Swimmable {
    // flyメソッドとswimメソッドを両方継承
}

interface A {
    default void doSomething() {
        System.out.println("Doing something in A");
    }
}

interface B {
    default void doSomething() {
        System.out.println("Doing something in B");
    }
}

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

public class CustomJdbcTemplate extends JdbcTemplate {
    @Override
    public <T> T query(String sql, ResultSetExtractor<T> rse) throws DataAccessException {
        // カスタムロギングやエラーハンドリングを追加
        try {
            return super.query(sql, rse);
        } catch (DataAccessException e) {
            log.error("Query execution failed: " + sql, e);
            throw e;
        }
    }
}

public abstract class BaseDAOTest {
    protected DataSource dataSource;

    @Before
    public void setUp() throws Exception {
        // データソースのセットアップ
        dataSource = new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .addScript("schema.sql")
            .addScript("test-data.sql")
            .build();
    }

    @After
    public void tearDown() throws Exception {
        // リソースのクリーンアップ
    }
}

public class UserDAOTest extends BaseDAOTest {
    private UserDAO userDAO;

    @Before
    public void setUp() throws Exception {
        super.setUp();
        userDAO = new UserDAO(dataSource);
    }

    @Test
    public void testFindUserById() {
        // テストコード
    }
}

class Vehicle { /* ... */ }
class Car extends Vehicle { /* ... */ }
class SportsCar extends Car { /* ... */ }
class RaceCar extends SportsCar { /* ... */ }

interface Vehicle { /* ... */ }
class BasicVehicle implements Vehicle { /* ... */ }
class Car implements Vehicle {
    private BasicVehicle vehicle;
    // 委譲を使用
}
class SportsCar implements Vehicle {
    private Car car;
    // 委譲を使用
}

class Square extends Rectangle {
    @Override
    public void setWidth(int width) {
        super.setWidth(width);
        super.setHeight(width);
    }

    @Override
    public void setHeight(int height) {
        super.setHeight(height);
        super.setWidth(height);
    }
}

コンポジションの使用
インターフェースの活用
継承の深さを制限する
LSP（リスコフの置換原則）の遵守

interface Shape {
    double area();
}

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

    // コンストラクタ、getterとsetter

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

class Square implements Shape {
    private double side;

    // コンストラクタ、getterとsetter

    @Override
    public double area() {
        return side * side;
    }
}

public sealed class Shape permits Circle, Rectangle, Square {
    // Shapeクラスの実装
}

public final class Circle extends Shape {
    // Circleクラスの実装
}

public non-sealed class Rectangle extends Shape {
    // Rectangleクラスの実装
}

public sealed class Square extends Shape permits ColoredSquare {
    // Squareクラスの実装
}

public final class ColoredSquare extends Square {
    // ColoredSquareクラスの実装
}

Shape shape = getShape();
if (shape instanceof Rectangle r && r.width() > 100) {
    System.out.println("幅の広い長方形です: " + r.width());
} else if (shape instanceof Circle c) {
    System.out.println("円の半径: " + c.radius());
}

double area = switch (shape) {
    case Rectangle r -> r.width() * r.height();
    case Circle c -> Math.PI * c.radius() * c.radius();
    case Triangle t -> t.base() * t.height() / 2;
    default -> throw new IllegalArgumentException("Unknown shape");
};

継承の制御と安全性の強化
コンポジションとインターフェースの重要性の増加
関数型プログラミングとの融合

バリュークラス（値型）：プリミティブ型のようなパフォーマンスと参照型のような柔軟性を兼ね備えたクラス
パターンマッチングのさらなる拡張：より複雑な条件や構造に対応したマッチング
多重継承の部分的サポート：インターフェースのデフォルトメソッドを拡張した形での多重継承（議論段階）

Javaの継承メカニズムは、オブジェクト指向プログラミングの中核をなす重要な概念です。今後も、より表現力豊かで安全な継承の仕組みが導入されることで、大規模で保守性の高いJavaアプリケーションの開発がさらに容易になることが期待されます。開発者は、これらの新機能を適切に活用することで、より堅牢で柔軟なコードを書くことができるでしょう。