C#之小练⑨（Directory保存歌曲名字、多态练习、抽象方法、接口）

①、将文件夹中的音乐名称复制到一个文本文档中

 static void Main(string[] args)
        {
            string path = @"C:\Users\Smile\Desktop\MUSIC";      //创建一个文件夹路径
            string pathtext = @"C:\Users\Smile\Desktop\1.txt";  //创建一个文本文档路径
            string[] str=Directory.GetFiles(path);              //获取文件夹路径下面的除文件夹之外的所有文档
            List<string> musics = new List<string>();           //创建歌曲名称的存放泛集合
            for (int i = 0; i < str.Length ; i++)               //遍历文件夹下获取的所有文件名称路径
            {
                                                                //方法一：将文件名路径进行切割
                string[] splitstr=str[i].Split(new char[] { '\\' }, StringSplitOptions.RemoveEmptyEntries);
                musics.Add(splitstr[splitstr.Length - 1]);      //将切割出来的最后的一个内容添加到泛集合musics变量中
                                                                //方法二：获取最后\的索引值，然后读取\后面的内容
                int index=str[i].LastIndexOf("\\");
                musics.Add(str[i].Substring(index + 1));
            }
            File.WriteAllLines(pathtext, musics);               //调用File按行写入的方法，将内容写入控制台
        }

②、多态代码

 //当子类方法与父类方法具有相同方法名称时，运行没有问题，但子类的方法名会报绿线，那如何解决这个绿线？
 //方法一：(不推荐使用)在子类方法中添加new 关键字，无论是否加new都不影响使用.new隐藏基类当中的方法
 //方法二：（推荐使用）在子类方法中添加override 重写父类方法,父类方法修饰符后面需加virtual关键字，方法不能用Static修饰，不能用private,原因：为了让子类访问，不能为私有
 //为什么不能使用static，因为用了static只能用类来调取方法,即类.方法名，这样子类就无法调取父类的方法
 //方法二是把父类的方法进行了重写，创新，已经是子方法特有的方法了。父类方法依然存在，可以调取
 //为什么直接把子类中的方法名称改掉而要重写呢？为了调取时方便，只调取一个方法名。
 //多态就是对象可以表现多个类型的能力
     class Program
    {
        static void Main(string[] args)
        {
                                                                //随机产生10个类的对象
            Animal[] animals = new Animal[10];                  //实例化是一个类数组，即建立一个类数组
            Random rnd = new Random();                          //实例化一个随机数
          
            for (int i = 0; i < animals.Length; i++)            //遍历类数组
            {
                int num = rnd.Next(1, 5);                       //创建一个1-4的随机数
                switch(num)                                     //将num转换到以下不同的case中
                {
                    case 1:animals[i] = new Pig("赵");break;     //如果num=1,实例化类组合中的类
                    case 2:animals[i] = new Dog("钱");break;     //如果num=2,实例化类组合中的类
                    case 3:animals[i] = new Cat("孙");break;     //如果num=3,实例化类组合中的类
                    case 4:animals[i] = new Cow("李");break;     //如果num=4,实例化类组合中的类
                }
            }
            for (int i = 0; i < animals .Length ; i++)          //遍历已经实例化完的类数组
            {
                animals[i].Shout();                             //调取每个数组中实例化类，即对象的方法
            }
            Console.ReadKey();
        }

    }
    public abstract  class Animal                               //创建一个抽象类Animal
    {
        public Animal(string name)                              //创建抽象类Animal的构造函数
        {
            this._name = name;
        }
        string _name;                    
        public string Name                                                             
        {
            get { return _name; }
            set { _name = value; }
        }


        public abstract void Shout();                           //创建抽象方法，动物叫，叫是一个动作，因每个动物叫的声音不一样，所以这里定义为抽象方法，具体的声音让子类实现

    }
    public class Pig:Animal                                     //创建一个Pig类继承抽象类Animal
    {   public Pig(string name):base(name)                      //创建一个Pig的构造函数，name的参数从基类中获得
        {

        }
        public override void Shout()                            //子类通过override 关键字来重写父类中的抽象方法
        {
            Console.WriteLine("{0},哼哼",this.Name);
        }
    }

③、抽象代码

//抽象方法用abstract修饰
 //抽象方法里面没有方法体
 //抽象方法，抽象成员必须在抽象类中
 //抽象类有非抽象成员，非抽象方法
 //抽象类无法实例化，抽象方法无法调取
 //父类是抽象类，子类继承了这个类，必须把抽象类中的方法进行重写，否则会报错，必须要override，抽象类的派生类（子类）必须实现抽象方法体
 //抽象类只能用于基类，无法实例化
 //抽象方法只有子类可以重写，所以子类中一般不写抽象类

    class Program
    {
        static void Main(string[] args)
        {
            Pig pig = new Pig();     //实例化一个Pig类
            pig.Shout();             //调取对象pig的Shout方法
            Console.ReadKey();
        }
    }
    public abstract class Animal
    {
        public Animal(string name)
        {
            this._name = name;
        }
        public Animal()
        {
        }
        string _name;                                         
        public string Name                                     
        {
            get { return _name; }
            set { _name = value; }
        }

        public abstract void Shout();   //抽象方法没有方法体
    }

    public class Pig:Animal            //子类Pig继承父类Animal
    {
        public override void Shout()   //子类用override关键字重写了父类Shout方法
        {
            Console.WriteLine("哼哼叫");
        }
    }

④、接口代码

 interface IFly  
    {
        void IFly();
    }

    class Program
    {
        static void Main(string[] args)
        {
            Animal animal = new Animal("乔巴");                  //实例化一个Animal类,即创建一个animal对象
            animal.IFly();                                      //调用对象animal的IFly()方法
            Console.ReadKey();
        }
    }
    public  class Animal:IFly                                   //创建一个Animal类实现IFly接口
    {
        public void IFly()                                      //子类要实现方法就要有具体的方法体
        {
            Console.WriteLine("我会飞");
        }
        public Animal(string name)                              //创建抽象类Animal的构造函数
        {
            this._name = name;
        }
        string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
    }

  终于完成核心代码的练习，下一站走起^_^