30天C#基础巩固------面向鸭子编程，关于string和File的练习

面向对象编程就是面向抽象的父类进行编程，具体的实现不用考虑，由子类决定。<经典的说法--面向鸭子编程>

eg:鸭子的编程，<对于多态的理解>

我们都习惯把使用两条腿两边走的动物，形象的叫做鸭子。这里我们的本来的鸭子就是父类(抽象类)，继承且实现方法的叫做子类，就是我们把走路和鸭子一样的都叫做鸭子一样。(木头鸭子，橡皮鸭子，真实的鸭子)。

接口：鸭子叫，鸭子游泳。

    //鸭子大叫
    public interface IBark
    {
        void Bark();
    }

    //鸭子游泳接口
    public interface ISwitch
    {
        void Switch();//接口只管定义方法，不用管实现。
    }

真实鸭子，木头鸭子，橡皮鸭子

    //真鸭子，即会游泳又回叫
    public class RealDuck:Duck,IBark
    {
        public void Bark()
        {
            Console.WriteLine("嘎嘎嘎嘎嘎嘎嘎------");
        }

        public override void Switch()
        {
            Console.WriteLine("真实的鸭子----自由自在的游泳.....");
        }
    }

    //橡皮鸭子，继承鸭子，只会叫。
    public class RubbleDuck:Duck,IBark
    {
        public void Bark()
        {
            Console.WriteLine("叽叽叽叽....");
        }

        public override void Switch()
        {
            Console.WriteLine("橡皮鸭子--，漂浮在水上。");
        }
    }

    //木头鸭子
    public class WoodDuck:Duck
    {
        public override void Switch()
        {
            Console.WriteLine("木头鸭子，漂浮在水上。");
        }
    }

main（）方法中的。

        /// <summary>
        /// 面向鸭子编程----->理解多态
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            //父类定义方法，子类具体实现(每个鸭子游泳是不一样的。)
            Duck d1=new RealDuck();
            Duck d2=new RubbleDuck();
            Duck d3=new WoodDuck();
            Console.WriteLine("……………01.鸭子游泳………...…");
            //三个鸭子的游泳都不一样
            d1.Switch();
            d2.Switch();
            d3.Switch();
            Console.WriteLine("……………02.鸭子的叫声……………");
            //把抽象类给了接口IBark，(利用了里氏转换原则)
            IBark i1 = d1 as IBark;
            if (i1!=null) i1.Bark();          //会叫，嘎嘎嘎嘎
            IBark i2 = d2 as IBark;
            if (i2!=null)
            {
                i2.Bark();                      //会叫，叽叽
            }
            IBark i3 = d3 as IBark;
            if (i3!=null)
            {
                i3.Bark();                 //不会叫,没有实现ibark接口，而且木头鸭子本身就不会叫。
            }
            Console.ReadKey();
        }
    }

上面我们把鸭子Duck定义为抽象的类，里面我们只是定义了方法，具体的实现在子类中。就是我们前面说的那样，父类定义方法，子类继承实现，这就是具体的实现在子类，每个都是不一样的。

下面的那个利用里氏转换原理，把父类Duck转换为接口IBark，只要实现了接口，他就会拥有里面叫的方法。

反转字符串

            //将字符串反转。
            Console.WriteLine("请输入一个字符串?");
            string input = Console.ReadLine();
            char[] chs= input.ToCharArray();        //将string类型转换为数组
            for (int i = 0; i <chs.Length/2; i++)     //反转只需要执行1/2次数就可以。
            {
                char cTemp = chs[i];
                chs[i] = chs[chs.Length-1-i];        //第一个和最后一个转换
                chs[chs.Length - 1 - i] = cTemp;
            }
            Console.WriteLine(new string(chs));          //把char数组又转换为string类型。
            Console.ReadKey();

读取phone.csv文件并且输出来。

            string[] lines = File.ReadAllLines("phone.csv", Encoding.Default);       //按行读取Debug文件下面
            //的csv文件，放到数组里面。
            for (int i = 0; i < lines.Length; i++)
            {
                string[ ] ts = lines[i].Split(',');
                Console.WriteLine("姓名:{0}",ts);
            }
     Console.ReadKey();

读取文件利用File.ReadAllLines(“文件名”,Encoding.Default);，这个是读取项目文件中Debug目录下的文件，按行读取值，放到string[]数组中.

利用键值对来保存我们读取到字符串中的年月日下标。

            string src = "1993年10月08日";
            Dictionary<char,int>  dic=new Dictionary<char, int>();              //声明一个键值对。
            int index = -1;
            do
            {
                //显示这3个字符的位置下标。
                index = src.IndexOfAny("年月日".ToCharArray(), index + 1);  //将字符串"年月日"转换为char数组，循环的输出每个下标。
                if (index!=-1)
                {
                    //Console.WriteLine(index);
                    dic.Add(src[index],index);
                }
            } while (index!=-1);
            //循环输出键值对中的值，注意这里的KeyValuePair<char, int>类型，不是我们以前的var。
            foreach (KeyValuePair<char, int> item in dic)
            {
                Console.WriteLine(item.Key+"  "+item.Value);
            }
            Console.ReadKey();