ha231.rundog.org

・名前の隠蔽やらメソッドのオーバライドやら似たようで似てないようなプログラムがでてきて頭がパンクしそうでしたが、
一応違いまでは理解できました。

　　何よりです。

・多様性に関してはまだまだ？？？状態です。笑　雰囲気はつかめましたが、まだ理解が
足りない部分があるなと思いました。。。(._.)

　「大雑把に扱われても自分が何なのかを忘れないから大丈夫」な機能です。
　いろいろと試してみてください。

・単語などもごちゃごちゃになるときがあるので、もう一度見直して整理してみようと思います。

　是非。

次回予告：p.245「inheritance07.cs」から
講義メモ：講義メモ20230826.zip

p.232（多態性の説明の前に…基本クラスの参照変数について）

・派生クラスのインスタンスは、基本クラスの参照変数で扱うことができる
・例えば「ホイミスライムのホイミンはスライムとして扱えること」と考えると良い
例：
  class Slime {…}
  class HoimiSlime : Slime {…}
  ：
  HoimiSlime hoimin = new HoimiSlime();
  Slime slime1go = hoimin; //継承しているので型は違うが同じオブジェクトを参照できる
・このことを利用して、複数の派生クラスのオブジェクトを、基本クラスを型としてまとめて扱える
・例えば「モンスターから派生した各種の魔物はすべてモンスターで扱える」
・具体的には、基本クラスを型とする配列には、派生クラスのインスタンスを格納できる
例：
  Slime[] slimes = {hoimin, behoimin, sulalin}; //派生クラスのオブジェクトを基本クラスの配列へ

p.232 多態性

・派生クラスのオブジェクトを基本クラスの型であつかうと、名前の隠ぺいを行っている場合、基本クラスで扱われる
例：
  class Slime {public void name(){ Console.WriteLine("スライムです");}
  class HoimiSlime : Slime {new public void name(){ Console.WriteLine("ホイミスライムです");;}
  ：
  Slime hoimin = new HoimiSlime();
  hoimin.name(); //「スライムです」と表示
・しかし、元は派生オブジェクトなのだから、派生クラス側のメソッドが動作するのが適切
・これが多態性で、オーバーライドメソッドにおいて可能になる
例：
  class Slime {public virtual void name(){ Console.WriteLine("スライムです");}
  class HoimiSlime : Slime {public override void name(){ Console.WriteLine("ホイミスライムです");;}
  ：
  Slime hoimin = new HoimiSlime();
  hoimin.name(); //「ホイミスライムです」と表示
・多態性を用いると、複数の派生クラスのオブジェクトを、基本クラスを型としてまとめて扱っても、元の定義が活きる。
・よって通常、メソッドにおいては名前の隠ぺいではなくオーバーライドを用いる。
・多態性により、基本クラスのメソッドに代わって派生クラスのオーバーライドメソッドのどれを呼ぶかは実行時に決まるので、動的メソッドディスパッチという。

p.233 override02.cs

//p.233 override02.cs
using System;
class Mammal { //基本クラス(哺乳類)
    protected const int LegNo = 4; //脚の数は4本
    protected string Koe; //鳴き声
    public virtual string Nakigoe() { //声を返す仮想メソッド
        Koe = "..."; //哺乳類の鳴き声は不定なので「...」にしておく
        return Koe; 
    }
    public int Leg() { //脚の数を返す通常メソッド
        return LegNo;
    }
}
class Cat : Mammal { //派生クラス(猫)
    public override string Nakigoe() { //声を返すオーバーライドメソッド
        Koe = "ニャー、ニャー"; //猫の鳴き声にする
        return Koe;
    }
}
class Dog : Mammal { //派生クラス(猫)
    public override string Nakigoe() { //声を返すオーバーライドメソッド
        Koe = "ワン、ワン"; //犬の鳴き声にする
        return Koe;
    }
}
class override02 {
    public static void Main() {
        Mammal m; //哺乳類クラスとその派生クラスを扱うための参照変数のみを定義
        Cat cat = new Cat(); //派生クラス(猫)のインスタンスを生成
        Dog dog = new Dog(); //派生クラス(犬)のインスタンスを生成
        m = cat; //派生クラス(猫)のインスタンスを基本クラス(哺乳類)で扱う
        Console.WriteLine("猫の脚は{0}本で鳴き声は「{1}」です", 
            m.Leg(), m.Nakigoe()); //通常メソッドとオーバーライドメソッド(猫)を呼ぶ
        m = dog; //派生クラス(犬)のインスタンスを基本クラス(哺乳類)で扱う
        Console.WriteLine("犬の脚は{0}本で鳴き声は「{1}」です",
            m.Leg(), m.Nakigoe()); //通常メソッドとオーバーライドメソッド(犬)を呼ぶ
    }
}

アレンジ演習：p.233 override02.cs

・基本クラス型の配列に、派生クラス型の２インスタンスを格納しよう
・配列の全要素について繰り返す中で、オーバーライドメソッドを呼んで多態性を確認しよう

作成例

//アレンジ演習：p.233 override02.cs
using System;
class Mammal { //基本クラス(哺乳類)
    protected const int LegNo = 4; //脚の数は4本
    protected string Koe; //鳴き声
    public virtual string Nakigoe() { //声を返す仮想メソッド
        Koe = "..."; //哺乳類の鳴き声は不定なので「...」にしておく
        return Koe; 
    }
    public int Leg() { //脚の数を返す通常メソッド
        return LegNo;
    }
}
class Cat : Mammal { //派生クラス(猫)
    public override string Nakigoe() { //声を返すオーバーライドメソッド
        Koe = "ニャー、ニャー"; //猫の鳴き声にする
        return Koe;
    }
}
class Dog : Mammal { //派生クラス(犬)
    public override string Nakigoe() { //声を返すオーバーライドメソッド
        Koe = "ワン、ワン"; //犬の鳴き声にする
        return Koe;
    }
}
class override02 {
    public static void Main() {
        Cat cat = new Cat(); //派生クラス(猫)のインスタンスを生成
        Dog dog = new Dog(); //派生クラス(犬)のインスタンスを生成
        Mammal[] m = {cat, dog}; //哺乳類クラスとその派生クラスを扱うための配列に格納
        foreach (var w in m) { //哺乳類の配列の全要素について繰返す
            Console.WriteLine("脚は{0}本で鳴き声は「{1}」です", 
            w.Leg(), w.Nakigoe()); //通常メソッドとオーバーライドメソッドを呼ぶ
        }
    }
}

p.235 プロパティのオーバーライド

・メソッドと同様で、多態性を実現できる
・基本クラスのプロパティを仮想プロパティにし、派生クラスのプロパティをオーバーライドプロパティにする

p.236 override03.cs

//p.236 override03.cs
using System;
class Mammal { //基本クラス(哺乳類)
    protected const int LegNo = 4; //脚の数は4本    
    public virtual string Nakigoe { //声を返す仮想プロパティ
        get { return "..."; } //setがないプロパティ
    }
    public int Leg() { //脚の数を返す通常メソッド
        return LegNo;
    }
}
class Cat : Mammal { //派生クラス(猫)
    public override string Nakigoe { //声を返すオーバーライドプロパティ
        get { return "ニャー、ニャー"; }
    }
}
class Dog : Mammal { //派生クラス(犬)
    public override string Nakigoe { //声を返すオーバーライドプロパティ
        get { return "ワン、ワン"; }
    }
}
       
class override03 {
    public static void Main() {
        Mammal m; //哺乳類クラスとその派生クラスを扱うための参照変数を定義
        Cat cat = new Cat(); //派生クラス(猫)のインスタンスを生成
        Dog dog = new Dog(); //派生クラス(犬)のインスタンスを生成
        m = cat; //派生クラス(猫)のインスタンスを基本クラス(哺乳類)で扱う
        Console.WriteLine("猫の脚の数は{0}本で、鳴き声は「{1}」です",
            m.Leg(), m.Nakigoe); //通常メソッドとオーバーライドプロパティ(猫)を呼ぶ
        m = dog; //派生クラス(犬)のインスタンスを基本クラス(哺乳類)で扱う
        Console.WriteLine("犬の脚の数は{0}本で、鳴き声は「{1}」です",
            m.Leg(), m.Nakigoe); //通常メソッドとオーバーライドプロパティ(犬)を呼ぶ
    }
}

＜自由参加課題＞ アレンジ演習：p.236 override03.cs

・基本クラス型の配列に、派生クラス型の２インスタンスを格納しよう
・配列の全要素について繰り返す中で、オーバーライドプロパティを呼んで多態性を確認しよう

p.237（オーバーライドインデクサ）

・メソッドと同様で、多態性を実現できる
・基本クラスのインデクサを仮想インデクサにし、派生クラスのインデクサをオーバーライドインデクサにする

作成例

//p.237 override04.cs
using System;
class Mammal { //基本クラス(哺乳類)
    protected const int LegNo = 4; //脚の数は4本
    protected string Tail, Gei, Food, Koe; //特徴を示す文字列変数
    public virtual string this[string index] { //声を返す仮想インデクサ
        get { return "..."; }
    }
    public int Leg() { //脚の数を返す通常メソッド
        return LegNo;
    }
}
class Cat : Mammal { //派生クラス(猫)
    public override string this[string index] { //オーバーライドインデクサ
        get {
            switch (index) { //インデックスの値により返す情報を選択する
                case "尾":
                    Tail = "1本";
                    return Tail;
                case "芸":
                    Gei = "できない";
                    return Gei;
                case "鳴き声":
                    Koe = "ニャー、ニャー";
                    return Koe;
                case "食べ物":
                    Food = "キャットフード";
                    return Food;
                default:
                    return "";
            }
        }
    }
}
class Dog : Mammal { //派生クラス(犬)
    public override string this[string index] { //オーバーライドインデクサ
        get {
            switch (index) { //インデックスの値により返す情報を選択する
                case "尾":
                    Tail = "1本";
                    return Tail;
                case "芸":
                    Gei = "できる";
                    return Gei;
                case "鳴き声":
                    Koe = "ワン、ワン";
                    return Koe;
                case "食べ物":
                    Food = "ドッグフード";
                    return Food;
                default:
                    return "";
            }
        }
    }
}
class override04 {
    public static void Main() {
        Mammal m;
        Cat cat = new Cat();
        Dog dog = new Dog();
        m = cat;
        //文字列をインデックスとしてオーバライドインデクサ(猫)を呼ぶ
        Console.WriteLine("猫の脚は{0}本です。尾は{1}です。芸は{2}。食べ物は{3}。",
            m.Leg(), m["尾"], m["芸"], m["食べ物"]);
        m = dog;
        //文字列をインデックスとしてオーバライドインデクサ(犬)を呼ぶ
        Console.WriteLine("犬の脚は{0}本です。尾は{1}です。芸は{2}。食べ物は{3}。",
            m.Leg(), m["尾"], m["芸"], m["食べ物"]);
    }
}

p.248 クラスの多層階層

・派生クラスを基本クラスとしてさらに派生することが可能（親子孫のイメージ）
・基本クラスのメンバは派生の派生クラスにも引き継がれる
・派生の派生クラスのオブジェクトを基本クラスの型で扱うことができる
・派生クラスで独自に記述したメソッドを派生の派生クラスでオーバライドするには、仮想メソッドにする
・派生クラスのオーバライドメソッドを派生の派生クラスでオーバライドするには、オーバライドメソッドで良い

p.240 inheritance05.cs

//p.240 inheritance05.cs
using System;
class MyBase { //基本クラス
    protected int x = 10; //継承可能なデータメンバ
    public virtual void show() { //オーバライド可能な仮想メソッド
        Console.WriteLine("x = {0}", x);
    }
}
class Derived1 : MyBase { //派生クラス
    //ここに「protected int x = 10;」があるとみなされる
    protected int y = 20; //継承可能なデータメンバ
    //ここに「public virtual void show() {…}」があるとみなされる
}
class Derived2 : Derived1 { //派生の派生クラス
    //ここに「protected int x = 10;」があるとみなされる
    //ここに「protected int y = 20;」があるとみなされる
    int z = 30;
    public override void show() { //派生クラスが継承したメソッドのオーバライド
        Console.WriteLine("z = {0}", z);
    }
}
class inheritance05 {
    public static void Main() {
        MyBase mb; //派生クラスと派生の派生クラスを扱うための参照変数を定義
        Derived1 d1 = new Derived1(); //派生クラスのインスタンスを生成
        Derived2 d2 = new Derived2(); //派生の派生クラスのインスタンスを生成
        mb = d1; //派生クラスのインスタンスを基本クラスで扱う
        mb.show(); //多態性により派生クラスのメソッドが動作
        mb = d2; //派生の派生クラスのインスタンスを基本クラスで扱う
        mb.show(); //多態性により派生の派生クラスのメソッドが動作
    }
}

p.243 クラスの継承とコンストラクタ（引数がない場合）

・どのクラスにおいても、コンストラクタを全く記述しないと、引数のない＆中身のないコンストラクタが自動的に用意される
・基本クラスのオブジェクトを引数なしのnewで生成すると、引数のないコンストラクタが呼ばれる
・派生クラスのオブジェクトを引数なしのnewで生成すると：
　① 基本クラスの引数のないコンストラクタが呼ばれる
　② 派生クラスの引数のないコンストラクタが呼ばれる
・こうすることで、基本クラスから継承したデータメンバの初期化などの処理も正しく行われる
・また、その派生クラスには不要でも基本クラスの機能を引き継ぐ上で必要な準備処理が正しく行われる
・よって、派生の派生クラスのオブジェクトを引数なしのnewで生成すると：
　① 基本クラスの引数のないコンストラクタが呼ばれる
　② 派生クラスの引数のないコンストラクタが呼ばれる
　③ 派生の派生クラスの引数のないコンストラクタが呼ばれる

p.243 inheritance06.cs

//p.243 inheritance06.cs
using System;
class MyBase { //基本クラス
    protected int x; //継承可能なデータメンバ
    public MyBase() { //①引数の無いコンストラクタ
        Console.WriteLine("ここはMyBase");
        x = 10; //データメンバの初期化
    }
}
class Derived1 : MyBase { //派生クラス
    //ここに「protected int x;」があるとみなされる
    public Derived1() { //②引数の無いコンストラクタ
        //この直前に基本クラスの①引数の無いコンストラクタが実行される
        Console.WriteLine("ここはDerived1");
        x = 20; //データメンバの初期化
    }
}
class Derived2 : Derived1 { //派生の派生クラス
    //ここに「protected int x;」があるとみなされる
    public Derived2() {  //③引数の無いコンストラクタ
        //この直前に基本クラスの①引数の無いコンストラクタが実行される
        //この直前に派生クラスの②引数の無いコンストラクタが実行される
        Console.WriteLine("ここはDerived2");
        x = 30; //データメンバの初期化
    }
    public void show() { //派生の派生クラスの独自のメソッド
        Console.WriteLine("x = {0}", x);
    }
}
class inheritance06 {
    public static void Main() {
        Derived2 d2 = new Derived2(); //派生の派生クラスのインスタンスを生成(①②③の実行)
        d2.show(); //③が最後に動くので30になっている
    }
}

p.245 基本クラスのコンストラクタが引数をとる場合

・例えば、派生の派生クラスのコンストラクタの引数を「int i」とし、派生クラスのコンストラクタの引数も「int i」とするとエラーになる
・これは、派生クラスのコンストラクタの引数を与える手段がないから
・同様に、基本クラスのコンストラクタの引数も「int i」とするとエラーになる
・これは、基本クラスのコンストラクタの引数を与える手段がないから
・これを解決するのが、コンストラクタにおけるbaseキーワードによる引数渡しの指定
・書式例： public クラス名(引数リスト) : base(引数,…){…}
・baseキーワードに指定する引数はコンストラクタの引数を用いると良い
・例： public Derived2(int i) : base(i) {…} //派生クラスのコンストラクタに引数iの値を渡す
・例： public Derived1(int i) : base(i) {…} //基本クラスのコンストラクタに引数iの値を渡す

提出：アレンジ演習：p.243 inheritance06.cs

・３つのクラスのコンストラクタの引数をすべて「int i」にしたい
・xの初期値をiで与えるとする
・派生クラスのコンストラクタと、派生の派生クラスのコンストラクタにbaseキーワードを追加しよう
・Mainで派生の派生クラスのコンストラクタに引数で90を与えてみよう

・p.228「名前の隠ぺい」から

p.228 名前の隠ぺい

・隠ぺいは「おおい隠す＝元を残して上に定義を乗せる」イメージ
・派生クラスで基本クラスと同一のメンバ名を記述できる仕掛け
・この時、newキーワードを前置することで「隠ぺいしている」ことを明示する
※ C#のバージョンによってはnewを記述しなくても隠ぺいできる場合があるが、明示したほうが良い

p.338 inheritance03

//p.338 inheritance03
using System;
class Base { //基本クラス
    public int x = 10;
    public void BaseMethod() {
        Console.WriteLine("Baseクラスです");
    }
}
class Derived : Base { //派生クラス
    new public int x = 20; //データメンバの名前の隠ぺい
    new public void BaseMethod() { //メソッドの名前の隠ぺい
        Console.WriteLine("Derivedクラスです");
    }
}
class inheritance03 {
    public static void Main() {
        Derived d = new Derived(); //派生クラスのインスタンスを生成
        Console.WriteLine("x = {0}", d.x); //派生クラスで隠ぺいしたデータメンバを利用
        d.BaseMethod(); //派生クラスで隠ぺいしたメソッドを利用
    }
}

アレンジ演習：p.338 inheritance03

・private指定(または無指定)のメンバの名前の隠ぺいと、protected指定のメンバの名前の隠ぺいの可否を確認しよう
→ どの場合も名前の隠ぺいは可能であり、派生クラスでpublic指定してあれば、外部からも利用可能

作成例

//アレンジ演習：p.338 inheritance03
using System;
class Base { //基本クラス
    protected int x = 10;
    protected void BaseMethod() { //メソッドの名前の隠ぺい
        Console.WriteLine("Baseクラスです");
    }
}
class Derived : Base { //派生クラス
    new public int x = 20; //データメンバの名前の隠ぺい
    new public void BaseMethod() { //メソッドの名前の隠ぺい
        Console.WriteLine("Derivedクラスです");
    }
}
class inheritance03 {
    public static void Main() {
        Derived d = new Derived(); //派生クラスのインスタンスを生成
        Console.WriteLine("x = {0}", d.x); //派生クラスで隠ぺいしたデータメンバを利用
        d.BaseMethod(); //派生クラスで隠ぺいしたメソッドを利用
    }
}

p.229（baseキーワード）

・名前の隠ぺいは基本クラスと同じ意味のメンバに同じ名前を与えることで、似た名前のメンバの乱立を避けられる
・また「上書き」ではないので、隠ぺいの対象となった基本クラスのメンバを「base.」を前置することで利用可能

p.229 inheritance04.cs

//p.229 inheritance04.cs
using System;
class Base { //基本クラス
    protected int x = 10; //隠ぺいされるデータメンバ
}
class Derived : Base { //派生クラス
    new int x = 20; //名前の隠ぺいを行う指定
    public void Show() {
        Console.WriteLine("base.x = {0}, x = {1} ", base.x, x); //基本クラスのメンバを利用
    }
}
class inheritance04 {
    public static void Main() {
        Derived d = new Derived(); //派生クラスのインスタンスを生成
        d.Show();
    }
}

p.230 メソッドのオーバーライド

・メソッドにおける名前の隠ぺいの手法の一つだが、名前の隠ぺいでは実現できない多態性(後述)が可能な仕掛け
・通常、メソッドにおいてはオーバーライドを用いることが多い。
・名前の隠ぺいとは異なり、基本クラス側のメソッドでオーバーライドを認めることを示す「virtual」キーワードを指定する必要がある（仮想メソッドともいう）
・派生クラスではオーバーライドメソッドであることを、overrideキーワードで明示する
・オーバーライドではシグニチャに加えてアクセス修飾子を一致させる。
※ 静的メソッドのオーバーライドは不可（名前の隠ぺいは可能）

p.231 override01.cs

//p.231 override01.cs
using System;
class MyBase { //基本クラス
    public virtual void Method() { //オーバーライド可能な仮想メソッドの定義
        Console.WriteLine("MyBase");
    }
}
class Derived1 : MyBase { //派生クラス
    public override void Method() {　//オーバーライドメソッド①の定義
        Console.WriteLine("Derived1");
    }
}
class Derived2 : MyBase { //派生クラス
    public override void Method() {　//オーバーライドメソッド②の定義
        Console.WriteLine("Derived2");
    }
}
class override01 {
    public static void Main() {
        Derived1 d1 = new Derived1();
        Derived2 d2 = new Derived2();
        d1.Method(); //オーバーライドメソッド①
        d2.Method(); //オーバーライドメソッド②
    }
}

アレンジ演習：p.231 override01.cs

・MyBaseクラスとDerived1クラスにデータメンバを追加して名前の隠ぺいを行おう
・MyBaseクラスとDerived2クラスに静的メソッドを追加して名前の隠ぺいを行おう

作成例

//アレンジ演習：p.231 override01.cs
using System;
class MyBase { //基本クラス
    public int n; //【追加】データメンバ（オーバーライド不可）
    public virtual void Method() { //オーバーライド可能な仮想メソッドの定義
        Console.WriteLine("MyBase");
    }
    public static void Methods() { //【追加】オーバーライド不可な静的メソッドの定義
        Console.WriteLine("MyBases");
    }
}
class Derived1 : MyBase { //派生クラス
    new public int n; //【追加】データメンバの名前を隠ぺい
    public override void Method() {　//オーバーライドメソッド①の定義
        Console.WriteLine("Derived1");
    }
}
class Derived2 : MyBase { //派生クラス
    public override void Method() {　//オーバーライドメソッド②の定義
        Console.WriteLine("Derived2");
    }
    new public void Methods() {　//【追加】静的メソッドの名前の隠ぺい
        Console.WriteLine("Derived2s");
    }
}
class override01 {
    public static void Main() {
        Derived1 d1 = new Derived1();
        Derived2 d2 = new Derived2();
        d1.Method(); //オーバーライドメソッド①
        d2.Methods(); //静的メソッドの名前の隠ぺい
    }
}

販売本数ランキング 今回トップも「ピクミン4(Switch)」GO!
gamescom award 2023の受賞作が発表。『ゼルダの伝説 ティアキン』が4冠に輝く【gamescom 2023】 GO!
バンダイナムコスタジオが語る、オンラインホワイトボードMiroを使ったリモートワークの効率化とコミュニケーションの円滑化【CEDEC2023】GO!
『FF16』顔のシワは形状の変形ではなくテクスチャのブレンドで表現。3Dキャラに必須の仕事人“リガー”のイロハと魅力【CEDEC2023】GO!
数値化された盛り上がりでシャウトを5段階に！条件設定や負荷軽減法が紹介された『ストリートファイター6』自動実況機能セッション【CEDEC2023】GO!
四半期過去最高益の任天堂―映画『マリオ』の大ヒットはなぜ重要？【ゲーム企業の決算を読む】GO!
NVIDIA、新発表「DLSS 3.5」によるAI強化のリアルタイムレイトレーシングを公開 GO!

販売本数ランキング 今回トップも「ピクミン4(Switch)」GO!
サイバーエージェントが下方修正、『ウマ娘』の反動で冬の時代到来か【ゲーム企業の決算を読む】GO!
連続投入した『モンスト』最新作が不発―MIXIの業績に黄色信号【ゲーム企業の決算を読む】GO!
【CEDEC2023】「Live2D Cubism」がCEDEC2023に登壇・展示―Unityでの活用方法を紹介 GO!
【決算】TCG好調のブシロード、『ヴァイスシュヴァルツ』が過去最高売上も純利益4割減 GO!
『ロケットリーグ』まさかの映画化？実話をもとにしたe-Sports映画「PLAY! ～勝つとか負けるとかは、どーでもよくて～」2024年春公開決定 GO!
【CEDEC2023】ロケーションゲーム特化のデジタルマップ開発技術を紹介―マップボックス・ジャパン「CEDEC2023」に初出展 GO!

「生成AIは著作権保護の検討が不十分」新聞協会など声明　「著作権法30条の4は大きな課題」GO!
X（旧Twitter）のイーロン・マスクCTO、「ブロック機能を削除する予定」とポスト GO!
「早急なパスワード変更を」　ピクブラ情報漏えいで、ニコニコやピクシブなどが注意喚起 GO!

【追記】Unity ゲーミングレポート 2023 （日本語版）公開 GO!

スタッフからビデオ補講の案内があると思いますので、下記の講義メモ（半年前のクラス）を見ながら学習してみてください。
　・講義メモ p.207-222：https://ha226.rundog.org/?p=762
　・講義メモ p.222-222：https://ha226.rundog.org/?p=796
　・講義メモ p.223-229：https://ha226.rundog.org/?p=800
次回、8/26はp.230「9.3 メソッドのオーバーライド」から再開したいと思います。
疑問点がありましたら。提出フォームからお送りください。

・P199のプログラムではコマンドプロンプトで処理の結果を確認したのですが、見慣れない文字ばかりでなにがなんだか。。という感じでした。
　visual　studioなどのアプリが開発されてとても使いやすくなってるんだなと実感したのと、いつかはコマンドプロンプトなどもっと細かい
ところも理解を深めてみたいと思いました。

　コマンドプロンプトはWindowsが出来る前のインタフェースですので、面食らわれたのではと思います。
　理解しておくと便利ですので、是非どうぞ。

・P201のparams のアレンジ演習をやりましたので確認お願いいたします！(*^▽^*)

　拝見しました。しっかり理解していますね。
　敢えて言えば「Myclass mc =new Myclass();」の「=」は、前にスペースを置いていますので、後ろにも置くと読みやすくなりますよ。

・なかなか苦戦してたオーバーロード達ですが、家でもいろいろ練習してみたら
　使い方などの理解を少しだけ深められたきがします。

　何よりです。

・プログラムも使い方次第では１行で済んだりと面白くて興味深いと思いました。
　なかなか１回でパッと思いつきませんが・・・(;^ω^)

　慣れてくると思いつけるようになりますよ♪

・この先もまたオーバーロードちゃんが出てくるのでついていけるように
　頑張ります！！！

　応援します。

　さて、次回、お休みとのこと承知致しました。
　スタッフからビデオ補講の案内があると思いますので、下記の講義メモ（半年前のクラス）を見ながら学習してみてください。
　・講義メモ p.197-201：https://ha226.rundog.org/?p=715
　・講義メモ p.202-206：https://ha226.rundog.org/?p=746
　次回、8/19はp.207「プロパティ」から再開したいと思います。
　疑問点がありましたら。提出フォームからお送りください。

次回予告：p.197「mainメソッドのオーバーロード」から再開します
講義メモ：講義メモ20230729.zip