プログラミング – ページ 12 – サイゼントの技術ブログ

2020年12月25日

JavaScript：動的型付けとは

JavaやC#に慣れている人だとJavaScriptの動的型付けの概念に戸惑うと思うので、この記事では動的型付けについて簡単にまとめてみます。

JavaScriptには、下記の７つのプリミティブ型（ECMAScript 2015の場合）とObject型が存在します。

型	説明
Boolean	真偽値を示す。true または false
null	null値を示す。
undefined	未定義の値を示す。
Number	浮動小数点型を示す。例１：100 例２：123.45
BigInt	整数型を示す。例：123n（これで整数の123の意味となる）
String	文字列型を示す。例：”Hoge”
Symbol	名前空間の衝突を防ぐ特殊な型。言語仕様の拡張等で用いられる。

JavaScriptの場合、下記のように変数を定義します。
型名を指定するのではなく、”let”というキーワードで変数であることを示します。

let hoge = 1;

1	let hoge = 1;

※補足

“let”の代わりに”var”や”const”で変数を定義することもできます。
“var”で定義した変数は、定義したブロックの外でも参照可能になります。
“const”で定義した変数は定数となり、上書きができなくなります。

どのような型でも”let”で変数定義できる、という話であれば、JavaやC#の型推論と同じような話になります。
しかし、JavaScriptの動的型付けは、型推論とは異なる点もあります。

JavaScriptでは、一度変数を定義した後に、定義した時とは異なる型の値を代入することが許されます。

例えば、下記のコードでは、Number型の変数を定義した後にString型の値”Hello World!”を代入していますが、異常終了することなくコンソール上に”Hello World!”と出力されます。

let hoge = 1;
hoge = "Hello World!";
console.log(hoge);

let hoge = 1;

hoge = "Hello World!";

console.log(hoge);

なお、JavaやC#では一度変数の型を定義した後に異なる型の値を代入することは許されておらず、コンパイルエラーとなります。
この挙動の違いを理解していないと、バグ調査する際の絞り込みが難しくなることがあるので、注意が必要です。

いかがでしたでしょうか？

JavaやC#の経験者がJavaScriptを触ると動的型付けの概念に戸惑うと思うので、記事にしてみました。
他にも、整数型の扱いについても戸惑うのではないかと思っています。これは別の機会に記事にしたいと思います。

ちなみに、この記事でちょうど100記事目になりました！
今まで見て下さった方々、ありがとうございます。
これからもブログを続けていきますので、よろしくお願いします。

2020年12月11日

JavaScriptでHelloWorld（ブラウザ上に文字表示）

JavaScriptはCUIでも実行できますが、GUIで使うケースの方が多いので、GUIでHelloWorldを書いてみました。
JavaScriptのHelloWorldはログに出力したりポップアップ表示したりするものが多いですが、ブラウザ上に出力した方がJavaScriptっぽい気がするので、ブラウザ上に表示するサンプルを提示します。

【サンプルコード１】

・Sample.html

＜!DOCTYPE html＞
＜html lang="ja"＞
  ＜head＞
    ＜!-- charsetがutf-8なので、このファイルもutf-8で保存する必要がある --＞
    ＜meta charset="utf-8"＞
    ＜title＞Sample＜/title＞
  ＜/head＞
  ＜body＞
    ＜script＞
      // window.onloadでロード時に実行される
      window.onload = function(){
        // documentはブラウザに読み込まれたウェブページを表す
        // getElementByIdでHTML上で使うidを参照する
        // innerHTMLではHTML要素の内容を書き変える
        document.getElementById("sample").innerHTML
          = "Hello World!＜br＞↑JavaScriptによる出力";
      }
    ＜/script＞
    ＜p id="sample"＞＜/p＞
  ＜/body＞
＜/html＞

＜!DOCTYPE html＞

＜html lang="ja"＞

＜head＞

＜!-- charsetがutf-8なので、このファイルもutf-8で保存する必要がある --＞

＜meta charset="utf-8"＞

＜title＞Sample＜/title＞

＜/head＞

＜body＞

＜script＞

// window.onloadでロード時に実行される

window.onload = function(){

// documentはブラウザに読み込まれたウェブページを表す

// getElementByIdでHTML上で使うidを参照する

// innerHTMLではHTML要素の内容を書き変える

document.getElementById("sample").innerHTML

= "Hello World!＜br＞↑JavaScriptによる出力";

}

＜/script＞

＜p id="sample"＞＜/p＞

＜/body＞

＜/html＞

【結果１】

・Sample.htmlをChromeで開いた結果

サンプルコード１のようにJavaScriptはHTML内に書くことができますが、サンプルコード２のようにJavaScriptを別ファイルにするケースの方が多いと思いますので、別ファイルにするサンプルも提示します。

【サンプルコード２】

・Sample.html

＜!DOCTYPE html＞
＜html lang="ja"＞
  ＜head＞
    ＜meta charset="utf-8"＞
    ＜title＞Sample＜/title＞
  ＜/head＞
  ＜body＞
    ＜!-- src属性で外部のスクリプトを指定できる --＞
    ＜script src="Sample.js"＞＜/script＞
    ＜p id="sample"＞＜/p＞
  ＜/body＞
＜/html＞

＜!DOCTYPE html＞

＜html lang="ja"＞

＜head＞

＜meta charset="utf-8"＞

＜title＞Sample＜/title＞

＜/head＞

＜body＞

＜!-- src属性で外部のスクリプトを指定できる --＞

＜script src="Sample.js"＞＜/script＞

＜p id="sample"＞＜/p＞

＜/body＞

＜/html＞

・Sample.js

window.onload = function(){
  document.getElementById("sample").innerHTML
    = "Hello World!＜br＞↑JavaScriptによる出力";
}

window.onload = function(){

document.getElementById("sample").innerHTML

= "Hello World!＜br＞↑JavaScriptによる出力";

}

【結果２】

結果１と同じため割愛

いかがでしたでしょうか。

JavaScriptは広く使われている言語であり、面談時点でJavaScriptのスキルを求められない現場でもJavaScriptを使うことがあります。
他言語に精通している技術者であっても、JavaScriptには慣れておいた方が無難だと思います。

2020年12月4日

テーブル結合の失敗パターン

RDBMSでのSQLによる問い合わせにおいて、複数のテーブルを結合するパターンは比較的複雑な操作になります。
そのため、ミスも起こりやすいです。

今回は、注意喚起のため、私が実務で出くわしたミスを３つ挙げます。

１．外部結合の結合条件をwhere句に書いてしまい内部結合になってしまう

２．結合条件指定不足で意図せず直積結合してしまう

３．結合条件となる値のセットを誤り結合できなくなってしまう

１．外部結合の結合条件をwhere句に書いてしまい内部結合になってしまう

例えば、以下のようなテーブルがあるとします。

・ログイン日時管理テーブル

create table user_info
(
user_id CHAR(4) NOT NULL, --ユーザID
last_access_date CHAR(8) NOT NULL, --最終アクセス日
PRIMARY KEY (user_id)
);
insert into user_info values("0001","20200301");
insert into user_info values("0002","20200301");

create table user_info

(

user_id CHAR(4) NOT NULL, --ユーザID

last_access_date CHAR(8) NOT NULL, --最終アクセス日

PRIMARY KEY (user_id)

);

insert into user_info values("0001","20200301");

insert into user_info values("0002","20200301");

・ユーザ名履歴テーブル

create table user_name
(
user_id CHAR(4) NOT NULL, --ユーザID
start_date CHAR(8) NOT NULL, --有効開始日
end_date CHAR(8) NOT NULL, --有効終了日
user_name VARCHAR(10) NOT NULL, --ユーザ名
PRIMARY KEY (user_id,start_date)
);
insert into user_name values("0001","20190101","20191231","hoge1");
insert into user_name values("0001","20200101","99991231","hoge2");
insert into user_name values("0002","20190101","20191231","piyo");

create table user_name

(

user_id CHAR(4) NOT NULL, --ユーザID

start_date CHAR(8) NOT NULL, --有効開始日

end_date CHAR(8) NOT NULL, --有効終了日

user_name VARCHAR(10) NOT NULL, --ユーザ名

PRIMARY KEY (user_id,start_date)

);

insert into user_name values("0001","20190101","20191231","hoge1");

insert into user_name values("0001","20200101","99991231","hoge2");

insert into user_name values("0002","20190101","20191231","piyo");

ここで、

・ユーザがログインした時のユーザ名を知りたい

・ただし、ユーザがログインした時、ユーザ名が存在しない場合がある

（この場合、ユーザ名が存在していない旨を知りたい）

という要件があった場合を考えます。

正しいselect文と問い合わせ結果は以下です。

select    i.user_id,
          n.user_name
from      user_info i
left join user_name n
on       (i.user_id = n.user_id)
and      (i.last_access_date ＞= n.start_date
and       i.last_access_date ＜= n.end_date);
+---------+-----------+
| user_id | user_name |
+---------+-----------+
| 0001    | hoge2     |
| 0002    | NULL      |
+---------+-----------+
2 rows in set (0.00 sec)

select i.user_id,

n.user_name

from user_info i

left join user_name n

on (i.user_id = n.user_id)

and (i.last_access_date ＞= n.start_date

and i.last_access_date ＜= n.end_date);

+---------+-----------+

| user_id | user_name |

+---------+-----------+

| 0001 | hoge2 |

| 0002 | NULL |

+---------+-----------+

2 rows in set (0.00 sec)

もし、ここで、誤って結合条件の一部をwhere句に記述すると、下記のようになります。
左側外部結合なのに、左側のテーブルにしか存在しないレコードが抽出されません。

select    i.user_id,
          n.user_name
from      user_info i
left join user_name n
on       (i.user_id = n.user_id)
where    (i.last_access_date ＞= n.start_date
and       i.last_access_date ＜= n.end_date);
+---------+-----------+
| user_id | user_name |
+---------+-----------+
| 0001    | hoge2     |
+---------+-----------+
1 row in set (0.00 sec)

select i.user_id,

n.user_name

from user_info i

left join user_name n

on (i.user_id = n.user_id)

where (i.last_access_date ＞= n.start_date

and i.last_access_date ＜= n.end_date);

+---------+-----------+

| user_id | user_name |

+---------+-----------+

| 0001 | hoge2 |

+---------+-----------+

1 row in set (0.00 sec)

誤ったSQL文については下記①②のような動きになるため、このような結果になります。

① on句に指定された条件で左側外部結合を行う

select    i.*,
          n.*
from      user_info i
left join user_name n
on       (i.user_id = n.user_id);
+---------+------------------+---------+------------+----------+-----------+
| user_id | last_access_date | user_id | start_date | end_date | user_name |
+---------+------------------+---------+------------+----------+-----------+
| 0001    | 20200301         | 0001    | 20190101   | 20191231 | hoge1     |
| 0001    | 20200301         | 0001    | 20200101   | 99991231 | hoge2     |
| 0002    | 20200301         | 0002    | 20190101   | 20191231 | piyo      |
+---------+------------------+---------+------------+----------+-----------+
3 rows in set (0.00 sec)

select i.*,

n.*

from user_info i

left join user_name n

on (i.user_id = n.user_id);

+---------+------------------+---------+------------+----------+-----------+

+---------+------------------+---------+------------+----------+-----------+

| 0001 | 20200301 | 0001 | 20190101 | 20191231 | hoge1 |

| 0001 | 20200301 | 0001 | 20200101 | 99991231 | hoge2 |

| 0002 | 20200301 | 0002 | 20190101 | 20191231 | piyo |

+---------+------------------+---------+------------+----------+-----------+

3 rows in set (0.00 sec)

② ①の結果に対して、where句とselect句が評価される。

（where句で条件指定した場合、内部結合と同じようになる）

２．結合条件指定不足で意図せず直積結合してしまう

例えば、以下のようなテーブルがあるとします。

・社員マスタテーブル

create table employee_master
(
company_id CHAR(3) NOT NULL, --会社コード
employee_id CHAR(7) NOT NULL, --社員コード
employee_name VARCHAR(20), --社員名
PRIMARY KEY (company_id,employee_id)
);
insert into employee_master values("001","0000001","Employee_A");
insert into employee_master values("001","0000002","Employee_B");
insert into employee_master values("001","0000003","Employee_C");
insert into employee_master values("002","0000001","Employee_D");

create table employee_master

(

company_id CHAR(3) NOT NULL, --会社コード

employee_id CHAR(7) NOT NULL, --社員コード

employee_name VARCHAR(20), --社員名

PRIMARY KEY (company_id,employee_id)

);

insert into employee_master values("001","0000001","Employee_A");

insert into employee_master values("001","0000002","Employee_B");

insert into employee_master values("001","0000003","Employee_C");

insert into employee_master values("002","0000001","Employee_D");

・保有資格管理テーブル

create table owned_licence
(
company_id CHAR(3) NOT NULL, --会社コード
employee_id CHAR(7) NOT NULL, --社員コード
licence_id CHAR(3) NOT NULL, --資格コード
PRIMARY KEY (company_id,employee_id,licence_id)
);
insert into owned_licence values("001","0000001","001");
insert into owned_licence values("001","0000002","001");
insert into owned_licence values("001","0000003","001");
insert into owned_licence values("001","0000003","002");
insert into owned_licence values("002","0000001","001");

create table owned_licence

(

company_id CHAR(3) NOT NULL, --会社コード

employee_id CHAR(7) NOT NULL, --社員コード

licence_id CHAR(3) NOT NULL, --資格コード

PRIMARY KEY (company_id,employee_id,licence_id)

);

insert into owned_licence values("001","0000001","001");

insert into owned_licence values("001","0000002","001");

insert into owned_licence values("001","0000003","001");

insert into owned_licence values("001","0000003","002");

insert into owned_licence values("002","0000001","001");

ここで、会社コードが”001″の会社の全社員が保有している資格を取得したいとします。

正しいselect文と問い合わせ結果は以下です。

select ol.licence_id
from   employee_master em
join   owned_licence ol
on     em.company_id = ol.company_id
and    em.employee_id = ol.employee_id
where  em.company_id = "001";
+------------+
| licence_id |
+------------+
| 001        |
| 001        |
| 001        |
| 002        |
+------------+
4 rows in set (0.00 sec)

select ol.licence_id

from employee_master em

join owned_licence ol

on em.company_id = ol.company_id

and em.employee_id = ol.employee_id

where em.company_id = "001";

+------------+

| licence_id |

+------------+

| 001 |

| 002 |

+------------+

4 rows in set (0.00 sec)

もし、ここで誤って結合条件に社員コードを含めないと、以下のように実際に保有している資格数よりも多く出力されてしまいます。

select ol.licence_id
from   employee_master em
join   owned_licence ol
on     em.company_id = ol.company_id
where  em.company_id = "001";
+------------+
| licence_id |
+------------+
| 001        |
| 001        |
| 001        |
| 002        |
| 001        |
| 001        |
| 001        |
| 002        |
| 001        |
| 001        |
| 001        |
| 002        |
+------------+
12 rows in set (0.00 sec)

select ol.licence_id

from employee_master em

join owned_licence ol

on em.company_id = ol.company_id

where em.company_id = "001";

+------------+

| licence_id |

+------------+

| 001 |

| 002 |

| 001 |

| 002 |

| 001 |

| 002 |

+------------+

12 rows in set (0.00 sec)

なぜこうなるのかは、select文で全カラム指定すればよくわかると思います。
社員マスタテーブル.社員コードと保有資格管理テーブル.社員コードが一致しないレコードについても結合してしまうため、意図せずに直積結合が起こり、実際に保有している資格数よりも多く出力されてしまいます。

select *
from   employee_master em
join   owned_licence ol
on     em.company_id = ol.company_id
where  em.company_id = "001";
+----------+-----------+-------------+----------+-----------+----------+
|company_id|employee_id|employee_name|company_id|employee_id|licence_id|
+----------+-----------+-------------+----------+-----------+----------+
|001       |0000001    |Employee_A   |001       |0000001    |001       |
|001       |0000001    |Employee_A   |001       |0000002    |001       |
|001       |0000001    |Employee_A   |001       |0000003    |001       |
|001       |0000001    |Employee_A   |001       |0000003    |002       |
|001       |0000002    |Employee_B   |001       |0000001    |001       |
|001       |0000002    |Employee_B   |001       |0000002    |001       |
|001       |0000002    |Employee_B   |001       |0000003    |001       |
|001       |0000002    |Employee_B   |001       |0000003    |002       |
|001       |0000003    |Employee_C   |001       |0000001    |001       |
|001       |0000003    |Employee_C   |001       |0000002    |001       |
|001       |0000003    |Employee_C   |001       |0000003    |001       |
|001       |0000003    |Employee_C   |001       |0000003    |002       |
+----------+-----------+-------------+----------+-----------+----------+
12 rows in set (0.00 sec)

select *

from employee_master em

join owned_licence ol

on em.company_id = ol.company_id

where em.company_id = "001";

+----------+-----------+-------------+----------+-----------+----------+

+----------+-----------+-------------+----------+-----------+----------+

|001 |0000001 |Employee_A |001 |0000001 |001 |

|001 |0000001 |Employee_A |001 |0000002 |001 |

|001 |0000001 |Employee_A |001 |0000003 |001 |

|001 |0000001 |Employee_A |001 |0000003 |002 |

|001 |0000002 |Employee_B |001 |0000001 |001 |

|001 |0000002 |Employee_B |001 |0000002 |001 |

|001 |0000002 |Employee_B |001 |0000003 |001 |

|001 |0000002 |Employee_B |001 |0000003 |002 |

|001 |0000003 |Employee_C |001 |0000001 |001 |

|001 |0000003 |Employee_C |001 |0000002 |001 |

|001 |0000003 |Employee_C |001 |0000003 |001 |

|001 |0000003 |Employee_C |001 |0000003 |002 |

+----------+-----------+-------------+----------+-----------+----------+

12 rows in set (0.00 sec)

３．結合条件となる値のセットを誤り結合できなくなってしまう

例えば、以下のようなテーブルが存在するとします。

・利用料金テーブル

create table usagefee
(
usage_id CHAR(10) NOT NULL, --利用番号
use_date CHAR(8) NOT NULL, --利用日
shop_name CHAR(40) NOT NULL, --店名
fee DECIMAL(10) NOT NULL, --利用料金
PRIMARY KEY (usage_id)
);

create table usagefee

(

usage_id CHAR(10) NOT NULL, --利用番号

use_date CHAR(8) NOT NULL, --利用日

shop_name CHAR(40) NOT NULL, --店名

fee DECIMAL(10) NOT NULL, --利用料金

PRIMARY KEY (usage_id)

);

・利用料金明細テーブル

create table usagefee_detail
(
usage_id CHAR(10) NOT NULL, --利用番号
detail_id CHAR(3) NOT NULL, --枝版
item_name CHAR(40) NOT NULL, --商品名
fee DECIMAL(10) NOT NULL, --利用料金
PRIMARY KEY (usage_id,detail_id)
);

create table usagefee_detail

(

usage_id CHAR(10) NOT NULL, --利用番号

detail_id CHAR(3) NOT NULL, --枝版

item_name CHAR(40) NOT NULL, --商品名

fee DECIMAL(10) NOT NULL, --利用料金

PRIMARY KEY (usage_id,detail_id)

);

結合する時に指定するキーは利用番号になるため、以下のように利用番号には同一の値を使用する必要があります。

insert into usagefee values("0000000001","20201201","Shop_A",10000);
insert into usagefee_detail values("0000000001","001","Item_A",5000);
insert into usagefee_detail values("0000000001","002","Item_B",5000);
select *
from   usagefee p
join   usagefee_detail c
on     p.usage_id = c.usage_id;

Query OK, 1 row affected (0.01 sec)
Query OK, 1 row affected (0.01 sec)
Query OK, 1 row affected (0.00 sec)
+----------+--------+---------+-----+----------+---------+---------+----+
|usage_id  |use_date|shop_name|fee  |usage_id  |detail_id|item_name|fee |
+----------+--------+---------+-----+----------+---------+---------+----+
|0000000001|20201201|Shop_A   |10000|0000000001|001      |Item_A   |5000|
|0000000001|20201201|Shop_A   |10000|0000000001|002      |Item_B   |5000|
+----------+--------+---------+-----+----------+---------+---------+----+
2 rows in set (0.00 sec)

insert into usagefee values("0000000001","20201201","Shop_A",10000);

insert into usagefee_detail values("0000000001","001","Item_A",5000);

insert into usagefee_detail values("0000000001","002","Item_B",5000);

select *

from usagefee p

join usagefee_detail c

on p.usage_id = c.usage_id;

Query OK, 1 row affected (0.01 sec)

Query OK, 1 row affected (0.00 sec)

+----------+--------+---------+-----+----------+---------+---------+----+

+----------+--------+---------+-----+----------+---------+---------+----+

|0000000001|20201201|Shop_A |10000|0000000001|001 |Item_A |5000|

|0000000001|20201201|Shop_A |10000|0000000001|002 |Item_B |5000|

+----------+--------+---------+-----+----------+---------+---------+----+

2 rows in set (0.00 sec)

しかし、利用番号がプログラム中で生成する連番であり、かつプログラム中で利用料金テーブルと利用料金明細テーブルで別々に連番を付与していた場合、利用番号で結びつかなくなってしまいます。

insert into usagefee values("0000000001","20201201","Shop_A",10000);
insert into usagefee_detail values("0000000002","001","Item_A",5000);
insert into usagefee_detail values("0000000002","002","Item_B",5000);
select *
from   usagefee p
join   usagefee_detail c
on     p.usage_id = c.usage_id;

Query OK, 1 row affected (0.01 sec)
Query OK, 1 row affected (0.01 sec)
Query OK, 1 row affected (0.00 sec)
Empty set (0.00 sec)

insert into usagefee values("0000000001","20201201","Shop_A",10000);

insert into usagefee_detail values("0000000002","001","Item_A",5000);

insert into usagefee_detail values("0000000002","002","Item_B",5000);

select *

from usagefee p

join usagefee_detail c

on p.usage_id = c.usage_id;

Query OK, 1 row affected (0.01 sec)

Query OK, 1 row affected (0.00 sec)

Empty set (0.00 sec)

こうなると、利用料金テーブルと利用料金明細テーブルを結合するという使い方ができなくなり、後で困ることになります。
更に、既にサービスイン後であり過去データの補正が必要になった場合、その補正も困難になる場合があります。

いかがでしたでしょうか。

今回は失敗パターンの説明ということで、テーブル結合の失敗パターンを取り上げました。
失敗パターンは実務をこなす中で暗黙知的に知ることが多いと思いますので、文章に起こして共有できる形にしていきたいと思います。

2020年11月29日

リスコフの置換原則とは

リスコフの置換原則とはオブジェクト指向の設計の原則の一つであり、「基本クラスをサブクラスに入れ替えても問題なく動かなけらばならない」という原則です。
もしサブクラスに入れ替えると正しく動かなくなるのであれば、クラスを利用する側はサブクラスを使用してはならないというのを意識しながらコーディングしなければならず、保守性が低下します。

クラスの入力・出力に目を向けると、以下の条件を満たすとリスコフの置換原則を満たすことができます。

１．サブクラスの入力のパターンは、基本クラスの入力のパターンよりも緩い

２．サブクラスの出力のパターンは、基本クラスの入力のパターンよりも厳しい
　

もし、サブクラスの入力のパターンが基本クラスの入力のパターンよりも厳しいと、利用する側はサブクラスを利用する際にサブクラスが許容する入力であるかどうかを意識する必要が出てきてしまいます。
また、サブクラスの出力のパターンが基本クラスの出力のパターンよりも緩いと、利用する側はサブクラスを利用する際にサブクラスが予期せぬ出力をしないか意識する必要が出てきてしまいます。

以下のサンプルコードは、割り算を行う基本クラスであるDivideクラスを、サブクラスのDivideBusinessクラス・DivideBad1クラス・DivideBad2クラスで入れ替えてみるサンプルです。

DivideBusinessクラスは、基本クラスが許容する入力パターンに加え分母=0のパターンも許容し、基本クラスが出力することがある負数を出力しません。Divideクラスと入れ替えても特に考慮するパターンが増えることはなく、リスコフの置換原則を満たした良いクラスです。
しかし、DivideBad1クラスは、基本クラスが許容する分子=負数のパターンを許容せず、基本クラスと入れ替えた場合は分子が負数になっていないか意識する必要が出てきてしまいます。
また、DivideBad2クラスは、基本クラスと異なりnullを出力するパターンがあり、基本クラスと入れ替えた場合は出力がnullになる場合を意識する必要が出てきてしまいます。

【サンプルコード】

・DivideMain.java

public class DivideMain {

    public static void main(String［］ args) {

        Divide divide［］ = new Divide［4］;
        divide［0］ = new Divide();
        divide［1］ = new DivideBusiness();
        divide［2］ = new DivideBad1();
        divide［3］ = new DivideBad2();

        for (int i = 0; i ＜ 4; i++) {
            System.out.println("［テストその" + (i + 1) + "］");
            Calc(divide［i］,6,2);
            Calc(divide［i］,-6,2);
            Calc(divide［i］,6,0);
            Calc(divide［i］,null,2);
        }
    }

    public static void Calc
        (Divide divide, Integer numerator, Integer denominator) {

        System.out.println("クラス名：" + divide.getClass().getName());
        System.out.println("分子　　：" + numerator);
        System.out.println("分母　　：" + denominator);

        try {
            Integer result = divide.Calc(numerator, denominator);
            if (result == null) {
                System.out.println("結果　　：想定外の値！");
            } else {
                System.out.println("結果　　：" + result);
            }

        } catch (Exception e) {
            System.out.println("結果　　：想定外の例外！");
        }

        System.out.println("");
    }
}

public class DivideMain {

public static void main(String［］ args) {

Divide divide［］ = new Divide［4］;

divide［0］ = new Divide();

divide［1］ = new DivideBusiness();

divide［2］ = new DivideBad1();

divide［3］ = new DivideBad2();

for (int i = 0; i ＜ 4; i++) {

System.out.println("［テストその" + (i + 1) + "］");

Calc(divide［i］,6,2);

Calc(divide［i］,-6,2);

Calc(divide［i］,6,0);

Calc(divide［i］,null,2);

}

public static void Calc

(Divide divide, Integer numerator, Integer denominator) {

System.out.println("クラス名：" + divide.getClass().getName());

System.out.println("分子　　：" + numerator);

System.out.println("分母　　：" + denominator);

try {

Integer result = divide.Calc(numerator, denominator);

if (result == null) {

System.out.println("結果　　：想定外の値！");

} else {

System.out.println("結果　　：" + result);

}

} catch (Exception e) {

System.out.println("結果　　：想定外の例外！");

}

System.out.println("");

}

・Divide.java

// 入力：分母はnullや0は不可（例外送出）
// 出力：整数（負になり得る）
public class Divide {

    public Integer Calc(Integer numerator, Integer denominator)
        throws Exception {

        int numeratorTemp;
        int denominatorTemp;

        if (numerator == null) {
            numeratorTemp = 0;
        } else {
            numeratorTemp = numerator;
        }

        if (denominator == null) {
            denominatorTemp = 0;
        } else {
            denominatorTemp = denominator;
        }

        return numeratorTemp / denominatorTemp;
    }
}

// 入力：分母はnullや0は不可（例外送出）

// 出力：整数（負になり得る）

public class Divide {

public Integer Calc(Integer numerator, Integer denominator)

throws Exception {

int numeratorTemp;

int denominatorTemp;

if (numerator == null) {

numeratorTemp = 0;

} else {

numeratorTemp = numerator;

}

if (denominator == null) {

denominatorTemp = 0;

} else {

denominatorTemp = denominator;

}

return numeratorTemp / denominatorTemp;

}

・DivideBusiness.java

// 入力：分母はnullや0も許容
// 出力：整数（負にはならない）
public class DivideBusiness extends Divide {

    public Integer Calc(Integer numerator, Integer denominator)
        throws Exception {

        int numeratorTemp;
        int denominatorTemp;

        if (numerator == null || numerator ＜ 0) {
            numeratorTemp = 0;
        } else {
            numeratorTemp = numerator;
        }

        if (denominator == null || denominator ＜ 0) {
            denominatorTemp = 0;
        } else {
            denominatorTemp = denominator;
        }

        if (denominatorTemp == 0) {
            denominatorTemp = 1;
        }

        return numeratorTemp / denominatorTemp;
    }
}

// 入力：分母はnullや0も許容

// 出力：整数（負にはならない）

public class DivideBusiness extends Divide {

public Integer Calc(Integer numerator, Integer denominator)

throws Exception {

int numeratorTemp;

int denominatorTemp;

if (numerator == null || numerator ＜ 0) {

numeratorTemp = 0;

} else {

numeratorTemp = numerator;

}

if (denominator == null || denominator ＜ 0) {

denominatorTemp = 0;

} else {

denominatorTemp = denominator;

}

if (denominatorTemp == 0) {

denominatorTemp = 1;

}

return numeratorTemp / denominatorTemp;

}

・DivideBad1.java

// 入力：分子は負数は不可（例外送出）、分母はnullや0未満は不可（例外送出）
// 出力：整数（負になり得る）
public class DivideBad1 extends Divide {

    public Integer Calc(Integer numerator, Integer denominator)
        throws Exception {

        int numeratorTemp;
        int denominatorTemp;

        if (numerator == null) {
            numeratorTemp = 0;
        } else {
            numeratorTemp = numerator;
        }

        if (denominator == null) {
            denominatorTemp = 0;
        } else {
            denominatorTemp = denominator;
        }

        if (numeratorTemp ＜ 0 || denominatorTemp ＜ 0) {
            throw new Exception();
        }

        return numeratorTemp / denominatorTemp;
    }
}

// 入力：分子は負数は不可（例外送出）、分母はnullや0未満は不可（例外送出）

// 出力：整数（負になり得る）

public class DivideBad1 extends Divide {

public Integer Calc(Integer numerator, Integer denominator)

throws Exception {

int numeratorTemp;

int denominatorTemp;

if (numerator == null) {

numeratorTemp = 0;

} else {

numeratorTemp = numerator;

}

if (denominator == null) {

denominatorTemp = 0;

} else {

denominatorTemp = denominator;

}

if (numeratorTemp ＜ 0 || denominatorTemp ＜ 0) {

throw new Exception();

}

return numeratorTemp / denominatorTemp;

}

・DivideBad2.java

// 入力：分子はnull許容、分母は0は不可（例外送出）
// 出力：整数（負になり得る）、ただし分子や分母がnullの場合はnull
public class DivideBad2 extends Divide {

    public Integer Calc(Integer numerator, Integer denominator)
        throws Exception {

        int numeratorTemp;
        int denominatorTemp;

        if (numerator == null) {
            return null;
        } else {
            numeratorTemp = numerator;
        }

        if (denominator == null) {
            return null;
        } else {
            denominatorTemp = denominator;
        }

        return numeratorTemp / denominatorTemp;
    }
}

// 入力：分子はnull許容、分母は0は不可（例外送出）

// 出力：整数（負になり得る）、ただし分子や分母がnullの場合はnull

public class DivideBad2 extends Divide {

public Integer Calc(Integer numerator, Integer denominator)

throws Exception {

int numeratorTemp;

int denominatorTemp;

if (numerator == null) {

return null;

} else {

numeratorTemp = numerator;

}

if (denominator == null) {

return null;

} else {

denominatorTemp = denominator;

}

return numeratorTemp / denominatorTemp;

}

【結果】

［テストその1］
クラス名：Divide
分子　　：6
分母　　：2
結果　　：3

クラス名：Divide
分子　　：-6
分母　　：2
結果　　：-3

クラス名：Divide
分子　　：6
分母　　：0
結果　　：想定外の例外！

クラス名：Divide
分子　　：null
分母　　：2
結果　　：0

［テストその2］
クラス名：DivideBusiness
分子　　：6
分母　　：2
結果　　：3

クラス名：DivideBusiness
分子　　：-6
分母　　：2
結果　　：0

クラス名：DivideBusiness
分子　　：6
分母　　：0
結果　　：6

クラス名：DivideBusiness
分子　　：null
分母　　：2
結果　　：0

［テストその3］
クラス名：DivideBad1
分子　　：6
分母　　：2
結果　　：3

クラス名：DivideBad1
分子　　：-6
分母　　：2
結果　　：想定外の例外！

クラス名：DivideBad1
分子　　：6
分母　　：0
結果　　：想定外の例外！

クラス名：DivideBad1
分子　　：null
分母　　：2
結果　　：0

［テストその4］
クラス名：DivideBad2
分子　　：6
分母　　：2
結果　　：3

クラス名：DivideBad2
分子　　：-6
分母　　：2
結果　　：-3

クラス名：DivideBad2
分子　　：6
分母　　：0
結果　　：想定外の例外！

クラス名：DivideBad2
分子　　：null
分母　　：2
結果　　：想定外の値！

［テストその1］

クラス名：Divide

分子　　：6

分母　　：2

結果　　：3

クラス名：Divide

分子　　：-6

分母　　：2

結果　　：-3

クラス名：Divide

分子　　：6

分母　　：0

結果　　：想定外の例外！

クラス名：Divide

分子　　：null

分母　　：2

結果　　：0

［テストその2］

クラス名：DivideBusiness

分子　　：6

分母　　：2

結果　　：3

クラス名：DivideBusiness

分子　　：-6

分母　　：2

結果　　：0

クラス名：DivideBusiness

分子　　：6

分母　　：0

結果　　：6

クラス名：DivideBusiness

分子　　：null

分母　　：2

結果　　：0

［テストその3］

クラス名：DivideBad1

分子　　：6

分母　　：2

結果　　：3

クラス名：DivideBad1

分子　　：-6

分母　　：2

結果　　：想定外の例外！

クラス名：DivideBad1

分子　　：6

分母　　：0

結果　　：想定外の例外！

クラス名：DivideBad1

分子　　：null

分母　　：2

結果　　：0

［テストその4］

クラス名：DivideBad2

分子　　：6

分母　　：2

結果　　：3

クラス名：DivideBad2

分子　　：-6

分母　　：2

結果　　：-3

クラス名：DivideBad2

分子　　：6

分母　　：0

結果　　：想定外の例外！

クラス名：DivideBad2

分子　　：null

分母　　：2

結果　　：想定外の値！

いかがでしたでしょうか。

ポリモーフィズムを利用するとソースコードを簡潔にできるのですが、それを実現するためにはリスコフの置換原則を満たすことが必要です。
デザインパターン等で良い設計に触れている方なら自然に満たせるものかもしれませんが、今一度意識してみるのも良いかもしれません。

2020年11月20日

単一責任の原則とは

オブジェクト指向の設計ではいくつかの原則があります。
その中でも有名な原則の一つが「単一責任の原則」です。

この原則は、その名の通り「一つのクラスに持たせる責任は一つにする」という原則です。
この原則が何のために用いられるのかと言うと、複数の理由で１つのクラスを修正するのを防ぐためです。
ここで言う「理由」を「案件」、「クラス」を「ソース」と捉えると分かりやすいと思います。
複数の案件で１つのソースを修正する必要が出てしまうと、並行開発手順やバージョン管理等が煩雑になってしまい、品質に悪影響が及びます。

「一つのクラスに持たせる責任は一つにする」と捉えると具体的なイメージが浮かびにくいと思うのですが、「複数の案件で１つのソースを修正しないような粒度で設計する」と捉えると分かりやすいと思います。

以下では、javaのソースコードで例を出します。
商品の名前と値段を登録し、それを表示するという例です。

まずは悪い例からです。

【サンプルコード１】

・CommodityMain.java

public class CommodityMain {

    public static void main(String［］ args) {

        RegistShowCommodity registShowCommodity = new RegistShowCommodity();
        String commodityName = "PC";

        // 商品の登録
        registShowCommodity.setCommodityPrice(commodityName, 100000);

        // 商品の表示
        registShowCommodity.showCommodityPrice(commodityName);

    }

}

public class CommodityMain {

public static void main(String［］ args) {

RegistShowCommodity registShowCommodity = new RegistShowCommodity();

String commodityName = "PC";

// 商品の登録

registShowCommodity.setCommodityPrice(commodityName, 100000);

// 商品の表示

registShowCommodity.showCommodityPrice(commodityName);

}

・RegistShowCommodity.java

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

public class RegistShowCommodity {

    private Map＜String, Integer＞ commodityMap 
        = new HashMap＜String, Integer＞();

    public void setCommodityPrice (String commodityName,int price) {
        commodityMap.put(commodityName,price);
    }

    public void showCommodityPrice (String commodityName) {
        System.out.println(commodityName + ":" +
            commodityMap.get(commodityName) + " yen");
    }

}

import java.util.HashMap;

import java.util.Map;

public class RegistShowCommodity {

private Map＜String, Integer＞ commodityMap

= new HashMap＜String, Integer＞();

public void setCommodityPrice (String commodityName,int price) {

commodityMap.put(commodityName,price);

}

public void showCommodityPrice (String commodityName) {

System.out.println(commodityName + ":" +

commodityMap.get(commodityName) + " yen");

}

【実行結果１】

PC:100000 yen

1	PC:100000 yen

ここで、「商品の税込み価格を計算可能にする」という案件と、「表示を綺麗にする」という案件が発生したとします。
今の設計だと、どちらの案件も RegistShowCommodityクラスの修正となってしまいます。

そこで、商品の登録を行う RegistCommodityクラス、商品の価格計算を行う CalcCommodityクラス、価格表示を行う ShowCommodityクラスの３クラスに分割します。

【サンプルコード２】

・CommodityMain.java

public class CommodityMain {

    public static void main(String［］ args) {

        RegistCommodity registCommodity = new RegistCommodity();
        CalcCommodity calcCommodity = new CalcCommodity();
        ShowCommodity showCommodity = new ShowCommodity();
        String commodityName = "PC";

        // 商品の登録
        registCommodity.setCommodityPrice(commodityName, 100000);

        // 商品の表示
        showCommodity.showCommodityPrice(commodityName,
            calcCommodity.calcPrice(
                registCommodity.getCommodityPrice(commodityName)));

    }

}

public class CommodityMain {

public static void main(String［］ args) {

RegistCommodity registCommodity = new RegistCommodity();

CalcCommodity calcCommodity = new CalcCommodity();

ShowCommodity showCommodity = new ShowCommodity();

String commodityName = "PC";

// 商品の登録

registCommodity.setCommodityPrice(commodityName, 100000);

// 商品の表示

showCommodity.showCommodityPrice(commodityName,

calcCommodity.calcPrice(

registCommodity.getCommodityPrice(commodityName)));

}

・RegistCommodity.java

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

public class RegistCommodity {

    private Map＜String, Integer＞ commodityMap 
        = new HashMap＜String, Integer＞();

    public void setCommodityPrice (String commodityName,int price) {
        commodityMap.put(commodityName,price);
    }

    public int getCommodityPrice (String commodityName) {
        return commodityMap.get(commodityName);
    }

}

import java.util.HashMap;

import java.util.Map;

public class RegistCommodity {

private Map＜String, Integer＞ commodityMap

= new HashMap＜String, Integer＞();

public void setCommodityPrice (String commodityName,int price) {

commodityMap.put(commodityName,price);

}

public int getCommodityPrice (String commodityName) {

return commodityMap.get(commodityName);

}

・CalcCommodity.java

public class CalcCommodity {

    public int calcPrice (int price) {
        return price;
    }

}

public class CalcCommodity {

public int calcPrice (int price) {

return price;

}

・ShowCommodity.java

public class ShowCommodity {

    public void showCommodityPrice (String commodityName,int price) {
        System.out.println(commodityName + ":" +
            price + " yen");
    }

}

public class ShowCommodity {

public void showCommodityPrice (String commodityName,int price) {

System.out.println(commodityName + ":" +

price + " yen");

}

【実行結果２】

PC:100000 yen

1	PC:100000 yen

３クラスに分割した結果、「商品の税込み価格を計算可能にする」という案件は CalcCommodityクラスの修正、「表示を綺麗にする」という案件は ShowCommodityクラスの修正で対応できるようになり、別々の案件で１つのクラスを修正する状態を防ぐことができました。

【サンプルコード３】

・CommodityMain.java

public class CommodityMain {

    public static void main(String［］ args) {

        RegistCommodity registCommodity = new RegistCommodity();
        CalcCommodity calcCommodity = new CalcCommodity();
        ShowCommodity showCommodity = new ShowCommodity();
        String commodityName = "PC";

        // 商品の登録
        registCommodity.setCommodityPrice(commodityName, 100000);

        // 商品の表示
        showCommodity.showCommodityPrice(commodityName,
            calcCommodity.calcPriceWithTax(
                registCommodity.getCommodityPrice(commodityName)));

    }
}

public class CommodityMain {

public static void main(String［］ args) {

RegistCommodity registCommodity = new RegistCommodity();

CalcCommodity calcCommodity = new CalcCommodity();

ShowCommodity showCommodity = new ShowCommodity();

String commodityName = "PC";

// 商品の登録

registCommodity.setCommodityPrice(commodityName, 100000);

// 商品の表示

showCommodity.showCommodityPrice(commodityName,

calcCommodity.calcPriceWithTax(

registCommodity.getCommodityPrice(commodityName)));

}

・RegistCommodity.java

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

public class RegistCommodity {

    private Map＜String, Integer＞ commodityMap 
        = new HashMap＜String, Integer＞();

    public void setCommodityPrice (String commodityName,int price) {
        commodityMap.put(commodityName,price);
    }

    public int getCommodityPrice (String commodityName) {
        return commodityMap.get(commodityName);
    }

}

import java.util.HashMap;

import java.util.Map;

public class RegistCommodity {

private Map＜String, Integer＞ commodityMap

= new HashMap＜String, Integer＞();

public void setCommodityPrice (String commodityName,int price) {

commodityMap.put(commodityName,price);

}

public int getCommodityPrice (String commodityName) {

return commodityMap.get(commodityName);

}

・CalcCommodity.java

public class CalcCommodity {

    private double taxRate = 1.1;

    public int calcPrice (int price) {
        return price;
    }

    // 「商品の税込み価格を計算可能にする」案件
    public int calcPriceWithTax (int price) {
        return (int) (price * taxRate);
    }

}

public class CalcCommodity {

private double taxRate = 1.1;

public int calcPrice (int price) {

return price;

}

// 「商品の税込み価格を計算可能にする」案件

public int calcPriceWithTax (int price) {

return (int) (price * taxRate);

}

・ShowCommodity.java

public class ShowCommodity {

    // 「表示を綺麗にする」案件
    public void showCommodityPrice (String commodityName,int price) {
        System.out.println("■CommodityName :" + commodityName);
        System.out.println("■CommodityPrice:" + price + " yen");
    }

}

public class ShowCommodity {

// 「表示を綺麗にする」案件

public void showCommodityPrice (String commodityName,int price) {

System.out.println("■CommodityName :" + commodityName);

System.out.println("■CommodityPrice:" + price + " yen");

}

【実行結果３】

■CommodityName :PC
■CommodityPrice:110000 yen

1 2	■CommodityName :PC ■CommodityPrice:110000 yen

いかがでしたでしょうか。

オブジェクト指向の設計と言うと覚えることが多くて大変だという印象を持つかもしれませんが、いくつかの原則を抑えるだけでも良い設計ができます。
（デザインパターンも、原則に則って設計を考えると自ずと導き出されるものだと思っています）

単一責任の原則は代表的な原則の一つなので、覚えておいて損はないと思います。