C＃基本紹介13日目（ポリモーフィックインターフェイス）

12日目のレビュー

namespace 复习
{
class Program
{
    static void Main(string[] args)
    {
        /*
         Lisi<T>
         Dictionary<K,T>
         拆装箱
         装箱：值类型转为引用类型
         拆箱：引用类型转为值类型
         应该尽量避免在代码中发生

         文件流
         FileStream  StreamReader和StreamWrite
         多态：虚方法、抽象类、接口
         虚方法
         抽象类
         */

        //List<int> list = new List<int>();

        //Dictionary<int, string> dic = new Dictionary<int, string>();
        //dic.Add(1, "张三");
        //dic[2] = "李四";
        //foreach (KeyValuePair<int ,string> kv in dic)
        //{
        //    Console.WriteLine("{0}----{1}", kv.Key, kv.Value);
        //}
        //Console.ReadKey();

        //File   FileStream  StreamReader  StreamWrite
        //using (FileStream fsRead = new FileStream("1.txt", FileMode.OpenOrCreate, FileAccess.Read))
        //{
        //    byte[] buffer = new byte[1024 * 1024 * 5];
        //    int r = fsRead.Read(buffer, 0, buffer.Length);
        //    string s = Encoding.UTF8.GetString(buffer, 0, r);
        //    Console.WriteLine(s);
        //}
        //Console.ReadKey();

        //using (FileStream fsWrite = new FileStream(@"C:\Users\Administrator\Desktop\new.txt", FileMode.OpenOrCreate, FileAccess.Write))
        //{
        //    string s = "今天的内容有点多啊";
        //    byte[] buffer = Encoding.UTF8.GetBytes(s);
        //    fsWrite.Write(buffer, 0, buffer.Length);
        //}
        //Console.WriteLine("OK");
        //Console.ReadKey();

        //虚方法和抽象类
        //老师可以起立，学生也可以起立,校长也可以起立
        //Person p = new Student();
        //p.StanUp();
        //Console.ReadKey();
    }
}
public abstract class Person
{
    public abstract void StanUp();
}

public class Student : Person
{
    public override void StanUp()
    {
        Console.WriteLine("学生起立，说老师好");
    }
}

public class Teachar : Person
{
    public override void StanUp()
    {
        Console.WriteLine("老师起立说校长好");
    }
}

public class HeadMaster : Person
{
    public override void StanUp()
    {
        Console.WriteLine("请坐");
    }
}

}

13日目の新しいコンテンツ
1.C＃のアクセス修飾子
public：public、public
private：private、現在のクラス内でのみアクセス可能
protected：protected、現在のクラスとクラス内でのみアクセス可能
：のサブクラスの内部アクセスは、現在のアセンブリでのみアクセスでき、同じプロジェクトのパブリックと同じ権限を持っています。
保護された内部：保護された内部の権限を追加します

1.クラスを変更できるアクセス修飾子はパブリックと内部のみ
です。2。
サブクラスのアクセス可能性を親クラスのアクセス可能性より高くすることはできません。高くしないと、親クラスのメンバーが公開されます。

2.設計パターン（このプロジェクトを設計する方法。）
単純な工場設計パターン

namespace _03简单工厂设计模式
{
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("请输入你需要的笔记本品牌");
        string note = Console.ReadLine();
        NoteBook nb = GetNoteBook(note);
        nb.SayHello();
        Console.ReadKey();
    }

    /// <summary>
    /// 简单工厂的核心，根据用户输入的对象来赋值给父类
    /// </summary>
    /// <param name="note"></param>
    /// <returns></returns>
    public static NoteBook GetNoteBook(string note)
    {
        NoteBook nb = null;
        switch (note)
        {
            case "Lenove" : nb = new Lenovo();
                break;
            case "Acre" : nb = new Acre();
                break;
            case "Dell" : nb = new Dell();
                break;
            case "Hp" : nb = new Hp();
                break;
        }
        return nb;
    }
}

public abstract class NoteBook
{
    public abstract void SayHello();
}

public class Lenovo : NoteBook
{
    public override void SayHello()
    {
        Console.WriteLine("我是联想笔记本，你连想都别想");
    }
}

public class Acre : NoteBook
{
    public override void SayHello()
    {
        Console.WriteLine("我是宏碁笔记本");
    }
}

public class Dell : NoteBook
{
    public override void SayHello()
    {
        Console.WriteLine("我是戴尔笔记本");
    }
}

public class Hp : NoteBook
{
    public override void SayHello()
    {
        Console.WriteLine("我是惠普笔记本");
    }
}
}

第三に、値タイプと参照タイプの転送
値タイプがコピーされると、それは値自体になります。
参照タイプがコピーされると、このオブジェクトへの参照が渡されます。

4.シリアル化と逆シリアル化シリアル化
：オブジェクトをバイナリに変換します逆シリアル化：
バイナリをオブジェクトに変換します
機能：データの
シリアル化を転送します：
1。このクラスをシリアル化可能としてマークし、クラスにキーを追加します単語：[シリアル化可能]

文法

namespace _04序列化和反序列化
{
class Program
{
    static void Main(string[] args)
    {
        ////序列化
        //Person p = new Person();
        //p.Name = "张三";
        //p.Age = 18;
        //p.Gender = '男';
        //using (FileStream fsWrite = new FileStream(@"C:\Users\Administrator\Desktop\111.txt", FileMode.OpenOrCreate, FileAccess.Write))
        //{
        //    //开始序列化对象
        //    BinaryFormatter bf = new BinaryFormatter();
        //    bf.Serialize(fsWrite, p);
        //}
        //Console.WriteLine("写入成功");
        //Console.ReadKey();

        //接收对方发送过来的二进制 反序列化成对象
        Person p;
        using (FileStream fsRead = new FileStream(@"C:\Users\Administrator\Desktop\111.txt", FileMode.OpenOrCreate, FileAccess.Read))
        {
            BinaryFormatter bf = new BinaryFormatter();
           p = (Person)bf.Deserialize(fsRead);
        }
        Console.WriteLine(p.Name);
        Console.WriteLine(p.Age);
        Console.WriteLine(p.Gender);
        Console.ReadKey();
    }
}

[Serializable]
public class Person
{
    private string _name;
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
    private int _age;
    public int Age
    {
        get { return _age; }
        set { _age = value; }
    }
    private char _gender;
    public char Gender
    {
        get { return _gender; }
        set { _gender = value; }
    }
}
}

5つ目は、一部のクラス
は同じ名前で同じ名前で記述されている、キーワード：部分的は
主に複数人の開発に使用されるため、クラス
構文を記述する必要があります

パブリック部分クラスPerson

6つの封印されたクラス
は継承できませんが、封印されたクラスは他のクラス
構文を継承できます
public Sealed class Person

7、ToStringメソッドを書き直し
ます。すべてをToStringにすることができます。ToStringはObjectのメソッドである必要があり、すべてのオブジェクトはObjectのサブクラス
構文です。

namespace _05重写ToString方法
{
class Program
{
    static void Main(string[] args)
    {
        Person p = new Person();
        Console.WriteLine(p.ToString());
        Console.ReadKey();
    }
}

public class Person
{
    public override string ToString()
    {
        return "Hello word";
    }
}
}

8.インターフェイス（インターフェイスは仕様、機能）
構文
[public] interface I ... able
{
//インターフェイスのメンバーはアクセス修飾子を追加できません。デフォルトはpublicです
//インターフェイスでは、メソッド本体を持つ関数は許可されていません、フィールドを含めることはできません
//インターフェイスでは、自動属性を書き込むことができます（書き込まれませんが、コンパイル時に自動的に生成されます）
public int Age
{
get;
set;
}
メンバー...
}

インターフェイスのメンバーは、メソッド、自動属性、およびインデクサーです。ただし、自動属性は基本的に2つの関数であり、インデクサーも関数です。だから：インターフェースのメンバーは：メソッドを持っています

インターフェイスの特性：インターフェイスは仕様です。クラスがインターフェイスを継承している限り、クラスはインターフェイスのすべてのメンバーを実装する必要があります。

public class Person : IFyable
{
    //实现这个接口中所有的成员
    public void Fly()
    {
        Console.WriteLine("飞");
    }
}

public interface IFyable
{
    void Fly();
}

多態性の場合、インターフェイスをインスタンス化することはできません。つまり、インターフェイスを新しくすることはできません（オブジェクトを作成することはできません）

static void Main(string[] args)
    {
        //接口是不能被实例化的，因为接口中的成员没有方法体
        // IFyable fly = new IFyable();
        //如果要想实现多态，则需要指向一个对象
        IFyable fly = new Person();
        fly.Fly();
        Console.ReadKey();
    }

「アクセス修飾子」をインターフェイスのメンバーに追加することはできません。インターフェイスのメンバーアクセス修飾子はデフォルトでパブリックであり、変更できません。インターフェイスのメンバーは実装できません（「練習せずに話すだけ」、実装されていないメンバーのグループを定義するだけです。抽象クラスの抽象関数と同様）

インターフェイスには、メソッド、自動プロパティ、インデクサー、およびイベントのみが存在でき、「フィールド」およびコンストラクターは存在できません。

インターフェイスとインターフェイスは継承でき、複数を継承できます

public interface M1
{
    void Test1();
}
public interface M2
{
    void Test2();
}
public interface M3
{
    void Test3();
}
public interface M4:M1,M2,M3
{

}
public class Cat : M4
{
    public void Test1()
    {
        throw new NotImplementedException();
    }

    public void Test2()
    {
        throw new NotImplementedException();
    }

    public void Test3()
    {
        throw new NotImplementedException();
    }
}

インターフェイスはクラスを継承できず、クラスはインターフェイスを継承できます（インターフェイスはインターフェイスからのみ継承でき、クラスはインターフェイスまたはクラスを継承できます）。
インターフェイスのサブクラスを実装するには、インターフェイスのすべてのメンバーを実装する必要があります
。1つのクラスを同時に実装できます。サブクラスが親クラスAも継承する場合は、クラスを継承し、複数のインターフェイスを実装します。そして、インターフェースインターフェースIAを実装します。次に、構文AをIA
構文の前に記述する必要があります。
パブリッククラスB：A、IA
{
クラスメンバー
}

ネットワーク全体のこの一連のビデオにはインターフェイスに問題があるため、レビューに任せます。

namespace _06接口
{
class Program
{
    static void Main(string[] args)
    {
        //接口是不能被实例化的，因为接口中的成员没有方法体
        // IFyable fly = new IFyable();
        //如果要想实现多态，则需要指向一个对象
        IFyable fly = new Person();
        fly.Fly();
        Console.ReadKey();
    }
}

public class Person : IFyable
{
    //实现这个接口中所有的成员
    public void Fly()
    {
        Console.WriteLine("飞");
    }
}

public interface IFyable
{
    void Fly();
}

public interface M1
{
    void Test1();
}
public interface M2
{
    void Test2();
}
public interface M3
{
    void Test3();
}
public interface M4:M1,M2,M3
{

}
public class Cat : M4
{
    public void Test1()
    {
        throw new NotImplementedException();
    }

    public void Test2()
    {
        throw new NotImplementedException();
    }

    public void Test3()
    {
        throw new NotImplementedException();
    }
}
}

9、実装インターフェイスの
文法と使用法を表示します（メソッドの同じ名前の問題を解決するため）

namespace _07显示实现接口
{
class Program
{
    static void Main(string[] args)
    {
        IFlyable fly = new bird();
        fly.Fly();
        bird bi = new bird();
        bi.Fly();
        Console.ReadKey();
    }
}

public class bird:IFlyable
{
    public void Fly()
    {
        Console.WriteLine("鸟会飞");
    }
    /// <summary>
    /// 显示实现接口
    /// </summary>
    void IFlyable.Fly()
    {
        Console.WriteLine("我是接口的飞");
    }
}

public interface IFlyable
{
    void Fly();
}
}

概要：
1。仮想メソッドを使用して多態性を実現する場合
提供されたクラスでは、親クラスを抽象化できます。親クラスは、サブクラスによって共有されるメソッドを記述し、このメソッドの記述方法を知っている必要があります。また、親クラスを作成する必要があります。オブジェクトを作成し、仮想メソッドを使用します

2.抽象クラスを使用して多態性を実現する場合
提供されたクラスでは、親クラスを抽象化できます。親クラスは、サブクラスによって共有されるメソッドを作成する必要があり、このメソッドの作成方法がわからない場合は、抽象クラスを使用します。

3.インターフェイスを使用して多態性を実装する場合
。いくつかのクラスの中で親クラスが見つかりませんが、すべて共通の動作をしているため、すぐにインターフェイスを使用してください。

インターフェース演習

namespace _08接口练习
{
class Program
{
    static void Main(string[] args)
    {
        //真的鸭子会游泳，木头鸭子不会游泳，橡皮鸭子会游泳
        ISwimming swim = new RealDuck();
        swim.Swim();
        Console.ReadKey();
    }
}

public class RealDuck : ISwimming
{
    public void Swim()
    {
        Console.WriteLine("真的鸭子会游泳");
    }
}
public class MuDuck
{

}
public class XPDuck : ISwimming
{
    public void Swim()
    {
        Console.WriteLine("橡皮鸭子漂着游泳");
    }
}

public interface ISwimming
{
    void Swim();
}
}

包括的な実際の戦闘：スーパーマーケットのキャッシャーシステム

システム要件を分析します
。スーパーマーケットが提供する製品：ラップトップ、携帯電話、大豆ソース、バナナ。
スーパーマーケットの製品には、価格、数量、数が必要です。
これにより、価格（価格）と数量（カウント）を含む親カテゴリ（ProductFather）を抽象化できます。、番号（ID）

物を売るのに十分でない場合は、倉庫に行って、倉庫に
必要な機能（商品の保管、受け取り、購入）を取得する必要があります。

スーパーマーケットが物を売るとき、彼らは現金登録機能を必要とします

商品の親カテゴリを抽象化します

class ProductFather
{
    public decimal Price
    {
        get;
        set;
    }

    public double Count
    {
        get;
        set;
    }

    public string ID
    {
        get;
        set;
    }

    public ProductFather(string id, decimal price, double count)
    {
        this.ID = id;
        this.Price = price;
        this.Count = count;
    }
}

それぞれ製品クラスを作成し、親クラスから継承します

class ShouJi:ProductFather
{
    public ShouJi(string id, decimal price, double count) : base(id, price, count)
    {

    }
}

倉庫クラスを作成する

class CangKu
{
// 1。ストアグッズ
//1.1リストは倉庫に相当し、List <ProductFather>はデータのコレクションを追加します。これは、倉庫に棚を置くことに相当し、
List <List <ProductFather >> list = new List <List <を分類します。ProductFather >>（）;

    /// <summary>
    /// 想用户展示货物
    /// </summary>
    public void ShowPros()
    {
        foreach (var item in list)
        {
            Console.WriteLine("仓库有：" + item[0].Name + "," + "\t" + "有" + item.Count + "个，" + "\t" + "每个" + item[0].Price + "元。");
        }
    }

    /// <summary>
    /// 创建仓库对象时，向仓库中添加货架
    /// </summary>
    //list[0] 存电脑  list[1]存手机 list[2]存酱油 list[3]存香蕉，这时候如果多，就能通过循环来完成
    public CangKu()
    {
        list.Add(new List<ProductFather>());
        list.Add(new List<ProductFather>());
        list.Add(new List<ProductFather>());
        list.Add(new List<ProductFather>());
    }

    /// <summary>
    /// 进货
    /// </summary>
    /// <param name="strType">货物的类型</param>
    /// <param name="count">货物的数量</param>
    public void GetPros(string strType,int count)
    {
        for (int i = 0; i < count; i++)
        {
            switch (strType)
            {
                case "NoteBook": list[0].Add(new NoteBook(Guid.NewGuid().ToString(), 5000, "笔记本电脑"));
                    break;
                case "ShouJi":list[1].Add(new ShouJi(Guid.NewGuid().ToString(), 3000, "手机"));
                    break;
                case "JiangYou":list[2].Add(new JiangYou(Guid.NewGuid().ToString(), 10, "酱油"));
                    break;
                case "Banana":list[3].Add(new Banana(Guid.NewGuid().ToString(), 20, "香蕉"));
                    break;
            }
        }
    }

    /// <summary>
    /// 取货
    /// </summary>
    /// <param name="strType">货物的类型</param>
    /// <param name="count">货物的数量</param>
    //货物取出后，需要放哪？而且有可能会拿很多个所以返回ProductFather[]
    public ProductFather[] QuPros(string strType, int count)
    {
        ProductFather[] pros = new ProductFather[count];
        for (int i = 0; i < count; i++)
        {
            switch (strType)
            {
                case "NoteBook":
                    if (list[0].Count == 0)
                    {
                        Console.WriteLine("没有电脑了！");
                    }
                    else
                    {
                        pros[i] = list[0][0];
                        list[0].RemoveAt(0);
                    }
                    break;
                case "ShouJi":
                    if (list[1].Count == 0)
                    {
                        Console.WriteLine("没有手机了！");
                    }
                    else
                    {
                        pros[i] = list[1][0];
                        list[1].RemoveAt(0);
                    }
                    break;
                case "JiangYou":
                    if (list[2].Count == 0)
                    {
                        Console.WriteLine("没有酱油了！");
                    }
                    else
                    {
                        pros[i] = list[2][0];
                        list[2].RemoveAt(0);
                    }
                    break;
                case "Banana":
                    if (list[3].Count == 0)
                    {
                        Console.WriteLine("没有酱油了！");
                    }
                    else
                    {
                        pros[i] = list[3][0];
                        list[3].RemoveAt(0);
                    }
                    break;
            }
        }
        return pros;
    }
}