オブジェクト指向って結局何が嬉しいの？？①



# オブジェクト指向って結局何が嬉しいかわかりづらくない？

新人研修のjava研修とかでもオブジェクト指向は習った気がしたが、当時はあまりピンときていなかった。
というのも、カプセル化、継承、ポリモフィズムなどの用語と概念、実装法はなんとなくわかっても、なんのためにそれらが存在するのかに関しては全く理解できていなかった。（メリットに関する説明は研修でも少なかった気がする）

いまでも全てを理解してるとは全く思えてないが、少なくともこんな嬉しさがあるんじゃないか？という学びを少しずつ共有していくシリーズにしたい。



# あらためて、オブジェクト（クラス）とは
オブジェクト指向におけるクラスは、

・インスタンス変数（属性）
・メソッド（ふるまい）

から構成されるのが基本である。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2602910/ab8c0a0c-112c-a949-47d6-68329e7ecebb.png)

これの何が嬉しいの？？

# ”インスタンス変数のルールをメソッド内に記述する”ことでメリットを享受できる

オブジェクト指向において（というかメリットを享受するために）重要なポイントは**インスタンス変数のルールをメソッド内に記述する**ことである。
※ここでいうルールとは、「age（年齢）は0以上の整数である」みたいなやつ

こうするとなぜ嬉しいのか？？

結論
**1. 不正な値の混入を防ぐことができる（保守性を高める）**
**2. ロジックの散在を防ぐことができる（凝集度を上げ、変更容易性を高める）**
からである。


抽象的な表現になってしまったので、具体例をふまえてより詳細にみていく↓↓

## 1. 不正な値の混入を防ぐことができる

 あるシステムのUserクラスがあるとする。
属性と、コンストラクタ、setter/getterがあるとして、こんな感じになる。

~~~java
class User{
    //属性
    private int age;
    private String name;

    //コンストラクタ
    public User(int age, String name){
        this.age = age;
        this.name = name;
    }

    //getter
    public int getAge(){
        return this.age;
    }

    public String getName(){
        return this.name;
    }

    //setter
    public void setAge(int age){
        this.age = age;
    }

    public void setName(String name){
        this.name = name;
    }
}
~~~
こんな感じになる。

しかし、このクラスは**インスタンス変数のルールをメソッド内に記述する**ことができていない。

この状況の何がまずいか？？例えばこんな実装ができてしまう↓
~~~java
User user = new User(-100, null);
System.out.println(user.getAge()); //出力結果：-100
System.out.println(user.getName()); //出力結果：null
~~~

年齢が-100歳で名前がないUserが誕生してしまう。。
このことにきづかずDBにおかしなデータを入れ込んでしまったり、思わぬところでバグを発生させてしまうリスクを埋め込んでしまっている。。。

こういったことを防ぐためにコンストラクタに**インスタンス変数のルールを記述する！**

今回は
age →　0以上の整数
name →　null以外の文字列
というルールであるとする。

~~~java
class User{

//~~省略

    public User(int age, String name){
        if(age < 0){
            throw new IllegalArgumentException("年齢が0以上でありません");
        }
        if(name == null){
            throw new NullPointerException("名前を設定してください");
        }
        this.age = age;
        this.name = name;
    }

//~~省略

}
~~~

引数でわたってきた年齢（age）の値がマイナスの時や、名前（name）の値がnullの時は例外を投げるような処理を追加している。

このことにより、不正な値をもったUserクラスの存在を防ぎ、DBにおかしなデータを入れ込んでしまうリスクや、思わぬところでバグを発生させてしまうリスクを回避している。

コンストラクタだけでなく、setterも修正

~~~java
    public void setAge(int age){
        if(age < 0){
            throw new IllegalArgumentException("年齢が0以上でありません");
        }
        this.age = age;
    }

    public void setName(String name){
        if(name == null){
            throw new NullPointerException("名前を設定してください");
        }
        this.name = name;
    }
~~~
値を変更する際につかうメソッドにおいても入力チェックをかますことで、不正値の混入を防ぐことができる。

## 2. ロジックの散在を防ぐことができる

Userクラスが属性と、コンストラクタ、setter/getterだけのデータクラス（つまりインスタンス変数のルールをメソッド内に記述されていない状態）だったとしても、Userクラスの外で値を設定する前に入力チェックを行えばいいのでないか？と思われた方もいるかもしれない。

例えばUserクラスをつかって、ユーザーを新規作成処理があるとする
~~~java
//ユーザー新規作成処理
public void CreateUser(int age, String name){
    if(age < 0){
        throw new IllegalArgumentException("年齢が0以上でありません");
    }
    if(name == null){
        throw new NullPointerException("名前を設定してください");
    }
    User user = new User(age, name);
    //略
}
~~~
Userクラスの外で、name,ageのルールのチェックをしている。
たしかに局所的にはこのコードは全く問題ない。
しかし次に、ユーザー情報を更新する処理も追加でつくることになったとする。

~~~java
//ユーザー情報更新処理
public void UpdateUser(int age, String name){
    if(age < 0){
        throw new IllegalArgumentException("年齢が0以上でありません");
    }
    if(name == null){
        throw new NullPointerException("名前を設定してください");
    }
    user.setAge(age);
    user.setName(name);
}
~~~

更新処理の方にも、Userクラスに値を設定する前の入力チェックが必要となるので、新規追加処理と同じ処理がかかれ、コードは重複することになる。


これのなにがまずいか？？
このようなコードの重複が引き起こす弊害は、**仕様変更が必要となった時に表れる。**

たとえば名前(name)のルールとして、nullを不許可にするだけでなく、”3文字以上の文字列”というルールを追加するという仕様変更があったとする。

nameのルールをUserクラスのメソッド内に記述せず、新規作成処理、更新処理に書いていた場合、書き換える箇所が新規作成処理、更新処理の最低２箇所。
~~~java
//ユーザー新規追加処理
public void CreateUser(int age, String name){
    if(age < 0){
        throw new IllegalArgumentException("年齢が0以上でありません");
    }
    if(name == null){
        throw new NullPointerException("名前を設定してください");
    }
    //New!
    if(name.length() < 3){
        throw new IllegalArgumentException("名前は3文字以上で設定してください");
    }
    User user = new User(age, name);
    //略
}
~~~

~~~java
//ユーザー情報更新処理
public void UpdateUser(int age, String name){
    if(age < 0){
        throw new IllegalArgumentException("年齢が0以上でありません");
    }
    if(name == null){
        throw new NullPointerException("名前を設定してください");
    }
    //New!
    if(name.length() < 3){
        throw new IllegalArgumentException("名前は3文字以上で設定してください");
    }
    user.setAge(age);
    user.setName(name);
}
~~~


今後の拡張によってはより多くの箇所（Userクラスを更新するすべての箇所）を修正しなければならない。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2602910/1ceba262-401d-7872-3a7f-7935530fe907.png)


つまり仕様変更の際に修正しなければならない箇所の数が跳ね上がり、変更コストが高くなる。（このようなソースコードを**変更容易性が低い**という。）


一方、Userクラスのメソッド（コンストラクタやセッター）内にルールを記述している場合は、ルールの変更に対するコードの変更箇所がUserクラス内で閉じるようになる。
~~~java
class User{
  //略
    public User(int age, String name){
        if(age < 0){
            throw new IllegalArgumentException("年齢が0以上でありません");
        }
        //ここを追加するだけで良い
        if(name.length() < 3){
            throw new IllegalArgumentException("名前は3文字以上で設定してください");
        }
        if(name == null){
            throw new NullPointerException("名前を設定してください");
        }
        this.age = age;
        this.name = name;
    }
~~~
新規作成処理や更新処理は以下のような処理となり、nameのルールの変更による修正は発生しない。
~~~java
//ユーザー新規追加処理
public void CreateUser(int age, String name){
    User user = new User(age, name);
    //略
}

//ユーザー情報更新処理
public void UpdateUser(int age, String name){
    user.setAge(age);
    user.setName(name);
}
~~~

このように属性と属性に対するロジックがクラス内にまとめられているコードを**凝集度が高い**といい、変更容易性を確保できる。

# 【発展】”インスタンス変数のルールをメソッド内に記述する”ことで、業務ルールをオブジェクトに埋め込む

というところまで書きたかったんですが時間切れで書けませんでした。また次回以降やります。
過去記事も参照してみてください。
https://qiita.com/shuma_horii/private/c450c9dc5db616789690

また今回の話を言い換えると、各々のオブジェクトは「自身の属性を正常に制御する」という単一の責任を負っているともみることができる。
※以下記事参照
https://qiita.com/MinoDriven/items/76307b1b066467cbfd6a

この辺りはまた続編で、、

# まとめ
結論、「インスタンス変数のルールをメソッド内に記述する」つまりそのクラスのルールはクラス内に書く、ことで高凝集なクラスとなり、保守性、変更容易性を確保できる。

「データとそのデータに関するロジックをひとつのクラスにまとめておける」というオブジェクト指向ならではの嬉しさである。


# 参考記事&書籍

https://qiita.com/MinoDriven/items/76307b1b066467cbfd6a

https://qiita.com/MinoDriven/items/5e69d9bd028aa350e2c4

https://www.amazon.co.jp/%E3%83%89%E3%83%A1%E3%82%A4%E3%83%B3%E9%A7%86%E5%8B%95%E8%A8%AD%E8%A8%88%E5%85%A5%E9%96%80-%E3%83%9C%E3%83%88%E3%83%A0%E3%82%A2%E3%83%83%E3%83%97%E3%81%A7%E3%82%8F%E3%81%8B%E3%82%8B-%E3%83%89%E3%83%A1%E3%82%A4%E3%83%B3%E9%A7%86%E5%8B%95%E8%A8%AD%E8%A8%88%E3%81%AE%E5%9F%BA%E6%9C%AC-%E6%88%90%E7%80%AC-%E5%85%81%E5%AE%A3/dp/479815072X/ref=asc_df_479815072X/?tag=jpgo-22&linkCode=df0&hvadid=418292279020&hvpos=&hvnetw=g&hvrand=5336659568935952057&hvpone=&hvptwo=&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=1009540&hvtargid=pla-878099275802&psc=1&th=1&psc=1

https://www.amazon.co.jp/%E8%89%AF%E3%81%84%E3%82%B3%E3%83%BC%E3%83%89-%E6%82%AA%E3%81%84%E3%82%B3%E3%83%BC%E3%83%89%E3%81%A7%E5%AD%A6%E3%81%B6%E8%A8%AD%E8%A8%88%E5%85%A5%E9%96%80-%E2%80%95%E4%BF%9D%E5%AE%88%E3%81%97%E3%82%84%E3%81%99%E3%81%84-%E6%88%90%E9%95%B7%E3%81%97%E7%B6%9A%E3%81%91%E3%82%8B%E3%82%B3%E3%83%BC%E3%83%89%E3%81%AE%E6%9B%B8%E3%81%8D%E6%96%B9-%E4%BB%99%E5%A1%B2/dp/4297127830/ref=asc_df_4297127830/?tag=jpgo-22&linkCode=df0&hvadid=553968464768&hvpos=&hvnetw=g&hvrand=16097725659414741880&hvpone=&hvptwo=&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=1009540&hvtargid=pla-1645485583101&psc=1&th=1&psc=1