【DDD】前提知識まとめ

# 動物は必ず「鳴く」
interface Animal {
    sound();
}
# 犬は「動物らしい振る舞い」をする(鳴く)
class dog implements Animal {
    sound() { /**/ }
}
# 動物は「鳴く」ので、引数の動物ごとの異なる鳴き声を処理する
# 引数で与えられる動物によって、異なる処理(鳴き声)ができる
public function animalsound(animal) {
    animal.sound()
}

# プロパティ管理とDB管理の二つの責任を持ってしまっているクラス
class Animal {
    constructor(name: string) { }
    getAnimalName() { }
    saveAnimal(a: Animal) { }

class Animal {
    constructor(name: string) { }
    getAnimalName() { }
}
class AnimalDB {
    getAnimal(a: Animal) { }
    saveAnimal(a: Animal) { }
}

class Animal {
    constructor(name: string) { }
    getAnimalName() { }
}

# animalリストを順に処理し、泣き声を出す
const animals: Array<Animal> = [
    new Animal(“lion”),
    new Animal(“mouse”)
];
# animalsが更新されるごとに修正を入れないといけない
# animalsの修正に対して「閉じていない」関数
function AnimalSound(a: Array<Animal>) {
    for(int i = 0; i <= a.length; i++) {
        if(a[i].name == “lion”)
            log(“gaogao”)
        if(a[i].name == “mouse”)
            log(“chu”)
    }
}
AnimalSound(animals);

# Animalに仮想メソッドmakeSound()を宣言
# 各々の動物に各々のmakeSound()が実装されるので、
# 新しい動物が増える度にAnimalSound()を変更する必要はない
class Animal {
    makeSound();
    # ...
}
class Lion extends Animal {
    nameSound() {
        return “gaogao”
    }
}
class mouse extends Animal {
    nameSound() {
        return “chu”
    }
}
# お好きなアニマルをanimalsに突っ込む
fanction AnimalSound(a: Array<Animal>) {
    for(int i = 0; i <= a.length; i++) {
        log(a[i].makeSound());
    }
}
AnimalSound(animals);

# 全部のAnimalの型を見て、それに関連するLegCountを呼び出す必要がある
# コードでクラスの型をチェックしていたら、LSPに違反している場合が多い
# OCPにも違反している
function AnimalLegCount(a: Array<animal>) {
    for(int i = 0; i <= a.length; i++) {
        if(typeof a[i] == Lion)
            log(LionLegCount(a[i]));
        if(typeof a[i] == Mouse)
            log(MouseLegCount(a[i]));
        if(typeof a[i] == Snake)
            log(SnakeLegCount(a[i]));
    }
}
AnimalLegCount(animals);

# OCPに一致させるために仮想メソッドを定義
class Animal {
    LegCount();
    # ...
}
# Animal型が通過しても気にせず、ただLegCountメソッドを呼び出すだけ
function AnimalLegCount(a: Array<Animal>){
    for(let i = 0; i <= a.length; i++) {
        a[i].LegCount()
    }
}
AnimalLegCount(animals);

interface ISape {
    drawCircle();
    drawSquare();
    drawRectagle();
}
# 円しか書かないのにdrawSquare()、drawRectagle()を実装しないといけない
class Circle implements IShape {
    drawCircle(){ /**/ }
    drawSquare(){ /**/ }
    drawRectangle(){ /**/ }
}

interface IShape {
    draw();
}
interface Icicle() {
    drawCicle();
}
interface ISquare {
    drawSquare();
}
class Circle implements ICircle {
    drawCicle() { /**/ }
}
# もしくは、IShapeを継承してお好きなdrawを組み立てる

Class Speaker() {
    sound() { /**/}
}
# この書き方をすることで、RadioTunerはSpeakerに強く依存している
# (Speakerの事を直接「知ってしまっている」)
# Speakerを修正する場合、RadioTunerも修正が必要になる
class RadioTuner() {
    $speaker = new Speaker();
    $speaker->sound();
}

interface AudioOutput() {
    sound();
}
# Speakerはinterfaceに依存
Class Speaker implements AudioOutput {
    sound() { /**/}
}
# RadioTunerもinterfaceに依存
# RadioTuner自体は、自分が実際に渡されているクラスを知らない
# (ポリモーフィズムという)
class RadioTuner {
    public function output(AudoiOutput $outputCircuit) {
        # sound()があることはinterfaceで保証されている
        $outputCircuit->sound();
    }
}