C#基礎入門第十三天（多態接口）

第十二天覆習

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("請坐");
    }
}

}

第十三天新內容
1、C#中的訪問修飾符
public:公開的，公共的
private: 私有的，只能在當前類的內部訪問
protected: 受保護的，只能在當前類的內部以及該類的子類中訪問
internal:只能在當前程序集中訪問，在同一個項目中和public的權限是同樣的。
protected internal:protected和internal的權限相加

1.可以修飾類的訪問修飾符只有：public和internal
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("我是惠普筆記本");
    }
}
}

3、值類型和引用類型的傳遞
值類型在複製的時候，傳遞時是這個值得自己
引用類型在複製的時候，傳遞的是對這個對象的引用

4、序列化和反序列化
序列化：將對象轉換爲二進制
反序列化：將二進制轉換爲對象
做用：傳輸數據
序列化：
一、將這個類標記爲能夠被序列化的，在類上面加關鍵字：[Serializable]

語法

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、部分類
在同一個命名空間下寫同名的類,關鍵字：partial
多用於多人開發時須要寫一個類
語法

public partial class 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;
}
成員...
}

接口的成員有：方法、自動屬性、索引器 可是：自動屬性本質也是兩個函數，索引器也是函數。因此：接口的成員就有：方法

接口的特色：
接口是一種規範，只要一個類繼承一個接口，這個類就必須實現這個接口中全部的成員

public class Person : IFyable
{
    //實現這個接口中全部的成員
    public void Fly()
    {
        Console.WriteLine("飛");
    }
}

public interface IFyable
{
    void Fly();
}

爲了多態，接口不能被實例化。也就是說，接口不能new（不能建立對象）

static void Main(string[] args)
    {
        //接口是不能被實例化的，由於接口中的成員沒有方法體
        // IFyable fly = new IFyable();
        //若是要想實現多態，則須要指向一個對象
        IFyable fly = new Person();
        fly.Fly();
        Console.ReadKey();
    }

接口中的成員不能加「訪問修飾符」，接口中的成員訪問修飾符默認爲public，不能修改。接口中的成員不能有任何實現（「光說不練」，只是定義一組未實現的成員。相似於抽象類中的抽象函數）

接口中只能有方法、自動屬性、索引器、事件，不能有「字段」和構造函數

接口與接口之間能夠繼承，而且能夠多繼承

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();
    }
}

接口並不能去繼承一個類，而類能夠繼承接口（接口只能繼承於接口，而類便可繼承接口，也可繼承類）
實現接口的子類，必須實現該接口的所有成員
一個類能夠同時繼承一個類並實現多個接口，若是一個子類同時繼承父類A。並實現接口接口IA，那麼語法上A必須寫在IA的前面
語法：
public class 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();
}
}

總結：
一、何時用虛方法來實現多態
在提供出來的類中，能抽象出來一個父類，父類必須寫上子類共有的方法，知道這個方法怎麼寫，而且還須要建立父類的對象，這時候就使用虛方法

二、何時用抽象類來實現多態
在提供出來的類中，能抽象出來一個父類，父類必須寫上子類共有的方法，而且不知道這個方法怎麼寫，這時候就使用抽象類

三、何時用接口來實現多態
幾個類中，找不出父類，可是他們都有一個共同的行爲，就時候就使用接口

接口練習

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）,包含價格（Price）、數量（Count）、編號（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至關於倉庫，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;
    }
}