/** * ドメイン非依存URL出力フィルタ * javadrill.tech移行時はwp_options.home/siteurlのみ変更すればよい * * データベースには絶対URL（https://minner.asia）を保持し、 * 表示時に現在のドメイン（home_url()）に動的変換する */ function javadrill_make_urls_dynamic($content) { if (empty($content)) { return $content; } // データベース内の絶対URLを現在のhome_url()に置換 $old_url = 'https://minner.asia'; $new_url = untrailingslashit(home_url()); // http版も対応（念のため） $content = str_replace($old_url, $new_url, $content); $content = str_replace('http://minner.asia', $new_url, $content); return $content; } // 投稿本文、ウィジェット、タームの説明、抜粋に適用 add_filter('the_content', 'javadrill_make_urls_dynamic', 20); add_filter('widget_text', 'javadrill_make_urls_dynamic', 20); add_filter('term_description', 'javadrill_make_urls_dynamic', 20); add_filter('get_the_excerpt', 'javadrill_make_urls_dynamic', 20); 解答例 | Javaドリル https://minner.asia 楽々学べるJavaの問題集 Fri, 05 Sep 2025 02:08:01 +0000 ja hourly 1 https://wordpress.org/?v=6.8.3 https://minner.asia/wp-content/uploads/2023/10/cropped-logo-32x32.png 解答例 | Javaドリル https://minner.asia 32 32 016 抽象クラス（ポリモーフィズムと抽象クラス） 013 解答例 https://minner.asia/archives/3695 https://minner.asia/archives/3695#respond Tue, 12 Dec 2023 22:07:21 +0000 http://localhost/?p=3695 
// 抽象クラス Employee
abstract class Employee {
    // 抽象メソッド calculateSalary を宣言
    public abstract double calculateSalary();
}

// 具象クラス Manager
class Manager extends Employee {
    private double baseSalary;
    private double bonus;

    // コンストラクタ
    public Manager(double baseSalary, double bonus) {
        this.baseSalary = baseSalary;
        this.bonus = bonus;
    }

    // calculateSalary メソッドの実装
    @Override
    public double calculateSalary() {
        return baseSalary + bonus;
    }
}

// 具象クラス Developer
class Developer extends Employee {
    private double hourlyRate;
    private int hoursWorked;

    // コンストラクタ
    public Developer(double hourlyRate, int hoursWorked) {
        this.hourlyRate = hourlyRate;
        this.hoursWorked = hoursWorked;
    }

    // calculateSalary メソッドの実装
    @Override
    public double calculateSalary() {
        return hourlyRate * hoursWorked;
    }
}

// メインクラス
public class Main {
    public static void main(String[] args) {
        // Employee 型の配列を作成
        Employee[] employees = new Employee[2];

        // Manager インスタンスを配列に格納
        employees[0] = new Manager(50000, 10000);

        // Developer インスタンスを配列に格納
        employees[1] = new Developer(25, 160);

        // ポリモーフィズムを使用して異なる従業員の給与を表示
        for (Employee employee : employees) {
            System.out.println("Employee's Salary: $" + employee.calculateSalary());
        }
    }
}

このコードでは、Employee クラスが抽象メソッド calculateSalary を宣言し、Manager と Developer クラスがそれをオーバーライドしています。そして、Employee 型のリストに Manager と Developer のインスタンスを格納し、ポリモーフィズムを使用して給与を表示しています。

出力結果：

Employee's Salary: $60000.0
Employee's Salary: $4000.0

ここで、Manager クラスのインスタンスの給与は基本給（baseSalary）とボーナス（bonus）の合計であり、Developer クラスのインスタンスの給与は時給（hourlyRate）と働いた時間（hoursWorked）の積です。

「016 抽象クラス」問題集リスト

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/3695/feed 0 016 抽象クラス（ポリモーフィズムと抽象クラス） 012 解答例 https://minner.asia/archives/3689 https://minner.asia/archives/3689#respond Tue, 12 Dec 2023 12:36:01 +0000 http://localhost/?p=3689 
import java.util.ArrayList;
import java.util.List;

// 抽象クラス Shape
abstract class Shape {
    // 抽象メソッド calculateArea を宣言
    public abstract double calculateArea();
}

// 具象クラス Circle
class Circle extends Shape {
    private double radius;

    // コンストラクタ
    public Circle(double radius) {
        this.radius = radius;
    }

    // calculateArea メソッドのオーバーライド
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

// 具象クラス Rectangle
class Rectangle extends Shape {
    private double length;
    private double width;

    // コンストラクタ
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    // calculateArea メソッドのオーバーライド
    @Override
    public double calculateArea() {
        return length * width;
    }
}

// メインクラス
public class Main {
    public static void main(String[] args) {
        // Shape 型のリストを作成
        List<Shape> shapes = new ArrayList<>();

        // Circle インスタンスをリストに追加
        shapes.add(new Circle(5.0));

        // Rectangle インスタンスをリストに追加
        shapes.add(new Rectangle(4.0, 6.0));

        // ポリモーフィズムを使用して異なる形状の面積を計算して表示
        for (Shape shape : shapes) {
            System.out.println("Area: " + shape.calculateArea());
        }
    }
}

このコードでは、抽象クラス Shape を定義し、具象クラス Circle と Rectangle がそれを拡張しています。各具象クラスでは calculateArea メソッドをオーバーライドし、ポリモーフィズムを使用してShape 型のリストに異なる形状のインスタンスを追加しています。そして、リスト内の各形状の面積を計算して表示しています。

実行結果：

Area: 78.53981633974483
Area: 24.0

これは、Shape 型のリストに含まれる各要素（Circle および Rectangle）の calculateArea メソッドが正しく呼び出され、それぞれの面積が計算されて表示されていることを示しています。

「016 抽象クラス」問題集リスト

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/3689/feed 0 016 抽象クラス（ポリモーフィズムと抽象クラス） 012 問題 https://minner.asia/archives/3685 https://minner.asia/archives/3685#respond Mon, 11 Dec 2023 23:28:42 +0000 http://localhost/?p=3685
  1. 問題
  2. ヒント
    1. 🎯 実習で理解を深めよう

問題

抽象クラス Shape を定義し、calculateArea という抽象メソッドを宣言します。
具象クラス Circle と Rectangle を作成し、Shape を拡張します。
Circle と Rectangle はそれぞれ calculateArea メソッドをオーバーライドして、円と長方形の面積を計算します。
ポリモーフィズムを使用して、Shape 型のリストを作成し、異なる形状の面積を計算して表示します。

ヒント

  1. Shape クラスを定義し、その中に calculateArea という抽象メソッドを宣言します。
  2. 具象クラス Circle と Rectangle を作成し、それぞれ Shape を拡張します。Circle と Rectangle では calculateArea メソッドをオーバーライドして、円と長方形の面積を計算します。
  3. Shape 型のリストを作成し、異なる形状のインスタンスを格納します。
  4. 拡張forループを使用して、各形状の面積を計算して表示します。

→解答例

「016 抽象クラス」問題集リスト

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/3685/feed 0 016 抽象クラス（ポリモーフィズムと抽象クラス） 011 解答例 https://minner.asia/archives/3679 https://minner.asia/archives/3679#respond Mon, 11 Dec 2023 23:26:04 +0000 http://localhost/?p=3679 
// 抽象クラス Animal
abstract class Animal {
    public abstract void makeSound();
}

// 具象クラス Dog
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof! Woof!");
    }
}

// 具象クラス Cat
class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow! Meow!");
    }
}

// メインクラス
public class Main {
    public static void main(String[] args) {
        // Animal 型の配列を作成
        Animal[] animals = new Animal[2];

        // Dog インスタンスを配列に格納
        animals[0] = new Dog();

        // Cat インスタンスを配列に格納
        animals[1] = new Cat();

        // ポリモーフィズムを使用して異なる種類の動物のサウンドを出力
        for (Animal animal : animals) {
            animal.makeSound();
        }
    }
}

このプログラムでは、Animal 抽象クラスを定義し、その中に makeSound 抽象メソッドがあります。Dog と Cat クラスはそれぞれ Animal を拡張して、makeSound メソッドをオーバーライドしています。Main クラスでは、Animal 型の配列を作成し、異なる種類の動物のサウンドをポリモーフィズムを使って表示しています。

出力結果：

Woof! Woof!
Meow! Meow!

このプログラムでは、Animal 型の配列 animals を作成し、その中に Dog インスタンスと Cat インスタンスを格納しています。その後、拡張forループを使用して配列内の各要素に対して makeSound メソッドを呼び出しています。

配列の1番目の要素は Dog インスタンスであり、makeSound メソッドが呼び出されると "Woof! Woof!" が出力されます。配列の2番目の要素は Cat インスタンスであり、同様に makeSound メソッドが呼び出されると "Meow! Meow!" が出力されます。

これがポリモーフィズムの一例です。

「016 抽象クラス」問題集リスト

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/3679/feed 0 016 抽象クラス（抽象メソッドと具象メソッド） 010 解答例 https://minner.asia/archives/3658 https://minner.asia/archives/3658#respond Mon, 11 Dec 2023 22:33:52 +0000 http://localhost/?p=3658 
// 抽象クラス BankAccount
abstract class BankAccount {
    // 抽象メソッド deposit を宣言
    public abstract void deposit(double amount);

    // 抽象メソッド withdraw を宣言
    public abstract void withdraw(double amount);
}

// 具象クラス SavingsAccount
class SavingsAccount extends BankAccount {
    private double balance;

    // コンストラクタ
    public SavingsAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    // deposit メソッドの実装
    @Override
    public void deposit(double amount) {
        balance += amount;
        System.out.println("Deposited: $" + amount);
    }

    // withdraw メソッドの実装
    @Override
    public void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
            System.out.println("Withdrawn: $" + amount);
        } else {
            System.out.println("Insufficient funds for withdrawal.");
        }
    }

    // 残高を取得するメソッド
    public double getBalance() {
        return balance;
    }
}

// 具象クラス CheckingAccount
class CheckingAccount extends BankAccount {
    private double balance;

    // コンストラクタ
    public CheckingAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    // deposit メソッドの実装
    @Override
    public void deposit(double amount) {
        balance += amount;
        System.out.println("Deposited: $" + amount);
    }

    // withdraw メソッドの実装
    @Override
    public void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
            System.out.println("Withdrawn: $" + amount);
        } else {
            System.out.println("Insufficient funds for withdrawal.");
        }
    }

    // 残高を取得するメソッド
    public double getBalance() {
        return balance;
    }
}

// メインクラス
public class Main {
    public static void main(String[] args) {
        // SavingsAccount クラスの利用例
        SavingsAccount savingsAccount = new SavingsAccount(1000);
        savingsAccount.deposit(500);
        savingsAccount.withdraw(200);
        System.out.println("Savings Account Balance: $" + savingsAccount.getBalance());

        // CheckingAccount クラスの利用例
        CheckingAccount checkingAccount = new CheckingAccount(500);
        checkingAccount.deposit(300);
        checkingAccount.withdraw(800);
        System.out.println("Checking Account Balance: $" + checkingAccount.getBalance());
    }
}

このコードでは、BankAccount クラスが抽象メソッド deposit と withdraw を宣言しています。それを継承する具象クラス SavingsAccount と CheckingAccount が、それぞれの銀行口座の動作を実装しています。Main クラスでそれぞれの銀行口座を利用して、預金や引き出しの操作を行い、残高が表示される様子が示されています。

出力結果：

Deposited: $500
Withdrawn: $200
Savings Account Balance: $1300

Deposited: $300
Insufficient funds for withdrawal.
Checking Account Balance: $800

それぞれの口座に対して、預金や引き出しの操作が行われ、最終的な残高が表示されています。

「016 抽象クラス」問題集リスト

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/3658/feed 0 016 抽象クラス（抽象メソッドと具象メソッド） 009 解答例 https://minner.asia/archives/3652 https://minner.asia/archives/3652#respond Mon, 11 Dec 2023 22:27:25 +0000 http://localhost/?p=3652 
// 抽象クラス Employee
abstract class Employee {
    // 抽象メソッド calculateSalary を宣言
    public abstract double calculateSalary();
}

// 具象クラス Manager
class Manager extends Employee {
    private double baseSalary;
    private double bonus;

    // コンストラクタ
    public Manager(double baseSalary, double bonus) {
        this.baseSalary = baseSalary;
        this.bonus = bonus;
    }

    // calculateSalary メソッドの実装
    @Override
    public double calculateSalary() {
        return baseSalary + bonus;
    }
}

// 具象クラス Developer
class Developer extends Employee {
    private double hourlyRate;
    private int hoursWorked;

    // コンストラクタ
    public Developer(double hourlyRate, int hoursWorked) {
        this.hourlyRate = hourlyRate;
        this.hoursWorked = hoursWorked;
    }

    // calculateSalary メソッドの実装
    @Override
    public double calculateSalary() {
        return hourlyRate * hoursWorked;
    }
}

// メインクラス
public class Main {
    public static void main(String[] args) {
        // Manager クラスの利用例
        Manager manager = new Manager(50000, 10000);
        System.out.println("Manager's Salary: $" + manager.calculateSalary());

        // Developer クラスの利用例
        Developer developer = new Developer(25, 160);
        System.out.println("Developer's Salary: $" + developer.calculateSalary());
    }
}

この例では、Employee クラスが抽象メソッド calculateSalary() を宣言しています。それを継承する具象クラス Manager と Developer が、それぞれの職種に応じた給与計算を行うメソッドを実装しています。Main クラスで Manager クラスと Developer クラスをインスタンス化し、calculateSalary() メソッドを呼び出して、各従業員の給与が表示される様子が示されています。

出力結果：

Manager's Salary: $60000.0
Developer's Salary: $4000.0

「016 抽象クラス」問題集リスト

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/3652/feed 0 016 抽象クラス（抽象メソッドと具象メソッド） 008 解答例 https://minner.asia/archives/3646 https://minner.asia/archives/3646#respond Mon, 11 Dec 2023 22:21:22 +0000 http://localhost/?p=3646 
// 抽象クラス Vehicle
abstract class Vehicle {
    // 抽象メソッド startEngine を宣言
    public abstract void startEngine();
}

// 具象クラス Car
class Car extends Vehicle {
    // startEngine メソッドの実装
    @Override
    public void startEngine() {
        System.out.println("Car Engine started. Vroom! Vroom!");
    }
}

// 具象クラス Motorcycle
class Motorcycle extends Vehicle {
    // startEngine メソッドの実装
    @Override
    public void startEngine() {
        System.out.println("Motorcycle Engine started. Rrrrrrrrrrr!");
    }
}

// メインクラス
public class Main {
    public static void main(String[] args) {
        // Car クラスのインスタンスを作成
        Car myCar = new Car();
        
        // startEngine() メソッドを呼び出して車のエンジンを始動
        myCar.startEngine();  // 出力: Car Engine started. Vroom! Vroom!

        // Motorcycle クラスのインスタンスを作成
        Motorcycle myMotorcycle = new Motorcycle();
        
        // startEngine() メソッドを呼び出してバイクのエンジンを始動
        myMotorcycle.startEngine();  // 出力: Motorcycle Engine started. Rrrrrrrrrrr!
    }
}

この例では、Vehicle クラスが抽象メソッド startEngine() を宣言しています。それを継承する具象クラス Car と Motorcycle が、それぞれの乗り物のエンジンを始動させるメソッドを実装しています。Main クラスで Car クラスと Motorcycle クラスをインスタンス化し、それぞれの startEngine() メソッドを呼び出すことで、車とバイクのエンジンが始動される様子が表示されます。

出力結果：

Car Engine started. Vroom! Vroom!
Motorcycle Engine started. Rrrrrrrrrrr!

「016 抽象クラス」問題集リスト

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/3646/feed 0 016 抽象クラス（抽象メソッドと具象メソッド） 007 解答例 https://minner.asia/archives/3631 https://minner.asia/archives/3631#respond Mon, 11 Dec 2023 12:47:50 +0000 http://localhost/?p=3631 
// 抽象クラス Animal
abstract class Animal {
    // 鳴き声を表す抽象メソッド
    public abstract void makeSound();
}

// 具象クラス Dog
class Dog extends Animal {
    // 犬の鳴き声を出力するメソッド
    @Override
    public void makeSound() {
        System.out.println("Dog barks: Woof! Woof!");
    }
}

// 具象クラス Cat
class Cat extends Animal {
    // 猫の鳴き声を出力するメソッド
    @Override
    public void makeSound() {
        System.out.println("Cat meows: Meow! Meow!");
    }
}

// メインクラス
public class Main {
    public static void main(String[] args) {
        // Dog クラスの利用例
        Dog myDog = new Dog();
        
        // 犬の鳴き声を呼び出し
        myDog.makeSound();  // 出力: Dog barks: Woof! Woof!

        // Cat クラスの利用例
        Cat myCat = new Cat();
        
        // 猫の鳴き声を呼び出し
        myCat.makeSound();  // 出力: Cat meows: Meow! Meow!
    }
}

この例では、Animal クラスが抽象メソッド makeSound() を宣言しています。それを継承する具象クラス Dog と Cat が、それぞれの動物の鳴き声を出力するメソッドを実装しています。Main クラスで Dog クラスと Cat クラスをインスタンス化して、それぞれの makeSound() メソッドを呼び出すことで、犬と猫の鳴き声が表示されます。

出力結果：

Dog barks: Woof! Woof!
Cat meows: Meow! Meow!

具象クラス Dog のインスタンスを作成し、makeSound() メソッドを呼び出した結果、”Dog barks: Woof! Woof!” という文字列が表示されます。同様に、具象クラス Cat のインスタンスを作成し、makeSound() メソッドを呼び出した結果、”Cat meows: Meow! Meow!” という文字列が表示されます。

「016 抽象クラス」問題集リスト

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/3631/feed 0 016 抽象クラス（抽象メソッドと具象メソッド） 006 解答例 https://minner.asia/archives/3624 https://minner.asia/archives/3624#respond Mon, 11 Dec 2023 12:39:29 +0000 http://localhost/?p=3624 
// 抽象クラス Shape
abstract class Shape {
    // 抽象メソッド calculateArea を宣言
    public abstract double calculateArea();
}

// 具象クラス Circle
class Circle extends Shape {
    private double radius;

    // コンストラクタ
    public Circle(double radius) {
        this.radius = radius;
    }

    // calculateArea メソッドの実装
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

// 具象クラス Rectangle
class Rectangle extends Shape {
    private double length;
    private double width;

    // コンストラクタ
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    // calculateArea メソッドの実装
    @Override
    public double calculateArea() {
        return length * width;
    }
}

// メインクラス
public class Main {
    public static void main(String[] args) {
        // Circle クラスの利用例
        Circle circle = new Circle(5.0);
        System.out.println("Circle Area: " + circle.calculateArea());

        // Rectangle クラスの利用例
        Rectangle rectangle = new Rectangle(4.0, 6.0);
        System.out.println("Rectangle Area: " + rectangle.calculateArea());
    }
}

この例では、Shape クラスが抽象メソッド calculateArea() を宣言しています。それを継承する具象クラス Circle と Rectangle が、それぞれの形状に対する面積を計算するメソッドを実装しています。Main クラスでそれぞれのクラスをインスタンス化して calculateArea() を呼び出すことで、各形状の面積が表示されます。

出力結果：

Circle Area: 78.53981633974483
Rectangle Area: 24.0

抽象メソッドと具象メソッド

抽象メソッドと具象メソッドは、Javaにおいてオブジェクト指向プログラミングの中で重要な概念です。これらは、抽象クラスやインターフェースを通じて利用され、継承や実装において役立ちます。

抽象メソッド:

  1. 定義:
    • 抽象メソッドはメソッドの本体（実装）がないメソッドです。
    • 宣言のみを含み、メソッドの動作が具体的なクラスで定義されます。
  2. 宣言:
    • 抽象メソッドは抽象クラスまたはインターフェースで宣言されます。
    • 抽象メソッドを含むクラスは、そのクラス自体も抽象である必要があります。
  3. サブクラスでの実装:
    • 抽象クラスを継承するサブクラスは、抽象メソッドを実装（オーバーライド）する必要があります。
    • インターフェースの場合も同様で、実装クラスはインターフェースのメソッドを実装しなければなりません。
  4. 利点:
    • 抽象メソッドを使用することで、異なるサブクラスで同じメソッド名を持ちつつ、個々のクラスに合った独自の挙動を実現できます。
abstract class Shape {
    public abstract double calculateArea();
}

具象クラス Circle のインスタンスを作成し、calculateArea() メソッドを呼び出した結果、円の面積が計算されて表示されます。同様に、具象クラス Rectangle のインスタンスを作成し、calculateArea() メソッドを呼び出した結果、長方形の面積が計算されて表示されます。

具象メソッド:

  1. 定義:
    • 具象メソッドはメソッドの本体（実装）を持つ通常のメソッドです。
    • 通常のメソッドと同様に、メソッドの動作が既に実装されています。
  2. クラス内で直接使用:
    • 具象メソッドは抽象クラスや通常のクラス内で直接使用されます。
    • サブクラスでオーバーライドされることなく、そのまま使用されます。
  3. オーバーライド:
    • 抽象クラス内の具象メソッドは、サブクラスによってオーバーライドされることがあります。
    • オーバーライドにより、サブクラスは親クラスのメソッドを再定義することができます。
  4. 利点:
    • 具象メソッドは既存の実装を提供するため、サブクラスで特別な動作が必要ない場合はそのまま使用できます。
abstract class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

抽象メソッドと具象メソッドは、オブジェクト指向プログラミングにおいて柔軟性と再利用性を提供します。抽象メソッドは特定のクラスに固有の挙動を要求し、具象メソッドは既存の実装を提供して再利用を可能にします。

「016 抽象クラス」問題集リスト

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/3624/feed 0 016 抽象クラス（基本概念） 005 解答例 https://minner.asia/archives/3615 https://minner.asia/archives/3615#respond Sun, 10 Dec 2023 22:48:56 +0000 http://localhost/?p=3615 
// 抽象クラス BankAccount の定義
abstract class BankAccount {
    private double balance; // 残高

    // コンストラクタ
    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    // 抽象メソッド deposit
    public abstract void deposit(double amount);

    // 抽象メソッド withdraw
    public abstract void withdraw(double amount);

    // 残高を取得するメソッド
    public double getBalance() {
        return balance;
    }
}

// 具象クラス SavingsAccount の定義
class SavingsAccount extends BankAccount {
    private double interestRate; // 利率

    // コンストラクタ
    public SavingsAccount(double initialBalance, double interestRate) {
        super(initialBalance);
        this.interestRate = interestRate;
    }

    // deposit メソッドの実装
    @Override
    public void deposit(double amount) {
        double interest = amount * interestRate;
        super.deposit(amount + interest);
        System.out.println("Deposited: $" + amount + ", Interest Earned: $" + interest);
    }

    // withdraw メソッドの実装
    @Override
    public void withdraw(double amount) {
        super.withdraw(amount);
        System.out.println("Withdrawn: $" + amount);
    }
}

// 具象クラス CheckingAccount の定義
class CheckingAccount extends BankAccount {
    private double overdraftFee; // オーバードラフト手数料

    // コンストラクタ
    public CheckingAccount(double initialBalance, double overdraftFee) {
        super(initialBalance);
        this.overdraftFee = overdraftFee;
    }

    // deposit メソッドの実装
    @Override
    public void deposit(double amount) {
        super.deposit(amount);
        System.out.println("Deposited: $" + amount);
    }

    // withdraw メソッドの実装
    @Override
    public void withdraw(double amount) {
        if (amount > getBalance()) {
            double totalAmount = amount + overdraftFee;
            super.withdraw(totalAmount);
            System.out.println("Overdraft Occurred! Withdrawn: $" + amount + ", Overdraft Fee: $" + overdraftFee);
        } else {
            super.withdraw(amount);
            System.out.println("Withdrawn: $" + amount);
        }
    }
}

// メインクラス
public class Main {
    public static void main(String[] args) {
        // SavingsAccount の利用例
        SavingsAccount savingsAccount = new SavingsAccount(1000, 0.05);
        savingsAccount.deposit(500);
        savingsAccount.withdraw(200);
        System.out.println("Savings Account Balance: $" + savingsAccount.getBalance());

        // CheckingAccount の利用例
        CheckingAccount checkingAccount = new CheckingAccount(500, 20);
        checkingAccount.deposit(300);
        checkingAccount.withdraw(800);
        System.out.println("Checking Account Balance: $" + checkingAccount.getBalance());
    }
}

この例では、BankAccount クラスを抽象クラスとして定義し、その中に deposit と withdraw という抽象メソッドを宣言しました。それを継承する SavingsAccount と CheckingAccount クラスが、それぞれの特有の振る舞いを実装しています。

出力結果：

Deposited: $500.0, Interest Earned: $25.0
Withdrawn: $200.0
Savings Account Balance: $1325.0

Deposited: $300.0
Overdraft Occurred! Withdrawn: $800.0, Overdraft Fee: $20.0
Checking Account Balance: $0.0

各アカウントの操作に対する出力を説明します。

SavingsAccount の利用例：

  1. 500ドルをデポジットし、その結果、利子25ドルが加算されています。
  2. 200ドルを引き出しました。
  3. Savings Accountの残高はデポジットと利子の合計で1325ドルです。

CheckingAccount の利用例：

  1. 300ドルをデポジットしました。
  2. 800ドルを引き出しましたが、残高不足のためオーバードラフトが発生し、手数料20ドルが追加されています。
  3. Checking Accountの残高は0ドルです。

「016 抽象クラス」問題集リスト

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/3615/feed 0