C#基礎入門第十二天（面向對象多態，File操做流，泛型集合）

複習

static void Main(string[] args)
    {
        /*
         里氏轉換
         一、子類賦值給父類（若是有一個父類做爲參數，咱們能夠傳遞一個子類對象）
         二、若是父類中裝的是子類對象，則能夠將這個父類強轉爲子類對象
         */
        // Person p = new Teachar();
        //is
        //if (p is Teachar)
        //{
        //    ((Teachar)p).TeacharSayHello();
        //}
        //else
        //{
        //    Console.WriteLine("轉換失敗");
        //}
        //Console.ReadKey();

        //as
        //Teachar t = p as Teachar;
        //t.TeacharSayHello();
        //Console.ReadKey();

        //ArrayList list = new ArrayList();
        //方法：Remove RemoveAt RemoveRange Clear Insert  InsertRange Revers Sort

        //Hashtable ht = new Hashtable();
        //ht.Add(1, "張三");
        //ht.Add(true, '男');
        ////在鍵值對集合中，鍵必須是惟一的
        ////ht.Containskey  判斷當前是否包含這個鍵
        //foreach (var item in ht.Keys)
        //{
        //    Console.WriteLine("{0}-------{1}", item, ht[item]);
        //}
        //Console.ReadKey();

        //兩個類都是靜態類
        //Path類：

        //File類：文本文件進行讀寫
        //byte[] buffer = File.ReadAllBytes(@"C:\Users\Administrator\Desktop\1.txt");
        ////將字節數組中的每個元素都要按照咱們制定的編碼格式解碼成字符串
        ////UTF-8 GB2312 GBK ASCII Unicode
        //// string s = Encoding.Default.GetString(buffer);
        //string s = Encoding.GetEncoding("gb2312").GetString(buffer);
        //Console.WriteLine(s);

        //若是沒有這個文件，系統會建立一個，有就覆蓋
        string str = "今每天氣不錯，挺風和日麗的";
        byte[] buffer = Encoding.Default.GetBytes(str);
        File.WriteAllBytes(@"C:\Users\Administrator\Desktop\2.txt",buffer);
        Console.WriteLine("寫入成功");
        Console.ReadKey();
    }
}

public class Person
{
    public void PersonSayHello()
    {
        Console.WriteLine("我是人類");
    }
}
public class Teachar : Person
{
    public void TeacharSayHello()
    {
        Console.WriteLine("我是老師類");
    }
}

十二天新內容
1、絕對路徑和相對路徑
絕對徑路：經過給定的這個路徑直接能在個人電腦中找到這個文件
相對路徑：文件相對於應用程序的路徑
開發中儘可能使用相對路徑
File類最大的缺點：只能讀取小文件，由於浪費內存

static void Main(string[] args)
    {
        // //以行的形式讀取  須要操做每行數據用這個
        //string[] s = File.ReadAllLines(@"C:\Users\Administrator\Desktop\1.txt");
        // foreach (string item in s)
        // {
        //     Console.WriteLine(item);
        // }
        // Console.ReadKey();

        // //拿到是一個字符串
        //string str = File.ReadAllText("1.txt", Encoding.Default);
        //Console.WriteLine(str);
        //Console.ReadKey();

        //File.WriteAllLines(@"C:\Users\Administrator\Desktop\1.txt", new string[] { "a", "o", "e" });
        //Console.WriteLine("寫入成功");
        //Console.ReadKey();

        //File.WriteAllText(@"C:\Users\Administrator\Desktop\1.txt",  "aoeiuv");
        //Console.WriteLine("寫入成功");
        //Console.ReadKey();

        //新增寫入，不覆蓋以前的內容
        File.AppendAllLines(@"C:\Users\Administrator\Desktop\1.txt", new string[] { "有", "沒", "有" });
        Console.WriteLine("OK");
        Console.ReadKey();
    }

2、List泛型集合
語法及方法

static void Main(string[] args)
    {
        //建立泛型集合對象
        List<int> list = new List<int>();
        list.Add(1);
        list.Add(2);
        list.AddRange(new int[] { 1,2,3,40});
        list.AddRange(list);

        //List泛型集合能夠轉換爲數組
        int[] num = list.ToArray();

        List<string> listStr = new List<string>();
        string[] str = listStr.ToArray();

        //數組轉爲List泛型集合
        List<int> listTwo = num.ToList();

        char[] chs = new char[] { 'a', 'b', 'c' };
        List < char > listChar= chs.ToList();

        for (int i = 0; i < list.Count; i++)
        {
            Console.WriteLine(list[i]);
        }
        Console.ReadKey();
    }

裝箱、拆箱
裝箱：就是將值類型轉換爲引用類型
拆箱：將引用類型轉換爲值類型
看兩種類型是否發生了裝箱或拆箱，要看，這兩種類型是否存在繼承關係

static void Main(string[] args)
    {
        int n = 10;
        object o = n;//裝箱
        int nn = (int)o;//拆箱

        //下面的代碼並無發生裝箱或者拆箱
        //看兩種類型是否發生了裝箱或拆箱，要看，這兩種類型是否存在繼承關係,有繼承關係則偶可能發生裝箱拆箱，沒有繼承則不發生，如下代碼則不會發生
        string str = "123";
        int n1 = Convert.ToInt32(str);
    }

3、Dictionary鍵值對集合（字典集合）
語法及方法

static void Main(string[] args)
    {
        //建立Dictionary
        Dictionary<int, string> dic = new Dictionary<int, string>();
        dic.Add(1, "張三");
        dic.Add(2, "李四");
        dic.Add(3, "王五");
        dic[1] = "新來的";
        //foreach (var item in dic.Keys)
        //{
        //    Console.WriteLine("{0}--------{1}", item, dic[item]);
        //}

        //一對數據一對數據的遍歷  儘可能多使用這種遍歷
        foreach (KeyValuePair<int,string> kv in dic)
        {
            Console.WriteLine("{0}--------{1}", kv.Key, kv.Value);
        }
        Console.ReadKey();
    }

集合的三個練習

static void Main(string[] args)
    {
        ////將一個數組中的奇數放到一個集合中，偶數放到另外一個集合中
        ////最終將兩個集合合併爲一個集合，奇數在左邊，偶數在右邊
        //int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        //List<int> qi = new List<int>();
        //List<int> ou = new List<int>();
        //for (int i = 0; i < nums.Length; i++)
        //{
        //    if (nums[i] % 2 == 0)
        //    {
        //        ou.Add(nums[i]);
        //    }
        //    else
        //    {
        //        qi.Add(nums[i]);
        //    }
        //}
        ////List<int> zheng = new List<int>();
        ////zheng.AddRange(qi);
        ////zheng.AddRange(ou);
        //qi.AddRange(ou);
        //foreach (int item in qi)
        //{
        //    Console.Write(item+" ");
        //}
        //Console.ReadKey();

        ////提示用戶輸入一個字符串，經過foreach循環將用戶輸入的字符串賦值給一個字符數組。
        //Console.WriteLine("請輸入一段字符串");
        //string strs = Console.ReadLine();
        //char[] chs = new char[strs.Length];
        //int i = 0;
        //foreach (var item in strs)
        //{
        //    chs[i] = item;
        //    i++;
        //}
        //foreach (var item in chs)
        //{
        //    Console.WriteLine(item);
        //}
        //Console.ReadKey();

        //統計Welcome to china 中每一個字符出現的次數，不考慮大小寫
        string str = "Welcome to china";
        Dictionary<char, int> dic = new Dictionary<char, int>();
        for (int i = 0; i < str.Length; i++)
        {
            if (str[i] == ' ')
            {
                continue;
            }
            //若是dic已經包含了當前循環到的這個鍵
            if (dic.ContainsKey(str[i]))
            {
                //值再次加1
                dic[str[i]]++;
            }
            //字符在集合中第一次出現
            else
            {
                dic[str[i]] = 1;
            }
        }
        foreach (KeyValuePair<char,int> kv in dic)
        {
            Console.WriteLine("字母{0}出現了{1}次", kv.Key, kv.Value);
        }
        Console.ReadKey();
    }

4、FileStream方法（對文件操做）
FileStream(一點一點讀取，對內存壓力小) 操做字節
StreamReader和StreamWriter 操做字符

將建立文件流對象的過程寫在using當中，會自動幫助咱們釋放流所佔用的資源

static void Main(string[] args)
    {
        ////使用FileStream來讀取數據
        ////1.建立一個FileStream類   所需三個參數：路徑、針對這個文件作什麼操做、針對這個文件裏面的數據作什麼操做
        //FileStream fs = new FileStream(@"C:\Users\Administrator\Desktop\1.txt",FileMode.OpenOrCreate,FileAccess.Read);
        //byte[] buffer = new byte[1024 * 1024 * 5];
        ////返回本次實際讀取到的有效字節數
        //int r = fs.Read(buffer,0,buffer.Length);
        ////將字節數組中每個元素按照指定的編碼格式解碼成字符串，從0開始到r結束
        //string s = Encoding.Default.GetString(buffer,0,r);
        ////關閉流
        //fs.Close();
        ////釋放流所佔用的資源
        //fs.Dispose();
        //Console.WriteLine(s);
        //Console.ReadKey();

        //使用FileStream寫入數據
        using (FileStream fsWrite = new FileStream(@"C:\Users\Administrator\Desktop\1.txt",FileMode.OpenOrCreate,FileAccess.Write))
        {
            string str = "看我何平何胖子把你覆蓋";
            byte[] buffer = Encoding.Default.GetBytes(str);
            fsWrite.Write(buffer,0,buffer.Length);
        }
        Console.WriteLine("寫入OK");
        Console.ReadKey();
    }

FileStream實現多媒體文件的複製

static void Main(string[] args)
    {
        //思路：先將要複製的多媒體文件讀取出來，而後寫入到指定的位置
        string source = @"D:\BaiduNetdiskDownload\（第十二天）\video\一、複習.avi";
        string target = @"C:\Users\Administrator\Desktop\new.avi";
        CopyFile(source, target);
        Console.WriteLine("複製成功");
        Console.ReadKey();
    }

    public static void CopyFile(string source, string target)
    {
        //1.建立一個負責讀取的流
        using (FileStream fsRead = new FileStream(source, FileMode.Open, FileAccess.Read)) 
        {
            //2.建立一個負責寫入的流
            using (FileStream fsWrite = new FileStream(target, FileMode.OpenOrCreate, FileAccess.Write)) 
            {
                byte[] buffer = new byte[1024 * 1024 * 5];
                //4.由於文件可能會比較大，因此在讀取的時候，應該經過循環去讀取
                while (true)
                {
                    //3.返回本次讀取實際讀取到的數據字節數
                    int r = fsRead.Read(buffer, 0, buffer.Length);
                    //5.若是返回一個0，也就意味着什麼都讀取不到，讀取完了
                    if (r == 0)
                    {
                        break;
                    }
                    fsWrite.Write(buffer, 0, r);
                }
            }
        }
    }

5、StreamReader和StreamWrite
語法及用法：

static void Main(string[] args)
    {
        ////使用StreamReader來讀取一個文本文件
        //using (StreamReader sr = new StreamReader(@"C:\Users\Administrator\Desktop\1.txt"))
        //{
        //    while (!sr.EndOfStream)
        //    {
        //        Console.WriteLine(sr.ReadLine());
        //    }
        //}

        ////使用StreamWrite來寫入一個文本文件
        //using (StreamWriter sw = new StreamWriter(@"C:\Users\Administrator\Desktop\1.txt"))
        //{
        //    sw.Write("今每天氣不錯，挺風和日麗的"); //寫入後覆蓋掉原內容
        //}
        //Console.WriteLine("寫入成功");

        //使用StreamWrite來寫入一個文本文件，不覆蓋
        using (StreamWriter sw = new StreamWriter(@"C:\Users\Administrator\Desktop\1.txt",true))
        {
            sw.Write("今每天氣不錯，挺風和日麗的"); //寫入後覆蓋掉原內容
        }
        Console.WriteLine("寫入成功");
        Console.ReadKey();
    }

6、多態
概念：讓一個對象可以表現出多種狀態(類型)
實現多態的三種方法：1.虛方法 2.抽象類 3.接口
一、虛方法 （減小代碼量而且增長了程序的可擴展性）
步驟
1.將父類的方法標記爲虛方法，使用關鍵字virtual,這個函數能夠被子類從新寫一遍
2.在子類方法前標記，使用關鍵字override

語法及做用示範

namespace _06多態
{
class Program
{
    static void Main(string[] args)
    {
        //概念：讓一個對象可以表現出多種的狀態（類型）
        //

        Chinese cn1 = new Chinese("韓梅梅");
        Chinese cn2 = new Chinese("李雷");
        Japanese j1 = new Japanese("不穿褲子");
        Japanese j2 = new Japanese("沒穿內衣");
        Korea k1 = new Korea("金吃屎");
        Korea k2 = new Korea("宋吃翔");
        America a1 = new America("蝙蝠俠");
        America a2 = new America("蜘蛛俠");
        Person[] pers = { cn1, cn2, j1, j2, k1, k2, a1, a2 };
        for (int i = 0; i < pers.Length; i++)
        {
            ////這一坨代碼，就是幹一件事，分別打招呼，若是最後那一行能實現這一坨代碼，減小N多代碼量
            ////而且在加入新類時候，只須要寫類，不須要在來這裏判斷
            //if (pers[i] is Chinese)
            //{
            //    ((Chinese)pers[i]).SayHello();
            //}
            //else if (pers[i] is Japanese)
            //{
            //    ((Japanese)pers[i]).SayHello();
            //}
            //else if (pers[i] is Korea)
            //{
            //    ((Korea)pers[i]).SayHello();
            //}
            //else
            //{
            //    ((America)pers[i]).SayHello();
            //}
            pers[i].SayHello();//這樣一行代碼就搞定，而且加入新類也能使用
        }
        Console.ReadKey();
    }
}

public class Person
{
    private string _name;
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }

    public Person(string name)
    {
        this.Name = name;
    }
    public virtual void SayHello()
    {
        Console.WriteLine("我是人類");
    }
}

public class Chinese : Person
{
    public Chinese(string name) : base(name)
    { }
    public override void SayHello()
    {
        Console.WriteLine("我是中國人，我叫{0}", this.Name);
    }
}

public class Japanese : Person
{
    public Japanese(string name) : base(name)
    { }
    public override void SayHello()
    {
        Console.WriteLine("我是日本人，我叫{0}", this.Name);
    }
}

public class Korea : Person
{
    public Korea(string name) : base(name)
    { }
    public override void SayHello()
    {
        Console.WriteLine("我是棒子國人，我叫{0}", this.Name);
    }
}

public class America : Person
{
    public America(string name) : base(name)
    { }
    public override void SayHello()
    {
        Console.WriteLine("我是漂亮國人，我叫{0}", this.Name);
    }
}

}

虛方法的練習

namespace _07虛方法的練習
{
class Program
{
    static void Main(string[] args)
    {
        //真的鴨子嘎嘎叫 木頭鴨子吱吱叫 橡皮鴨子唧唧叫
        Duck rd = new Duck();
        MuDuck md = new MuDuck();
        XPDuck xd = new XPDuck();
        Duck[] ducks = { rd, md, xd };
        for (int i = 0; i < ducks.Length; i++)
        {
            ducks[i].back();
        }
        Console.ReadKey();
    }
}

public class Duck
{
    public virtual void back()
    {
        Console.WriteLine("真的鴨子嘎嘎叫");
    }
}

public class MuDuck : Duck
{
    public override void back()
    {
        Console.WriteLine("木頭鴨子吱吱叫");
    }
}

public class XPDuck : Duck
{
    public override void back()
    {
        Console.WriteLine("橡皮鴨子唧唧叫");
    }
}
  }

虛方法的練習二

namespace _07虛方法的練習
{
class Program
{
    static void Main(string[] args)
    {
        //經理十一點打卡，員工九點打卡，程序員不打卡
        Employee emp = new Employee();
        Manager mg = new Manager();
        Programmer pm = new Programmer();
        Employee[] emps = { emp, mg, pm };
        for (int i = 0; i < emps.Length; i++)
        {
            emps[i].Daka();
        }
        Console.ReadKey();
    }
}
public class Employee
{
    public virtual void Daka()
    {
        Console.WriteLine("員工九點打卡");
    }
}

public class Manager : Employee
{
    public override void Daka()
    {
        Console.WriteLine("經理十一點打卡");
    }
}

public class Programmer : Employee
{
    public override void Daka()
    {
        Console.WriteLine("程序員不打卡");
    }
}
}

7、抽象類
1.當父類中的方法不知道如何實現的時候，能夠考慮將父類寫成抽象類，將方法寫成抽象方法
2.抽象類使用關鍵字：abstract 加到抽象類和抽象方法上。抽象方法是沒有方法體的。
3.抽象成員必須在抽象類中
4.抽象類不能被實例化
5.子類繼承抽象類後，必須把父類中的全部抽象成員都重寫
（除非子類也是一個抽象類，則能夠不重寫）
6.在抽象類中能夠包含實例成員，而且抽象類的實例成員能夠不被子類實現
7.抽象類是有構造函數的，雖然不能被實例化
8.若是父類的抽象方法中有參數，繼承這個抽象父類的子類在重寫父類的方法的時候必須傳入對應的參數。若是抽象父類的抽象方法中有返回值，子類在重寫這個抽象方法的時候，也必需要傳入返回值
若是父類中的方法有默認的實現，而且父類須要被實例化，這時能夠考慮將父類定義成一個普通類，用虛方法來實現
若是父類中的方法沒有默認實現，父類也不須要被實例化，則能夠將該類定義爲抽象類。

語法及用途：

namespace _08抽象類
{
class Program
{
    static void Main(string[] args)
    {
        //狗會叫 貓也會叫
        Animal a = new Dog();
        a.Brak();
        Animal b = new Cat();
        b.Brak();
        Console.ReadKey();
    }
}

public abstract class Animal
{
    public abstract void Brak();
}

public class Dog : Animal
{
    public override void Brak()
    {
        //throw new NotImplementedException();
        Console.WriteLine("狗旺旺旺的叫");
    }
}

public class Cat : Animal
{
    public override void Brak()
    {
        //throw new NotImplementedException();
        Console.WriteLine("貓喵瞄喵的叫");
    }
}
}

抽象類的練習（求圓和矩形的面積及周長）

namespace _09抽象類的練習
{
class Program
{
    static void Main(string[] args)
    {
        //使用多臺求矩形的面積和周長以及圓形的面積和周長
        Shape shape = new Square(5, 6); //new Circle(5);
        double area = shape.GetArea();
        double perimeter = shape.GetPerimeter();
        Console.WriteLine("這個形狀的面積是{0},周長是{1}", area, perimeter);
        Console.ReadKey();
    }
}
/// <summary>
/// 抽象出一個類來做爲父類
/// </summary>
public abstract class Shape
{
    public abstract double GetArea();
    public abstract double GetPerimeter();
}
/// <summary>
/// 求圓的面積和周長
/// </summary>
public class Circle : Shape
{
    private double _r;
    public double R
    {
        get { return _r; }
        set { _r = value; }
    }

    public Circle(double r)
    {
        this.R = r;
    }

    public override double GetArea()
    {
        return Math.PI * this.R * this.R;
    }

    public override double GetPerimeter()
    {
        return 2 * Math.PI * this.R;
    }
}

/// <summary>
/// 求矩形的面積和周長
/// </summary>
public class Square : Shape
{
    private double _height;
    public double Height
    {
        get { return _height; }
        set { _height = value; }
    }
    private double _width;
    public double Width
    {
        get { return _width; }
        set { _width = value; }
    }
    public Square(double height, double width)
    {
        this.Height = height;
        this.Width = width;
    }
    public override double GetArea()
    {
        return this.Height * this.Width;
    }

    public override double GetPerimeter()
    {
        return (this.Height + this.Width) * 2;
    }
}
}

9、模擬移動硬盤，U盤，MP3插入電腦進行讀取操做的練習

namespace _10使用多態模擬U盤_移動硬盤_MP3插入電腦讀寫數據
{
class Program
{
    static void Main(string[] args)
    {
        //MobileDisk md = new MobileDisk();
        //UDisk ud = new UDisk();
        //MP3 mp3 = new MP3();
        //Computer cpu = new Computer();
        //cpu.CpuRead(ud);
        //cpu.CpuWrite(ud);

        //MobileStorage ms = new UDisk();
        //Computer cpu = new Computer();
        //cpu.CpuRead(ms);
        //cpu.CpuWrite(ms);

        MobileStorage ms = new UDisk();
        Computer cpu = new Computer();
        cpu.Ms = ms;
        cpu.CpuRead();
        cpu.CpuWrite();
        Console.ReadKey();

    }
}

/// <summary>
/// 新建一個父類來存儲子類的公有方法讀和寫
/// </summary>
public abstract class MobileStorage
{
    public abstract void Read();
    public abstract void Write();
}

/// <summary>
/// 建立移動硬盤類，來模擬移動硬盤的操做
/// </summary>
public class MobileDisk : MobileStorage
{
    public override void Read()
    {
        Console.WriteLine("移動硬盤在讀取數據");
    }

    public override void Write()
    {
        Console.WriteLine("移動硬盤在寫入數據");
    }
}

/// <summary>
/// 建立U盤類，模擬U盤的操做
/// </summary>
public class UDisk : MobileStorage
{
    public override void Read()
    {
        Console.WriteLine("U盤在讀取數據");
    }

    public override void Write()
    {
        Console.WriteLine("U盤在寫入數據");
    }
}

/// <summary>
/// 建立MP3類，模擬MP3的操做
/// </summary>
public class MP3 : MobileStorage
{
    public override void Read()
    {
        Console.WriteLine("MP3在讀取數據");
    }

    public override void Write()
    {
        Console.WriteLine("MP3在寫入數據");
    }

    public void PlayMusic()
    {
        Console.WriteLine("MP3本身能夠播放音樂");
    }
}

/// <summary>
/// 建立電腦類，調用移動存儲類的讀寫兩個方法，傳入參數實際是被子類重新賦值後的
/// </summary>
public class Computer
{
    private MobileStorage _ms;
    public MobileStorage Ms
    {
        get { return _ms; }
        set { _ms = value; }
    }
    // public void CpuRead(MobileStorage ms)
    public void CpuRead()//直接使用字段賦值
    {
        Ms.Read();
    }
    // public void CpuWrite(MobileStorage ms)
    public void CpuWrite()//直接使用字段賦值
    {
        Ms.Write();
    }
}
}