継承 (七週目の学習)

<font color="limegreen">モチベーションも大事だと思うので覚書として使用します。</font>
<font color="DarkSlateGray"><details><summary>七週目の感想</summary><div>七週目は、継承を学習。
学習書/ｶﾞｲﾄﾞﾗｲﾝとして参考にしている「猫でもわかるC#」にて序盤に軽く触れた継承が、
約30P分の量で再登場したので、じっくり臨みました。(書籍内でも主要な要素であろう事が伺えた･･･)
派生クラスやその多層化で、最初に比べればオブジェクト指向の片鱗位は理解できたと思います。

</font></details></div>








　　　　　　　　　　　　　　　<img src = https://camo.qiitausercontent.com/383edf3da2278d473d15750468f2186916b306d9/68747470733a2f2f71696974612d696d6167652d73746f72652e73332e616d617a6f6e6177732e636f6d2f302f35313231322f32333338666333662d306366382d343461342d383761382d6163343262633131636132632e706e67 width = 300 ％>






#<font color="SlateGray">継承
継承は、<b>OOP三原則</b>(継承・ポリモーフィズム・カプセル化)の1つであり非常に重要な概念です。
変更に対して柔軟に対応するため、可能な限りこの三原則を用いて設計・保守していく事になります。
継承は、引き継ぐ事を意味するが、それは元となる<b>規格であり機能ではない</b>事に注意。
・参考: [オブジェクト指向と10年戦ってわかったこと](https://qiita.com/tutinoco/items/6952b01e5fc38914ec4e)

<br>
継承は概念ですが、C#での具体例をあげるとすれば、
元のクラスを引き継いだまま新しいクラスを作成する事ができます(便利！)
元のクラスを<b>基本クラス(base class)</b>
新しく作成されたクラスを<b>派生クラス(derived class)</b>

といいます。

構文は以下のように書きます。
<b>`class 派生クラス名:基本クラス名`</b>

※基本クラスのpublicなメンバは派生クラスから呼び出す事ができます。
ただ全てpublicにしてしまうと、派生クラス以外に依存関係を作る恐れがあるため、
その場合`protected`や`private protected`を用いる事で基本クラスとその派生クラスにだけ影響を与えます。

<details><summary>基本的なコード例をここに示します</summary><div>

```c#
using System;

class MyBase// 基本クラス
{
    public int a = 10;
    public void BaseMethod()
    {
        Console.WriteLine("ここは基本クラス");
    }
}

class MyDerived : MyBase// 派生クラス作成
{
    public int b = 20;
    public void DerivedMethod()
    {
        Console.WriteLine("ここは派生クラス");
    }
}

class Inheritance01
{
    public static void Main()
    {
        MyDerived md = new MyDerived();// 派生クラスのインスタンス
        md.BaseMethod();// 基本クラスのpublicなメンバは派生クラスから呼び出せる
        md.DerivedMethod();
        Console.WriteLine($"md.a={md.a}");
        Console.WriteLine($"md.b={md.b}");
        MyBase mb = new MyBase();
        mb.BaseMethod();
        Console.WriteLine($"mb.a={mb.a}");
    }
}
```

![image.png](https://qiita-image-store.s3.amazonaws.com/0/252588/27275af9-3285-e947-aa0f-5475225b0861.png)


</details></div>

<font color="crimson">このように継承(inheritance)とは「引き継ぐ」ことを意味します。</font>

<br>
他の継承に関連する機能を見ていきましょう。

<br>
##<font color="DimGray">名前の隠蔽</font>
名前の隠蔽により、派生クラスでも基本クラスのメンバと同名のメンバを持つ事が可能になります。
使用には、`new`を頭につけるだけです(この時後ろの()は必要ありません)
以降のメンバ名は全て`new`メンバが呼び出され元のメンバは隠されます。

※隠蔽された元のメンバを使いたい場合、`base.メンバ名`を用いる事で呼び出せます。
(但し`static`なメソッドでは扱えません)

<details><summary>基本的なコード例をここに示します</summary><div>

```c#
namespace Inpei
{
    class Base
    {
        public int x = 10;
        protected void BaseMethod()
        {
            Console.WriteLine("Baseクラス");
        }
    }

    class Derived : Base
    {
        new public int x = 20;// 名前の隠蔽
        new public void BaseMethod()// 名前の隠蔽
        {
            Console.WriteLine("Derivedクラス");
            Console.WriteLine($"base.x={base.x}, x={x}");//base.メンバ名と更新されたメンバ
        }
    }

    class Inheritance
    {
        public static void Main()
        {
            Derived d = new Derived();// static method内はnewｲﾝｽﾀﾝｽ作成
            Console.WriteLine($"x={d.x}");// 20

            //base はstaticでは使用できないnewｲﾝｽﾀﾝｽ作成しても無理
            //Base b = new Base();
            //Console.WriteLine($"base.x={base.x}, {x}");

            d.BaseMethod();
        }
    }
}
```

![image.png](https://qiita-image-store.s3.amazonaws.com/0/252588/3fc4cb05-6c76-cc58-229a-f43a9c081229.png)



</details></div>



</details></div>


<font color="crimson">このように、`new`メンバにより元のメンバが隠される事を、名前の隠蔽といいます。</font>























<br>
##<font color="DimGray">オーバーライド</font>
オーバーライドは、派生クラスで同名のメソッド等を作る事ができます。
引数の違うメソッドを<b>多重定義できるオーバーロード(読み込む)(引数違う)とは違い、
オーバーライド(上書き)(引数同じ)は、再定義をする事ができます。</b>
また、`base.メンバ名`と同じく、`static`なメソッドでは定義できません。
メソッドの他、プロパティやインデクサでも使用可能です。
元のメソッドを<b>仮想メソッド(virtual method)</b>
新しいメソッドを<b>オーバーライドメソッド(override method)</b>
といいます。

使用には、アクセス修飾子の後ろに`virtual`をつけ、
派生クラスでは、`override`と同じ引数で再定義します。

※引数は同じでなければなりません。

<details><summary>基本的なコード例をここに示します</summary><div>
※Mainメソッドで参照変数と代入する分のnewインスタンスを全て作成し、実行前どのクラスの参照を代入するかによってm.Nakigoe()の動作が異なっている事に注意。

```c#
namespace Overrider
{
    class Mamma1// Mamma 哺乳類
    {
        protected readonly int leg = 4;// readonly 読み込み専用にして変更不可
        protected string koe;// 規格

        public virtual string Nakigoe()// virtual koe返す
        {
            return koe;
        }
        public int Leg()// 全部4本足なのでoverride不必要 leg返す
        {
            return leg;
        }
    }
    
    class Cat : Mamma1// 派生クラス
    {
        public override string Nakigoe()// Override
        {
            koe = "ニャー";
            return koe;// 呼出元(仮想メソッド)にkoe返す
        }
    }

    class Dog : Mamma1// 派生クラス
    {
        public override string Nakigoe()// Override
        {
            koe = "ワン";
            return koe;// 呼出元(仮想メソッド)にkoe返す
        }
    }

    class Override01
    {
        public static void Main()
        {
            Mamma1 m; //参照変数mを宣言
            Cat cat = new Cat();// 代入用ｲﾝｽﾀﾝｽ作成
            Dog dog = new Dog();// 代入用ｲﾝｽﾀﾝｽ作成

            m = cat; // 参照変数mに代入
            Console.WriteLine($"猫の脚は{m.Leg()}本で鳴き声は{m.Nakigoe()}です");// m(cat)の鳴き声

            m = dog;// どのｸﾗｽの参照を代入したかによってm.Nakigoe()の動作が異なる
            Console.WriteLine($"犬の脚は{m.Leg()}本で鳴き声は{m.Nakigoe()}です");// m(dog)の鳴き声
        }
    }
}
```


</details></div>



<font color="crimson">このように、規格となる`virtual method`から各パーツである`override method`が作成されます。</font>












































<br>
##<font color="DimGray">クラスの多層階層</font>
多層階層は、派生クラスを元に制限なく何層も派生クラスを作成できます。
使用には、<b>`新しい派生クラス:基となる派生クラス`</b>とします。
<details><summary>基本的なコード例をここに示します</summary><div>

```c#
namespace BaseDelived
{
    class MyBase// 基本クラス
    {
        protected int x = 10;
        public virtual void Show()
        {
            Console.WriteLine($"x={x}");
        }
    }

    class Derived1 : MyBase// 派生クラス
    {
        protected int y = 20;// 派生クラスでy定義しただけ。意味なし
    }

    class Derived2 : Derived1// 上の派生クラスを継承した派生クラス
    {
        int z = 30;// 本来はx、上書きされたz定義↓
        public override void Show()// MyBase.Showをoverrideしてx=xをz=zに上書き
        {
            Console.WriteLine($"z={z}");
        }
    }

    class inheritance
    {
        public static void Main()
        {
            MyBase mb;
            Derived1 d1 = new Derived1();
            Derived2 d2 = new Derived2();

            mb = d1;
            mb.Show();//d1時点では本来のxなので10

            mb = d2;
            mb.Show();//d2でoverrideされたのでx=10でなくz=30
        }
    }
}

```
![image.png](https://qiita-image-store.s3.amazonaws.com/0/252588/4be4846b-2fef-d171-08ef-1c005460f0c3.png)

</details></div>

<font color="crimson">このように、派生クラスを階層化しながらメソッドの`override`が可能です。</font>





















###<font color="DimGray">クラスの継承とコンストラクタ</font>
コンストラクタは、インスタンス生成時に呼び出されるメソッドで、
インスタンスが他クラスで使われる前に初期化処理してくれます。
この場合`new`で呼び出されたクラスのメソッドを指します。

使用上のルールとして、
・メソッド名(コンストラクタ名)はクラス名と同じ。
・戻り値は指定しない。
・呼び出されるタイミングはインスタンス生成時のみ。

<details><summary>基本的なコード例をここに示します</summary><div>

```c#
    public class Test
    {
        public string Tag;

        public Test() // こ
        {　　　　　　　 // の
            Tag = "A";// 部
        }　　　　　　　 // 分
    }
// この部分がコンストラクタになります。
// コンストラクタは戻り値voidを定義しません。
// さらに、メソッド名はクラス名と同じである必要があります。

    static void Main(string[] args)
    {
        Test test = new Test();
    }
// newにより呼び出されたメソッドがコンストラクタです。
// test.Tag には ”A" という値がセットされる事になります。
```
</details></div>






では本題ですが、派生クラスのコンストラクタはそれぞれどのように実行されていくのでしょうか？

<details><summary>基本的なコード例をここに示します</summary><div>

```c#
namespace Inheritance
{
    class MyBase
    {
        protected int x;

        public MyBase()// MyBaseクラスのconstructor
        {
            Console.WriteLine("ここはMyBase");
            x = 10;
        }
    }

    class Derived1 : MyBase
    {
        public Derived1()// Derived1クラスのconstructor
        {
            Console.WriteLine("ここはDerived1");
            x = 20;
        }
    }

    class Derived2 : Derived1
    {
        public Derived2()// Derived2クラスのconstructor
        {
            Console.WriteLine("ここはDerived2");
            x = 30;
        }
        public void Show()
        {
            Console.WriteLine($"x={x}");
        }
    }

    class Inheritance
    {
        public static void Main()
        {
            Derived2 d2 = new Derived2();// constructor呼出
            d2.Show();
            // 代入された値(d2)は、そのShowメソッドを呼び出す際、
            // xは遡って元の10、派生の20、その派生の30と基本クラスから順に呼び出される事になる。
            // 従ってShowメソッドは30となった。
        }
    }
}

```
![image.png](https://qiita-image-store.s3.amazonaws.com/0/252588/3af5b15b-e7cc-444e-d994-e533f4a2eca8.png)

</details></div>

<font color="crimson">このように、コンストラクタは基本クラスから順に呼び出される事になります。</font>



















<br>
##<font color="DimGray">抽象 abstract</font>
抽象メソッド(abstract method)は、派生クラス毎に個別定義するメソッドになります。
以前の再定義するオーバーライドや多重定義するオーバーロードとは違います。
抽象メソッドは仕様(規格)であり中身は記述せず、実装クラスにて初めて記述します。

使用には、アクセス修飾子の後ろに`abstract`をつけ、クラス名の前にも`abstract`をつけます。
派生クラスでは、その仕様(規格)にそった個別定義ができます。

※基本クラスでの使用の場合、実装クラスで必ず`override`にする。

<details><summary>基本的なコード例をここに示します</summary><div>

```c#
namespace Abstracting
{
    abstract class MyAbst// 抽象クラス&基本クラス
    {
        public abstract double Discri(double a, double b, double c);
    }

    class MyDscri : MyAbst// 派生クラス
    {
        public override double Discri(double a, double b, double c)// 必ずoverride
        {
            return Math.Pow(b, 2.0) - 4.0 * a * c;
        }
    }

    class Abst
    {
        public static void Main()
        {
            MyDscri md = new MyDscri();// 代入用インスタンス
            double d = md.Discri(1.0, 2.0, 3.0);// 代入
            Console.WriteLine(d);
        }
    }
}
```

![image.png](https://qiita-image-store.s3.amazonaws.com/0/252588/cbda8339-ed0c-e4ab-7bd6-f25d947971ae.png)

</details></div>


<font color="crimson">このように、abstractしてれば異なる処理も個別に設定しリターンできる。</font>























<br>
##<font color="DimGray">分割定義 partial</font>
###<font color="DimGray">クラスの分割定義</font>
クラスの分割定義は、クラスが肥大化した時に分割する事でパフォーマンスが向上します。
例えば、自動生成されるコードを処理したり何らかのバグでコードが変更された場合も分散により最小限の被害に抑えられます。
またクラスの分割定義は、他クラス、他ファイルをまたいで分散させる事もできます。

使用には、分割するクラスの頭に`partial`をつけます。


<details><summary>基本的なコード例をここに示します</summary><div>

```c#
//File1.cs 内:
namespace PC
{
    partial class A
    {
        int num = 0;
        void MethodA() { }
        partial void MethodC();
    }
}

//File2.cs 宣言内:
namespace PC
{
    partial class A
    {
        void MethodB() { }
        partial void MethodC() { }
    }
}
```
</details></div>




















###<font color="DimGray">メソッドの分割定義</font>
メソッドも分割定義できます。但し`partial class`内に限ります。
また、暗黙的に`private`になります。
使用には、分割するメソッドの頭に`partial`をつけます。


<details><summary>基本的なコード例をここに示します</summary><div>

```c#
namespace PM
{
    partial class A
    {
        partial void Am(string s);
    }

    partial class A
    {
        partial void Am(String s)
        {
            Console.WriteLine($"Am: {s}");
        }
    }
}



//--
partial class Earth : Planet, IRotate { }
partial class Earth : IRevolve { }
// これらは、次の宣言と等価です。

class Earth : Planet, IRotate, IRevolve { }
```
</details></div>

<font color="crimson">このように、コードをまたいで分割定義できます。</font>

<br>