Javaクラス応用コレクション 課題集 (全30問)

ここまでの学習内容を踏まえて問題集を作成しました。問題集の後には解答例も確認することができます。

初級問題 (9問)

1. 基本継承問題
   Animalクラスを作成し、これを継承するDogクラスとCatクラスを作成してください。Animalにはnameフィールドとspeak()メソッドを持たせ、各サブクラスでオーバーライドしてそれぞれの鳴き声を返すようにしてください。
2. スーパークラスのコンストラクタ呼び出し
   Vehicleクラス（brandフィールドを持つ）を継承するCarクラスを作成し、Carのコンストラクタでsuperを使ってbrandを初期化するようにしてください。
3. メソッドオーバーライド
   Shapeクラスとそれを継承するCircle, Rectangleクラスを作成し、calculateArea()メソッドを各サブクラスでオーバーライドして面積を計算するようにしてください。

4. ポリモーフィズムの基本
   Animal型の配列にDogとCatのインスタンスを混在させ、各オブジェクトのspeak()メソッドを呼び出すプログラムを作成してください。
5. インスタンスof判定
   上記の配列をループで処理し、instanceofを使って各オブジェクトの実際の型を判定するプログラムを作成してください。

6. ArrayList基本操作
   ArrayList<String>を作成し、文字列を5つ追加し、その後で2番目の要素を削除して全要素を表示するプログラムを作成してください。
7. HashSetでの重複排除
   ArrayList<Integer>に重複した数値を追加し、これをHashSetに変換して重複を排除するプログラムを作成してください。
8. HashMap基本操作
   HashMap<String, Integer>を作成し、3つのキーと値のペアを追加し、特定のキーに対応する値を取得して表示するプログラムを作成してください。
9. Listのソート
   ArrayList<Integer>を作成し、数値を5つ追加してCollections.sort()でソートするプログラムを作成してください。

中級問題 (15問)

10. 抽象クラスの実装
    AbstractEmployee抽象クラス（nameフィールドと抽象メソッドcalculateSalary()を持つ）を作成し、これを継承するFullTimeEmployeeとPartTimeEmployeeクラスを実装してください。
11. フィールドのアクセス修飾子
    protectedアクセス修飾子を使用した例を作成してください。親クラスにprotectedフィールドを定義し、子クラスからアクセスするプログラムを作成してください。
12. finalメソッドのオーバーライド禁止
    Parentクラスにfinalメソッドを定義し、Childクラスでオーバーライドしようとするとコンパイルエラーになることを確認してください。

13. インターフェースのポリモーフィズム
    Drawableインターフェース（draw()メソッド）を定義し、CircleとSquareクラスで実装するプログラムを作成してください。
14. ポリモーフィズムとメソッド引数
    Animalを引数に取るメソッドを作成し、DogとCatのインスタンスを渡してポリモーフィックな動作を確認するプログラムを作成してください。
15. オブジェクトの型変換
    アップキャストとダウンキャストの例を作成し、安全なダウンキャストのためにinstanceofを使用するプログラムを作成してください。

16. カスタムオブジェクトのListソート
    Studentクラス（name, scoreフィールド）のArrayListを作成し、scoreでソートするプログラムを作成してください。
17. Mapの反復処理
    HashMap<String, Integer>を作成し、エントリセットを使ってすべてのキーと値を表示するプログラムを作成してください。
18. Listのフィルタリング
    ArrayList<Integer>から特定の条件（例：10以上の数値）を満たす要素だけを新しいListに抽出するプログラムを作成してください。
19. Setの操作
    2つのHashSetを作成し、和集合、積集合、差集合を求めるプログラムを作成してください。
20. LinkedListによるQueue操作
    LinkedListをQueueとして使用し、要素の追加（offer）、削除（poll）、先頭要素の参照（peek）を行うプログラムを作成してください。
21. Iteratorを使ったList操作
    ArrayListに対してIteratorを使用して要素を走査し、特定の条件に合致する要素を削除するプログラムを作成してください。
22. 重複要素のカウント
    ArrayList<String>の中の各要素の出現回数をHashMapを使ってカウントするプログラムを作成してください。
23. Listのシャッフル
    ArrayList<Integer>を作成し、Collections.shuffle()で要素をランダムに並び替えるプログラムを作成してください。
24. カスタムキークラスとHashMap
    StudentクラスをキーとするHashMapを作成し、正しく動作させるためにequals()とhashCode()メソッドをオーバーライドしてください。

上級問題 (6問)

25. 継承とコレクションの組み合わせ
    Libraryクラスを作成し、BookオブジェクトのArrayListを管理するようにしてください。Bookを継承するEbookとPrintedBookクラスを作成し、ポリモーフィズムを活用してください。
26. 抽象クラスとポリモーフィズム
    AbstractPayment抽象クラスとそれを継承するCreditCardPayment, CashPaymentクラスを作成し、ArrayList<AbstractPayment>で管理するプログラムを作成してください。
27. Mapと継承の組み合わせ
    Map<String, Animal>を作成し、さまざまなAnimalサブクラスのインスタンスを追加して、特定の機能を実行するプログラムを作成してください。
28. コレクションのネスト
    HashMap<String, ArrayList<Student>>を作成し、クラス名をキー、学生リストを値として管理するプログラムを作成してください。
29. ポリモーフィズムとソート
    Comparableインターフェースを実装したProductクラス階層を作成し、価格でソートできるようにしてください。
30. 大規模なクラス設計
    簡単な銀行システムをモデル化してください。BankAccount抽象クラス、SavingsAccountとCheckingAccountサブクラスを作成し、ArrayList<BankAccount>で口座を管理するBankクラスを実装してください。

初級問題 解答例

1. 基本継承問題

class Animal {
    protected String name;

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

    public String speak() {
        return "Some sound";
    }
}

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

    @Override
    public String speak() {
        return "Woof!";
    }
}

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

    @Override
    public String speak() {
        return "Meow!";
    }
}

2. スーパークラスのコンストラクタ呼び出し

class Vehicle {
    protected String brand;

    public Vehicle(String brand) {
        this.brand = brand;
    }
}

class Car extends Vehicle {
    private int doors;

    public Car(String brand, int doors) {
        super(brand);
        this.doors = doors;
    }
}

3. メソッドオーバーライド

class Shape {
    public double calculateArea() {
        return 0;
    }
}

class Circle extends Shape {
    private double radius;

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

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

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

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

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

4. ポリモーフィズムの基本

public class Main {
    public static void main(String[] args) {
        Animal[] animals = new Animal[3];
        animals[0] = new Dog("Buddy");
        animals[1] = new Cat("Whiskers");
        animals[2] = new Dog("Max");

        for (Animal animal : animals) {
            System.out.println(animal.speak());
        }
    }
}

5. インスタンスof判定

public class Main {
    public static void main(String[] args) {
        Animal[] animals = new Animal[3];
        animals[0] = new Dog("Buddy");
        animals[1] = new Cat("Whiskers");
        animals[2] = new Dog("Max");

        for (Animal animal : animals) {
            if (animal instanceof Dog) {
                System.out.println(animal.name + " is a Dog");
            } else if (animal instanceof Cat) {
                System.out.println(animal.name + " is a Cat");
            }
        }
    }
}

6. ArrayList基本操作

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        list.add("Grape");
        list.add("Mango");

        list.remove(1); // 2番目の要素を削除

        for (String fruit : list) {
            System.out.println(fruit);
        }
    }
}

7. HashSetでの重複排除

import java.util.ArrayList;
import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        ArrayList numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(2);
        numbers.add(3);
        numbers.add(3);
        numbers.add(3);

        HashSet uniqueNumbers = new HashSet<>(numbers);

        System.out.println("Unique numbers: " + uniqueNumbers);
    }
}

8. HashMap基本操作

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap map = new HashMap<>();
        map.put("Alice", 25);
        map.put("Bob", 30);
        map.put("Charlie", 35);

        int age = map.get("Bob");
        System.out.println("Bob's age: " + age);
    }
}

9. Listのソート

import java.util.ArrayList;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        ArrayList numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(2);
        numbers.add(8);
        numbers.add(1);
        numbers.add(3);

        Collections.sort(numbers);

        System.out.println("Sorted list: " + numbers);
    }
}

中級問題 解答例

10. 抽象クラスの実装

abstract class AbstractEmployee {
    protected String name;

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

    public abstract double calculateSalary();
}

class FullTimeEmployee extends AbstractEmployee {
    private double monthlySalary;

    public FullTimeEmployee(String name, double monthlySalary) {
        super(name);
        this.monthlySalary = monthlySalary;
    }

    @Override
    public double calculateSalary() {
        return monthlySalary;
    }
}

class PartTimeEmployee extends AbstractEmployee {
    private double hourlyRate;
    private int hoursWorked;

    public PartTimeEmployee(String name, double hourlyRate, int hoursWorked) {
        super(name);
        this.hourlyRate = hourlyRate;
        this.hoursWorked = hoursWorked;
    }

    @Override
    public double calculateSalary() {
        return hourlyRate * hoursWorked;
    }
}

11. フィールドのアクセス修飾子

class Parent {
    protected String protectedField = "This is protected";
}

class Child extends Parent {
    public void accessProtectedField() {
        System.out.println(protectedField); // 子クラスからアクセス可能
    }
}

12. finalメソッドのオーバーライド禁止

class Parent {
    public final void finalMethod() {
        System.out.println("This cannot be overridden");
    }
}

class Child extends Parent {
    // 以下のコードはコンパイルエラーになる
    // @Override
    // public void finalMethod() {
    //     System.out.println("Trying to override");
    // }
}

13. インターフェースのポリモーフィズム

interface Drawable {
    void draw();
}

class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

class Square implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a Square");
    }
}

14. ポリモーフィズムとメソッド引数

class AnimalHelper {
    public static void makeAnimalSpeak(Animal animal) {
        System.out.println(animal.speak());
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        Cat cat = new Cat("Whiskers");

        AnimalHelper.makeAnimalSpeak(dog);
        AnimalHelper.makeAnimalSpeak(cat);
    }
}

15. オブジェクトの型変換

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog("Buddy"); // アップキャスト

        if (animal instanceof Dog) {
            Dog dog = (Dog) animal; // ダウンキャスト
            System.out.println("Successfully cast to Dog: " + dog.speak());
        }
    }
}

16. カスタムオブジェクトのListソート

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

class Student {
    String name;
    int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList students = new ArrayList<>();
        students.add(new Student("Alice", 85));
        students.add(new Student("Bob", 92));
        students.add(new Student("Charlie", 78));

        Collections.sort(students, new Comparator() {
            @Override
            public int compare(Student s1, Student s2) {
                return Integer.compare(s1.score, s2.score);
            }
        });

        for (Student student : students) {
            System.out.println(student.name + ": " + student.score);
        }
    }
}

17. Mapの反復処理

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        HashMap map = new HashMap<>();
        map.put("Apple", 100);
        map.put("Banana", 50);
        map.put("Orange", 80);

        for (Map.Entry entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
    }
}

18. Listのフィルタリング

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(12);
        numbers.add(8);
        numbers.add(15);
        numbers.add(3);

        ArrayList filtered = new ArrayList<>();
        for (Integer num : numbers) {
            if (num >= 10) {
                filtered.add(num);
            }
        }

        System.out.println("Filtered list: " + filtered);
    }
}

19. Setの操作

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet set1 = new HashSet<>();
        set1.add(1);
        set1.add(2);
        set1.add(3);

        HashSet set2 = new HashSet<>();
        set2.add(2);
        set2.add(3);
        set2.add(4);

        // 和集合
        HashSet union = new HashSet<>(set1);
        union.addAll(set2);
        System.out.println("Union: " + union);

        // 積集合
        HashSet intersection = new HashSet<>(set1);
        intersection.retainAll(set2);
        System.out.println("Intersection: " + intersection);

        // 差集合
        HashSet difference = new HashSet<>(set1);
        difference.removeAll(set2);
        System.out.println("Difference: " + difference);
    }
}

20. LinkedListによるQueue操作

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue queue = new LinkedList<>();

        queue.offer("First");
        queue.offer("Second");
        queue.offer("Third");

        System.out.println("Peek: " + queue.peek());
        System.out.println("Poll: " + queue.poll());
        System.out.println("Queue: " + queue);
    }
}

21. Iteratorを使ったList操作

import java.util.ArrayList;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        ArrayList numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);

        Iterator iterator = numbers.iterator();
        while (iterator.hasNext()) {
            int num = iterator.next();
            if (num % 2 == 0) {
                iterator.remove();
            }
        }

        System.out.println("After removal: " + numbers);
    }
}

22. 重複要素のカウント

import java.util.ArrayList;
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        ArrayList words = new ArrayList<>();
        words.add("apple");
        words.add("banana");
        words.add("apple");
        words.add("orange");
        words.add("banana");
        words.add("apple");

        HashMap countMap = new HashMap<>();
        for (String word : words) {
            countMap.put(word, countMap.getOrDefault(word, 0) + 1);
        }

        System.out.println("Word counts: " + countMap);
    }
}

23. Listのシャッフル

import java.util.ArrayList;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        ArrayList numbers = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            numbers.add(i);
        }

        System.out.println("Original: " + numbers);
        Collections.shuffle(numbers);
        System.out.println("Shuffled: " + numbers);
    }
}

24. カスタムキークラスとHashMap

import java.util.HashMap;
import java.util.Objects;

class Student {
    private String id;
    private String name;

    public Student(String id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(id, student.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

public class Main {
    public static void main(String[] args) {
        HashMap grades = new HashMap<>();
        Student s1 = new Student("001", "Alice");
        Student s2 = new Student("002", "Bob");

        grades.put(s1, 85);
        grades.put(s2, 92);

        System.out.println("Alice's grade: " + grades.get(s1));
    }
}

上級問題 解答例

25. 継承とコレクションの組み合わせ

import java.util.ArrayList;

class Book {
    protected String title;
    protected String author;

    public Book(String title, String author) {
        this.title = title;
        this.author = author;
    }

    public String getInfo() {
        return title + " by " + author;
    }
}

class Ebook extends Book {
    private double fileSize;

    public Ebook(String title, String author, double fileSize) {
        super(title, author);
        this.fileSize = fileSize;
    }

    @Override
    public String getInfo() {
        return super.getInfo() + " (File size: " + fileSize + "MB)";
    }
}

class PrintedBook extends Book {
    private int pages;

    public PrintedBook(String title, String author, int pages) {
        super(title, author);
        this.pages = pages;
    }

    @Override
    public String getInfo() {
        return super.getInfo() + " (Pages: " + pages + ")";
    }
}

class Library {
    private ArrayList books = new ArrayList<>();

    public void addBook(Book book) {
        books.add(book);
    }

    public void listAllBooks() {
        for (Book book : books) {
            System.out.println(book.getInfo());
        }
    }
}

26. 抽象クラスとポリモーフィズム

import java.util.ArrayList;

abstract class AbstractPayment {
    protected double amount;

    public AbstractPayment(double amount) {
        this.amount = amount;
    }

    public abstract void processPayment();
}

class CreditCardPayment extends AbstractPayment {
    private String cardNumber;

    public CreditCardPayment(double amount, String cardNumber) {
        super(amount);
        this.cardNumber = cardNumber;
    }

    @Override
    public void processPayment() {
        System.out.println("Processing credit card payment of $" + amount);
    }
}

class CashPayment extends AbstractPayment {
    public CashPayment(double amount) {
        super(amount);
    }

    @Override
    public void processPayment() {
        System.out.println("Processing cash payment of $" + amount);
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList payments = new ArrayList<>();
        payments.add(new CreditCardPayment(100.0, "1234-5678-9012-3456"));
        payments.add(new CashPayment(50.0));

        for (AbstractPayment payment : payments) {
            payment.processPayment();
        }
    }
}

27. Mapと継承の組み合わせ

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap animalMap = new HashMap<>();
        animalMap.put("dog1", new Dog("Buddy"));
        animalMap.put("cat1", new Cat("Whiskers"));
        animalMap.put("dog2", new Dog("Max"));

        for (Animal animal : animalMap.values()) {
            System.out.println(animal.name + " says: " + animal.speak());
        }
    }
}

28. コレクションのネスト

import java.util.ArrayList;
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap> classMap = new HashMap<>();

        ArrayList classA = new ArrayList<>();
        classA.add(new Student("S001", "Alice", 85));
        classA.add(new Student("S002", "Bob", 92));

        ArrayList classB = new ArrayList<>();
        classB.add(new Student("S003", "Charlie", 78));
        classB.add(new Student("S004", "Diana", 88));

        classMap.put("Class A", classA);
        classMap.put("Class B", classB);

        for (String className : classMap.keySet()) {
            System.out.println(className + ":");
            for (Student student : classMap.get(className)) {
                System.out.println("  " + student.name + " - " + student.score);
            }
        }
    }
}

class Student {
    String id;
    String name;
    int score;

    public Student(String id, String name, int score) {
        this.id = id;
        this.name = name;
        this.score = score;
    }
}

29. ポリモーフィズムとソート

import java.util.ArrayList;
import java.util.Collections;

abstract class Product implements Comparable {
    protected String name;
    protected double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public int compareTo(Product other) {
        return Double.compare(this.price, other.price);
    }

    public abstract String getProductType();
}

class Electronics extends Product {
    public Electronics(String name, double price) {
        super(name, price);
    }

    @Override
    public String getProductType() {
        return "Electronics";
    }
}

class Clothing extends Product {
    public Clothing(String name, double price) {
        super(name, price);
    }

    @Override
    public String getProductType() {
        return "Clothing";
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList products = new ArrayList<>();
        products.add(new Electronics("Laptop", 999.99));
        products.add(new Clothing("T-Shirt", 19.99));
        products.add(new Electronics("Smartphone", 699.99));

        Collections.sort(products);

        for (Product product : products) {
            System.out.println(product.name + " - $" + product.price + " (" + product.getProductType() + ")");
        }
    }
}

30. 大規模なクラス設計

import java.util.ArrayList;

abstract class BankAccount {
    protected String accountNumber;
    protected double balance;
    protected String owner;

    public BankAccount(String accountNumber, double balance, String owner) {
        this.accountNumber = accountNumber;
        this.balance = balance;
        this.owner = owner;
    }

    public abstract void withdraw(double amount);
    public abstract void deposit(double amount);

    public double getBalance() {
        return balance;
    }
}

class SavingsAccount extends BankAccount {
    private double interestRate;

    public SavingsAccount(String accountNumber, double balance, String owner, double interestRate) {
        super(accountNumber, balance, owner);
        this.interestRate = interestRate;
    }

    @Override
    public void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
            System.out.println("Withdrawn: $" + amount);
        } else {
            System.out.println("Insufficient funds");
        }
    }

    @Override
    public void deposit(double amount) {
        balance += amount;
        System.out.println("Deposited: $" + amount);
    }

    public void applyInterest() {
        balance += balance * interestRate;
    }
}

class CheckingAccount extends BankAccount {
    private double overdraftLimit;

    public CheckingAccount(String accountNumber, double balance, String owner, double overdraftLimit) {
        super(accountNumber, balance, owner);
        this.overdraftLimit = overdraftLimit;
    }

    @Override
    public void withdraw(double amount) {
        if (amount <= balance + overdraftLimit) {
            balance -= amount;
            System.out.println("Withdrawn: $" + amount);
        } else {
            System.out.println("Overdraft limit exceeded");
        }
    }

    @Override
    public void deposit(double amount) {
        balance += amount;
        System.out.println("Deposited: $" + amount);
    }
}

class Bank {
    private ArrayList accounts = new ArrayList<>();

    public void addAccount(BankAccount account) {
        accounts.add(account);
    }

    public void listAllAccounts() {
        for (BankAccount account : accounts) {
            System.out.println(account.owner + " - " + account.accountNumber + " - Balance: $" + account.getBalance());
        }
    }

    public double getTotalBalance() {
        double total = 0;
        for (BankAccount account : accounts) {
            total += account.getBalance();
        }
        return total;
    }
}