常連

### 実現したいこと
仙塲大也 著　『良いコード悪いコードで学ぶ設計入門』で、「getter/setterを多用すると良くない」という旨の記述がありましたが、具体的にどのような実装を心がければ良いのかピンときません。
また、メソッドの正しい実装方法がよくわかりません。

### 発生している問題・分からないこと
例えば、攻撃キャラが防御キャラに攻撃するとき、攻撃キャラの攻撃力、レベル、魔法威力と、防御キャラの防御力、HPを使ってダメージ計算をする必要があるとします。攻撃キャラは攻撃のみ、防御キャラは防御のみ可能です。
僕は、攻撃キャラと防御キャラは別概念と考え、別々のクラスとして設計しました。しかし、その場合攻撃キャラ防御キャラどちらかにダメージ計算メソッドを実装する必要があり、ダメージ計算メソッドを持つクラスは、もう一方のgetterを使わなければいけなくなってしまいそうです。また、攻撃キャラと防御キャラの属性をどちらも使った計算のため、そもそもダメージ計算メソッドは攻撃キャラと防御キャラどちらが持っておくべきものなのかもわかりません。
今回の例だけでなく、他の例でも応用可能な考え方等ありましたら併せてご教授お願い致します。



### 該当のソースコード

```
特になし
```

### 試したこと・調べたこと
- [x] teratailやGoogle等で検索した
- [ ] ソースコードを自分なりに変更した
- [ ] 知人に聞いた
- [ ] その他

##### 上記の詳細・結果
「委譲を行う」、「引数を渡さず尋ねるだけで結果が帰ってくるようにする」等の記述がネットに沢山転がっていましたが、今回の例で活用できる考え方なのかイマイチわかりません。

### 補足
技術レベルは以下の通りです。↓

学生で大規模開発経験なし。
簡単なボードゲーム、jspやサーブレットを用いた簡単なwebサイト等の開発経験はあります。
OracleのJavaSilver取得済みです。
クラス設計、オブジェクト指向等に関しては全くの初心者です。上記の『いいコード悪いコード』やネットの記事等で勉強を進めている状態です。

ご丁寧な回答、本当にありがとうございました！
全て参考にさせて頂きます。

デメテルの法則  尋ねるな命じろ

### 実現したいこと
添付コードの状況において「Carインスタンス作成後に、プレイヤーの数値入力によって動的にSuperEngineのgearを上げ下げできるようにしたい」といった仕様変更が入った際、どのように修正するのが良いか意見を伺いたいです。

### 発生している問題・分からないこと
そもそもこのような仕様変更が入る可能性を考えずにIEngineインターフェースで抽象化してしまったのが間違いなのか、それとも他に抽象化のメリットを維持しながら仕様変更に対処する方法があるなら知りたい。



### 該当のソースコード

```C#
public class Hello{
    public static void Main(){
       
        Car car = new Car(new MiniEngine());
        Car car2 = new Car(new SuperEngineAdapter(new SuperEngine(1)));
        
        car.Run();　// 5
        car2.Run(); // 30
        
        var line = System.Console.ReadLine();
        int newGear = 0;
        bool result = int.TryParse(line, out newGear);
        if(result){
            //car2.SetGear(newGear); //コンパイルエラー
            System.Console.WriteLine($"newGear:{newGear}");
        } 

        
        car2.Run(); // newGearに応じて変化させたい

    }
}



public class Car{
    public IEngine engine;
    public Car(IEngine engine){
        this.engine = engine;
    }
    
    public void Run(){
        float power = engine.Boost();
        System.Console.WriteLine("power=" + power.ToString());
    }
}

public interface IEngine{
    float Boost();
}
public class SuperEngine{
    int gear;
    public SuperEngine(int initalGear){this.gear = initalGear;}
    
    public float GetPower(){
        if(gear == 0) {return 10;}
        else if(gear == 1){return 30;}
        else return 50;
    }
    
    //public void SetGear(int gear) {this.gear = gear;}
    
}
public class SuperEngineAdapter : IEngine
{
    SuperEngine se;
    public SuperEngineAdapter(SuperEngine se){
        this.se = se;
    }
    public float Boost(){
        return se.GetPower();
    }
}

public class MiniEngine : IEngine{
    public float Boost(){
        return 5;
    }
}
```

### 修正済みコード(追加)
```C#
public class Hello{
    public static void Main(){
       
        Car car = new Car(new MiniEngine());
        Car car2 = new Car(new SuperEngineAdapter(new SuperEngine(1)));
        
        car.Run();　// 5
        car2.Run(); // 30
        
        var line = System.Console.ReadLine();
        int newGear = 0;
        bool result = int.TryParse(line, out newGear);
        if(result){
            //New Code
            car.SetEngineGear(newGear);
            car2.SetEngineGear(newGear);
            //
            System.Console.WriteLine($"newGear:{newGear}");
        } 

        car.Run(); //Warning
        car2.Run(); // newGearに応じて変化

    }
}



public class Car{
    protected IEngine engine;
    public Car(IEngine engine){
        this.engine = engine;
    }
    
    //New Code
    public void SetEngineGear(int newGear){
        engine.SetGear(newGear);
    }
    
    public void Run(){
        float power = engine.Boost();
        System.Console.WriteLine("power=" + power.ToString());
    }
}

public interface IEngine{
    float Boost();
    void SetGear(int newGear); //New Code
}
public class SuperEngine{
    int gear;
    public SuperEngine(int initalGear){this.gear = initalGear;}
    
    public float GetPower(){
        if(gear == 0) {return 10;}
        else if(gear == 1){return 30;}
        else return 50;
    }
    
    public void SetGear(int gear) {this.gear = gear;} //New Code
    
}
public class SuperEngineAdapter : IEngine
{
    SuperEngine se;
    public SuperEngineAdapter(SuperEngine se){
        this.se = se;
    }
    public float Boost(){
        return se.GetPower();
    }
    
    public void SetGear(int gear){ se.SetGear(gear);} //New Code
}

public class MiniEngine : IEngine{
    public float Boost(){
        return 5;
    }
    
    //New Code
    public void SetGear(int newGear){
#warning MiniEngine has no gear choice. It's always 5.
    }
}
```

### 試したこと・調べたこと
- [x] teratailやGoogle等で検索した
- [x] ソースコードを自分なりに変更した
- [ ] 知人に聞いた
- [ ] その他

##### 上記の詳細・結果
以下参考サイト
https://refactoring.guru/ja/design-patterns/adapter
https://www.youtube.com/watch?v=OCh1Bnj9gws
https://www.youtube.com/watch?v=CrqdpVPgE9k

### 補足
特になし

InterfaceとAdapterパターン採用時における仕様変更への対処

## 以下2冊のどちらがおすすめでしょうか？

[Adaptive Code　～　C#実践開発手法　第2版](https://www.amazon.co.jp/Adaptive-Code-%EF%BD%9E-C-%E5%AE%9F%E8%B7%B5%E9%96%8B%E7%99%BA%E6%89%8B%E6%B3%95-%E7%AC%AC2%E7%89%88-Gary-McLean-ebook/dp/B07DJ2BL4Y/ref=sr_1_1?crid=AN43Z7E5LEM0&dib=eyJ2IjoiMSJ9.N1mmwXYtBkSbpsYhEJggJ0LMU6sF_7VjIg-F8n6Ac8fnRCGcHue9PCXZyojgN2SJGehgmMHg9MA6vto-r9ghgCep-TkWnoZDnvfaos_kAeA89QfX7B8sMSBJkufSCT0xkHPttSxpatr78Z8FHBJzpjjrnmj2G362ROR7douvgzScNTkuZycwqNrDVqxc3R_73KjzUj3XGR78eThnZfGYdRVteYzo501pcBn16OBxP27M4lJm2a8gSqJd34WIpmXRIcDwhYcjg4lyPH993Jp-DJDqDj55Aczxm5023zrN838.wtt-KGqT3_Xou-bcL70cTpRIc-pLKI5uOCSqAc84mO0&dib_tag=se&keywords=adaptive+code&qid=1713521832&sprefix=adaptive+%2Caps%2C205&sr=8-1)
[アジャイルソフトウェア開発の奥義 第2版](https://www.amazon.co.jp/%E3%82%A2%E3%82%B8%E3%83%A3%E3%82%A4%E3%83%AB%E3%82%BD%E3%83%95%E3%83%88%E3%82%A6%E3%82%A7%E3%82%A2%E9%96%8B%E7%99%BA%E3%81%AE%E5%A5%A5%E7%BE%A9-%E7%AC%AC2%E7%89%88-%E3%82%AA%E3%83%96%E3%82%B8%E3%82%A7%E3%82%AF%E3%83%88%E6%8C%87%E5%90%91%E9%96%8B%E7%99%BA%E3%81%AE%E7%A5%9E%E9%AB%84%E3%81%A8%E5%8C%A0%E3%81%AE%E6%8A%80-%E3%83%AD%E3%83%90%E3%83%BC%E3%83%88%E3%83%BBC%E3%83%BB%E3%83%9E%E3%83%BC%E3%83%81%E3%83%B3/dp/4797347783/ref=sr_1_1?crid=3KRRNXVC1TP2P&dib=eyJ2IjoiMSJ9.rd2DLDLztNBUWuDfACcY29t584e0lYpe45o_EEBSc8XGjHj071QN20LucGBJIEps.m6R4axDZpB0Ysa6qc3ONPNkAa1KINMJGtretLmeJlJI&dib_tag=se&keywords=%E3%82%A2%E3%82%B8%E3%83%A3%E3%82%A4%E3%83%AB%E9%96%8B%E7%99%BA%E3%81%AE%E5%A5%A5%E7%BE%A9&qid=1713521848&sprefix=%E3%82%A2%E3%82%B8%E3%83%A3%E3%82%A4%E3%83%AB%E9%96%8B%E7%99%BA%E3%81%AE%2Caps%2C184&sr=8-1)

## 質問者について

- オブジェクト指向を用いた設計を学びたいプログラマ
- 上記2冊の評判が大変良いため興味を持っている
- Java、C#ともに経験あり
- デザインパターンはTemplate MethodとSingletonくらいしか知らない初学者
- アジャイル開発はDeveloperとして経験あり

## 期待していること

目次を見たところ内容が2冊とも似ており、決定的な違いは言語くらいの印象なので、「自身が業務で使用している言語が記載されている方の書籍を買えば良いのでは？」という漠然とした理由しか思い浮かばず...。なので、2冊それぞれに対する感想やおすすめ理由など、買うに至る他の理由を探しており、皆様の意見を頂戴したいです。
「2冊とも止めてこの本を買うべき」や「2冊とも買うべき」などの第三の意見も歓迎です。

どちらの書籍がおすすめでしょうか？

Spring bootにてWebアプリ開発を勉強中です。Domaでのデータアクセスをしようと思った時に疑問が出たので質問します。

参考にしているプロジェクト内でDaoとRepositoryを分けているプロジェクトを見つけたため何が違うのかと調べていたのですが、イマイチ理解できないでいます。

[参考にしているプロジェクト](https://github.com/miyabayt/spring-boot-doma2-sample.git)

その中でDaoとRepositoryを分けている箇所は以下のような実装をしています。
```userdaojava
package com.sample.domain.dao.users;

import java.util.List;
import java.util.Optional;
import java.util.stream.Collector;

import org.seasar.doma.*;
import org.seasar.doma.boot.ConfigAutowireable;
import org.seasar.doma.jdbc.SelectOptions;

import com.sample.domain.dto.user.User;
import com.sample.domain.dto.user.UserCriteria;

@ConfigAutowireable
@Dao
public interface UserDao {

    /**
     * ユーザーを取得します。
     *
     * @param criteria
     * @param options
     * @return
     */
    @Select(strategy = SelectType.COLLECT)
    <R> R selectAll(final UserCriteria criteria, final SelectOptions options, final Collector<User, ?, R> collector);

    /**
     * ユーザーを1件取得します。
     *
     * @param id
     * @return
     */
    @Select
    Optional<User> selectById(Long id);

    /**
     * ユーザーを1件取得します。
     *
     * @param criteria
     * @return
     */
    @Select
    Optional<User> select(UserCriteria criteria);

    /**
     * ユーザーを登録します。
     *
     * @param user
     * @return
     */
    @Insert
    int insert(User user);

    /**
     * ユーザーを更新します。
     *
     * @param user
     * @return
     */
    @Update
    int update(User user);

    /**
     * ユーザーを論理削除します。
     *
     * @param user
     * @return
     */
    @Update(excludeNull = true) // NULLの項目は更新対象にしない
    int delete(User user);

    /**
     * ユーザーを一括登録します。
     *
     * @param users
     * @return
     */
    @BatchInsert
    int[] insert(List<User> users);

    /**
     * ユーザーを一括更新します。
     *
     * @param users
     * @return
     */
    @BatchUpdate
    int[] update(List<User> users);
}

```

```UserRepository
package com.sample.domain.repository.users;

import static com.sample.domain.util.DomaUtils.createSelectOptions;
import static java.util.Optional.ofNullable;
import static java.util.stream.Collectors.toList;

import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import com.sample.domain.dao.system.UploadFileDao;
import com.sample.domain.dao.users.UserDao;
import com.sample.domain.dao.users.UserRoleDao;
import com.sample.domain.dto.common.Page;
import com.sample.domain.dto.common.Pageable;
import com.sample.domain.dto.user.User;
import com.sample.domain.dto.user.UserCriteria;
import com.sample.domain.dto.user.UserRole;
import com.sample.domain.exception.NoDataFoundException;
import com.sample.domain.service.BaseRepository;

import lombok.val;

@Repository
public class UserRepository extends BaseRepository {

    @Autowired
    UserDao userDao;

    @Autowired
    UserRoleDao userRoleDao;

    @Autowired
    UploadFileDao uploadFileDao;

    /**
     * ユーザーを取得します。
     * 
     * @param criteria
     * @param pageable
     * @return
     */
    public Page<User> findAll(UserCriteria criteria, Pageable pageable) {
        // ページングを指定する
        val options = createSelectOptions(pageable).count();
        val data = userDao.selectAll(criteria, options, toList());
        return pageFactory.create(data, pageable, options.getCount());
    }

    /**
     * ユーザーを取得します。
     * 
     * @param criteria
     * @return
     */
    public Optional<User> findOne(UserCriteria criteria) {
        // 1件取得
        val user = userDao.select(criteria);

        // 添付ファイルを取得する
        user.ifPresent(u -> {
            val uploadFileId = u.getUploadFileId();
            val uploadFile = ofNullable(uploadFileId).map(uploadFileDao::selectById);
            uploadFile.ifPresent(u::setUploadFile);
        });

        return user;
    }

    /**
     * ユーザー取得します。
     *
     * @return
     */
    public User findById(final Long id) {
        return userDao.selectById(id).orElseThrow(() -> new NoDataFoundException("user_id=" + id + " のデータが見つかりません。"));
    }

    /**
     * ユーザーを追加します。
     *
     * @param inputUser
     * @return
     */
    public User create(final User inputUser) {

        // 1件登録
        userDao.insert(inputUser);

        // 役割権限紐付けを登録する
        val userRole = new UserRole();
        userRole.setUserId(inputUser.getId());
        userRole.setRoleKey("users");
        userRoleDao.insert(userRole);

        return inputUser;
    }

    /**
     * ユーザーを更新します。
     *
     * @param inputUser
     * @return
     */
    public User update(final User inputUser) {

        val uploadFile = inputUser.getUploadFile();
        if (uploadFile != null) {
            // 添付ファイルがある場合は、登録・更新する
            val uploadFileId = inputUser.getUploadFileId();
            if (uploadFileId == null) {
                uploadFileDao.insert(uploadFile);
            } else {
                uploadFileDao.update(uploadFile);
            }

            inputUser.setUploadFileId(uploadFile.getId());
        }

        // 1件更新
        int updated = userDao.update(inputUser);

        if (updated < 1) {
            throw new NoDataFoundException("user_id=" + inputUser.getId() + " のデータが見つかりません。");
        }

        return inputUser;
    }

    /**
     * ユーザーを論理削除します。
     *
     * @return
     */
    public User delete(final Long id) {
        val user = userDao.selectById(id)
                .orElseThrow(() -> new NoDataFoundException("user_id=" + id + " のデータが見つかりません。"));

        int updated = userDao.delete(user);

        if (updated < 1) {
            throw new NoDataFoundException("user_id=" + id + " は更新できませんでした。");
        }

        return user;
    }
}

```

このようにRepositoryにてDaoをAutoweredしてメソッドを使用しています。

### 私の中のDaoとRepository
私の中で２つは「デザインパターンレベルでのデータを取得したり、操作するもの」という認識で、大きな違いはないと理解していました。
ただ今回使い分けているんだからなんか違うんだろう、そして同じプロジェクトで同じ階層で使用すべきものなのだろうと思って調査をしました。

１.DaoとRepositoryのすみ分け

```ここに言語を入力
Repositoryはドメインオブジェクトを見て、DAOはデータ・ソースのマッピングするDTOの方を見る

```
「ベクトルが違うのはなんとなく伝わるけどまだわからない」
次！！！

2.[リポジトリとDaoの住み分け方](http://blog.fukuchiharuki.me/entry/use-repository-and-dao-according-to-the-purpose)より

```ここに言語を入力
・リポジトリはドメインオブジェクトのコレクション
・DAOはデータアクセスのメカニズムを隠蔽する

・リポジトリの実装はドメインオブジェクトの構築です。

```
んー、頭の中で噛み砕けない。。。
恥ずかしながら私はデザインパターンを学んだ事がなく、こういう話は理解するのに苦労します。


SESの世界に例えた時に、簡単に言うと「二次請け企業と三次請け企業」のようにレイヤーが異なるという事でしょうか？
もう少し抽象的で構わないので子供に理解できるレベルの日本語で解説するとしたらどのような感じになりますでしょうか？
ご意見をよろしくお願いします。
また、皆さんの現場ではDaoとRepositoryは分けられていますか？

DaoとRepositoryの使い方

### 前提・実現したいこと
ViewModel(VM)とModelの区別が未だにつきません。

以下の記事のコードの例を出しますと、
[サンプルコードを見ながら理解するMVVMの基礎的な実装](http://kaorun.hatenablog.com/entry/20141202/1417532472)

チュートリアルとして、Personクラスが最初にModelとして実装されています。
しかしこれでは更新されないので、INotifyPropertyChangedを実装してPersonViewModelにしています。

Modelとして実装したはずのPersonクラスが、Viewと結びつかせるためにVMになりました。
そうなるとModelとはいったい何なのでしょうか。
データを保持したり、その処理を書くのがModelだと聞きますが、上の例だとVMがModelのようにデータを保持しているように感じます。

###
最初は、VMとModelを完全に別にするとなると、以下のようにPersonVMクラスの中にPersonのインスタンスを作ってラップするのではないかと考えました。
```C#
PersonVM : INotifyPropertyChanged //(1)
{
    Person person = new Person();
    public int Age{
        get => person.Age;
        set {
            person.Age = value;
            NotifyPropertyChanged(nameof(Age));
        }
    }
}
```
しかしこのようにVMとMを分けると、Personに対して操作しても変更通知されません。

また、ReactivePropertyの意味や使い方がよくわからなくなってしまいます。

```C#
//こう書くのがReactivePropertyの使い方だと思っていたが、VMとModelを兼任しているためMVVMにはならない？
PersonVM : INotifyPropertyChanged //(2)
{
    public ReactiveProperty<int> Age{get;} = new ReactiveProperty<int>();
}

//Modelに代入させることはできても、結局Modelのインスタンス内の変更通知はVMにもVにも飛ばない。
//逆に、ModelからVMに変更通知が必要な設計が間違い？
PersonVM : INotifyPropertyChanged //(3)
{
    Person person = new Person();

    public PersonVM(){
        Age.Subscribe(x => person.Age = x);
    }
    public ReactiveProperty<int> Age{get;}= new ReactiveProperty<int>();
}
```

このPersonクラスをバイナリなりテキストなりでエクスポートする実装をするとして、
ViewModelのCommandの中で出力処理を書いてしまうのはNGだと聞きます。

(1)や(3)ならPersonクラスにメソッドを入れるなり、Personクラスを引数にするメソッドをどっかに作ったりとやりようがありますが、
(2)のようなパターンだとPersonVM内に作るか、PersonVMを引数にとらなくてはならなくなってしまいます。

データ出力のためにVMが必要ならば、それはVMがデータを保持している。つまりVMでもありModelでもあるという状況になっていないでしょうか。

このように、私の中でModelとVMの境目、分け方がわからなくなってしまい混乱しています。
どこかにMVVMの解釈に関して誤解がないか。また、どのような形でMVVMを実装するのが正しいのかの助言をいただきたいです。

よろしくお願いいたします。

MVVMにおける、ViewModelとModelの違い、境界線について

複数のクラスで共通で利用する変数がありますが、どのように管理するのが良いのでしょうか。

例えば、ClassA,ClassB,ClassCで共通で利用する変数があります。この変数は、それぞれのクラスで読み込んで利用したり、値を変えたりします。

この変数を仮にClassAのメンバー変数にしてgetter、setterのメソッドを作りClassB,ClassCにClassAのsetterメソッドを作りそれでsetして上記の変数をそれぞれのクラスで利用出来るようにしたのですが、密結合だし、なんか変です。

どのようにすべきかご教示お願いします。

```Java

class A {
        int value;

        int getValue() {
            return value;
        }

        void setValue(int value) {
            this.value = value;
        }
    }
    
    class B {
        A a;

        void setA(A a) {
            this.a = a;
        }
    }

    class C {
        A a;

        void setA(A a) {
            this.a = a;
        }
    }
```

複数のクラスで共通で利用する変数をどのように管理するか。

現在javaの勉強中なのですが
以下のような流れの処理をボタンを押された際に呼び出されるメソッドに丸ごと詰め込んでいる状態です。

1.トランザクション開始
2.テーブルAからデータ取得
3.なんかいろいろ処理
4.テーブルBにデータ登録
5.トランザクション終了（コミット）

これをDAOを使った作りに書きなおしてみたいと思ったのですが、
その場合トランザクションの管理はどこで行うべきなのでしょうか？

パッと思いついたのは以下の2つです。
①1～5全てをDAOの1つのメソッドに詰め込む。
　トランザクションの管理はDAOのメソッド内で行う

②1,3,5はビジネスロジックにして2,4は個別のメソッドとして定義する。
　トランザクションの管理はビジネスロジックで行いDAOには引数等でトランザクションを渡すようにする。

しかし、①にした場合DAOにビジネスロジックが入っていしまう上にメソッドの粒度が大きくなりすぎる気がします（呼び出し元が何もしないでDAOのメソッド呼び出すだけなので元々と変わらないですし）。
②の方法にすると何となく解決は出来そうなんですがDAOを使った開発のパターンとして正しいものなのかどうかがわからないです。

フレームワーク等を使えばそれらが上手いことやってくれるらしいので気にしなくていいのかもしれませんが、
別の言語でも同じ問題にぶつかる可能性が高いですし、初学者なのでそれらに頼らずに自分で管理するように書いてみたいと思っています。

よろしくお願いします。

DAOを使う場合にトランザクション管理は何処で行うべきでしょうか？

「Java言語で学ぶデザインパターン入門」を元にデザインパターンを学習していますが、
Iteratorパターンを使うべきケースが理解できません。

書籍内のサンプルでは本の集合を表すBookShelfクラスにて、下記2つのメソッドを定義しています。
 ・本の冊数を返す。 int getLength ( )
 ・index番目の本を返す。 Book getBookAt ( int index )

MainクラスにてIteratorパターンを用いて、下記のように走査してますが、
```lang-java
Iterator it = book_shelf.iterator();
		while(it.hasNext()) {
			Book book = (Book)it.next();
			System.out.println(book.getName());
		}
```
Iteratorパターンを用いずに下記のようなfor文で問題ないと考えてます。

```lang-java
		for (int i = 0; i < bookShelf.getLength(); i++) {
			Book book = bookShelf.getBook(i);
			System.out.println(book.getName());
		}
```
Iteratorパターンのメリットは
> BookShelfクラスの実装を、現状の配列ではなく、Vectorを使うようにしても、BookShelfクラスを利用する側は変更しなくて済む。
と説明されてますが、これは「int getLength()」メソッドと「Book getBookAt()」が同じように機能するのであれば、forループの場合と比べて何ら変わりありません。

上記を踏まえた上で、Iteratorパターンのメリット、使うべきケースについてご教示頂けますと幸いです。

# なお、似たような記事を見つけましたが、こちらの内容ではいまいち理解できませんでした。
# http://www.aerith.net/design/Iterator-j.html

下記、参考までにソースを記載致します。

Aggregate.java
```lang-java
public interface Aggregate {

	public abstract Iterator iterator();
}
```
Iterator.java
```lang-java
public interface Iterator {
	public abstract boolean hasNext();
	public abstract Object next();
}
```
BookShelf.java
```lang-java
import java.util.*;

public class BookShelf implements Aggregate {

	private List<Book> books = new ArrayList<Book>();
	public Book getBook(int index) {
		return books.get(index);
	}
	public void appendBook(Book book) {
		books.add(book);
	}
	public int getLength() {
		return books.size();
	}
	public Iterator iterator() {
		return new BookShelfIterator(this);
	}
}
```
BookShelfIterator .java
```lang-java
public class BookShelfIterator implements Iterator {

	private BookShelf bookShelf;
	private int index;

	public BookShelfIterator(BookShelf bookShelf) {
		this.bookShelf = bookShelf;
		this.index = 0;
	}

	public boolean hasNext() {
		if (index < bookShelf.getLength()) {
			return true;
		} else {
			return false;
		}
	}

	public Object next() {
		Book book = bookShelf.getBook(index);
		index++;
		return book;
	}
}
```
Main.java
```lang-＜ここに言語を入力＞
public class Main {

	public static void main(String[] args) {

		BookShelf bookShelf = new BookShelf();
		bookShelf.appendBook(new Book("Around the World in 80 Days"));
		bookShelf.appendBook(new Book("Bible"));
		bookShelf.appendBook(new Book("Cinderella"));
		bookShelf.appendBook(new Book("Daddy-Long-Legs"));

		Iterator it = bookShelf.iterator();

		while(it.hasNext()) {
			Book book = (Book)it.next();
			System.out.println(book.getName());
		}

		//for (int i = 0; i < bookShelf.getLength(); i++) {
		//	Book book = bookShelf.getBook(i);
		//	System.out.println(book.getName());
		//}
	}
}
```