第12天笔记

        
===================================================        
             //创建泛型集合对象
===================================================
    List泛型集合：数组一旦声明了泛型数据类型就确定了里面每一个的元素就确定了
      //List泛型集合可以转换为数组
       int [] nums=list .ToArray();ToArray转成数组
            //List<int> list = new List<int>();
            //list.Add(1);
            //list.Add(2);
            //list.Add(3);
            //list.AddRange(new int[] { 1, 2, 3, 4, 5, 6 });
            //list.AddRange(list);        
            //int[] nums = list.ToArray();
            //List<string> listStr = new List<string>();
            //string[] str = listStr.ToArray();
            //char[] chs = new char[] { 'c', 'b', 'a' };
            //List<char> listChar = chs.ToList();
            //for (int i = 0; i < listChar.Count; i++)
            //{
            //    Console.WriteLine(listChar[i]);
            //}

               List<int> listTwo = nums.ToList();


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

1、复习：
      里氏转换：子类可以赋值给父类 （如果有一个方法需要一个父类作为参数，我们可以    传一个 子类对象）
             如果父类中装的是子类可以强转为子类对象
           Person p=new Student();
          如果说子类可以赋值给父类 那我们应该声明一个父类类型去指向子类对象
          如果说父类中装的是子类对象 可以考虑将父类强转为子类对象用
          is  转换成功返回 true
          as  转换成功返回对应的对象 来接收ss
      students ss =p as students;声明一个students类型的对象
    is的用法：
          if(p is students)
          {
            ((students)p).studentsSayHello();
          }
          else
          {
            cw("失败");
          }
 
      ArraList list=new ArraList();
      list.Add()//可以传任意值类型
      Remove 移除(你往里面传谁把谁删掉了)  RemoveAt（根据索引去删）  
    RemoveRange(删除一定范围的元素)  
    Clear（清空）   
    Insert（插入）
    InsertRange（插入一个集合）
    Reverse（反转）
    sort（升序排列）
    
     Hashtable  键值对集合 一个键对应一个值
     Hashtable ht=new Hashtable();
     ht.Add(1,"张三");
     ht.Add(2,'男');
     //在键值对集合中键必须是唯一的
     ht[1]="李四"
     ht.ContainsKey（键值集合中是否包含某一个键）
     foreach(var item in ht.Keys)item就是每一个键值对的值
     {
       cw("{0}",item,ht[item]);//ht[item]表示值
     }
    
     Path 类 文件路径
     File 类 静态类（不能创建静态类的对象 静态类当中所有的成员都是静态成员 调用    时 类名.静态成员 ）
     File.ReadAllBytes() 读数据 以字节 用于媒体
     ReadAllLine:每行数据进行操作时
     ReadAllText:整个的读取
     Creat  Delete Copy Move   文本文件
     你把一个数组对象直接tostrign 那么你拿到的是这个数组所在的命名空间
      byte [] buffer=File.ReadAllBytes();
     将字节数组中的每一个元素都要按照我们指定的编码格式解码城字符串
     编码：UTF 8 UTf32
     string s=Encoding .GetEncoding("G").getstring(buffer);
    
     string str="今天天气好晴朗 ，处处好风光"
     //需要将字符串转换成字节数组
      
      byte []=Encoding.Default.GetBytes(str);
      File.WriteAllBytes(@"",buffer);
     File.WriteAllBytes()写数据
    
 File类
      string [] contents=File.ReadAllLines(@)
      foreach(string item in contents)
      {
         cw    (item);
      }
    
   string str =File.ReadAllText(@"C:\Users\wbrm\Desktop.txt",Encoding.Default);    
       绝对路径和相对路径
     绝对路径：通过给定的这个路径直接能在我的电脑中打开的
     相对路径：把要读取的文件放在同一个程序下
     我们在开发中应该尽量的使用相对路径
  写数据：
  File.WriteLine(@"",new string [] {"aaa" ,"eee"});
   Console.WriteLine("Ok");
   Console.ReadKey();

  File.WriteAllText(@"","张三李四王五赵六");
    Console.WriteLine("Ok");
   Console.ReadKey();

     File .AppendAllText(@"","不覆盖的添加")
    Console.WriteLine("Ok");
   Console.ReadKey();
   AppendAllText：不覆盖的添加
    File 的缺点：只能用来读小文件 （它是一下子全都读进去）
    ReadAllBytes:以字节形式读取
    WriteAllBytes:以字节写入
    

 //将数组转换城集合
 char[] chs =new []{'c','b','a'};
 list <char> listchar=chs .Tolist();
 for(int i;i<listchar.Count)
 {
   cw(listchar[i]);
 }
      ArraList和Hastable 和少用了
    装箱和拆箱:先提条件看这两种类型是否存在继承关系才有可能发生拆箱和装箱
    装箱：就是将值类型转换成引用类型 会影响程序的性能 避免装拆箱
    拆箱：就是将应用类型转换成值类型    
    //int  n=10;
    //object =n;//装箱
    int nn=(int)0;//拆箱
    ArraList list=new ArraList ();
    stopwatch   nw=new stopwatch();
    nw.Start();
    for(int i=0;i<1000000;i++)
    {
       list.Add(i);
    }
    nw.Stop();
    console.WriteLine(nw.ElaPsed);
    Console.ReadK();

    string str="123"//这个地方没有发生装箱和拆箱
    int n=Convert.Toint32(str);
int n=10;
IcomParable i;//接口

字典
    Dictionary<int,string> dic =new Dictionary<int,string> ();键是int 值是string
    dic.Add(1,"张三");
    dic.Add(1,"张三");
    dic.Add(1,"张三");
    dic[1](1,"新来的");
    foreach(var item dic.keys)
    {
      cw("{0}{1}",item,dic[item]);
    }
    kv及代表键又代表值
    foreach(KeyValuePai<int,string> kv in dic)//一对一对数据的遍历
    {
      cw("{0}{1}",kv,key.Vlue);
    }

//将一个数组中的奇数放到一个集合中 ，偶数放一个集合 最终放一个集合
 int[] nums={1,2,3,4,5,6,7,8,9};
 list<int>lisou=new list<int>()；
 list<int>lisji=new list<int>()；
 for(int i=0; i<nums.Length;i++)
 {
   if(nums[i]%2==0)
   {
     Listou.add(nums[i]);
   }
   else
   {
      Listji.add(nums[i]);
   }
 }
 listou.AddRange(listji);
 foreach(int item in lisou)
 {
   conson.write(item)
 }
 
 
//提示用户输入一个字符串 ，通过foreach循环将用户输入的字符串赋值给一个字符
consol.WriteLine();
string input =console.ReadLine();
Char[]chs=new cha [input .Length]
foreach(var item in input)
{
  chs[i]=item;
  i++;
}
foreach(var item in input)
{
     cw(item);
}


//统计welcome to chai 中每个字符出现的次数，不考虑大小写
string str="Welcom to cbina";
//字符-----》出现的次数
//键-------》值
Dictionary<char,int> dic =new Dictionary<char,int>();
//
for(int i=0;i<str.Length;i++)
{
    if (str[i]=='')
    {
    continue;
    }
  //如果dic已经包含了当前循环的这个键
  //如果这个集合中这个键已经出现过了就意味着它的键再次加1
  if(dic.ContainsKey(str[i]))
  {
   dic[str[i]]++;
  }
  else
  {
    dic[str[i]]=1;
  }
}
foreach(KeyValuePai<char,int>kv,in dic)
{  
   "字母{0}出现了{1}次",kv.Key,kv.value
}

文件流
FileStream//(操作字节的)水一勺一勺的
FilesReader操作字节的 可以操作任何文件
SteaWriter操作字符的 只能文本文件
file  //区别 直接抬起来把水倒水缸
三个参数：文件的路径  OpenOrcreat:打开有我就打开没有也不报错   读取


//1.创建FileStream对象
//使用FileStream来读取数据
FileStream fsRead=new FileStream(@"C:\Users\wbrm\Desktop",FileMode.OpenOrcreat,fileAccess.Read);
byte [] buffer=new =byte[1024*1024*5]5M
//数据只用3.8兆每次读5兆 返回本次实际读取到的有效字节数
int r=fsRead.Read(buffer,0,buffer.Length);
//将字节数组中的每一个元素都要按照我们指定的编码格式解码城字符串
string s=Encoding.Default.Getstring(buffer,0,r);
//关闭流
fsRead.Close();
fsRead.Dispose();//释放所占用的资源
console.WriteLine(s);
//使用FileStream来写入数据
//将创建文件流对象的过程写在using 当中会自动地帮助我们释放资源

using (FileStream fsWrite=new FileStream(@""),FileMode.OpenOrcreat,FileAccess.Write)
{
  string str="看我有没有把你覆盖掉"
  byet[]buffer=Encoding.Default.GetBytes(str);
  fsWrite.write(buffer,0,buffer,Length);
}
console.Writeline("写入OK");
console.readkey();
使用文件流实现媒体文件的复制
思路：先将要复制的多媒体文件读取出来

//思路：就是先将要复制的多媒体文件读取出来，然后再写入到你指定的位置
            string source = @"C:\Users\SpringRain\Desktop\1、复习.wmv";
            string target = @"C:\Users\SpringRain\Desktop\new.wmv";
            CopyFile(source, target);
            Console.WriteLine("复制成功");
            Console.ReadKey();
        }

        public static void CopyFile(string soucre, string target)
        {
            //1、我们创建一个负责读取的流
            using (FileStream fsRead = new FileStream(soucre, FileMode.Open, FileAccess.Read))
            {
                //2、创建一个负责写入的流
                using (FileStream fsWrite = new FileStream(target, FileMode.OpenOrCreate, FileAccess.Write))
                {
                    byte[] buffer = new byte[1024 * 1024 * 5];
                    //因为文件可能会比较大，所以我们在读取的时候 应该通过一个循环去读取
                    while (true)
                    {
                        //返回本次读取实际读取到的字节数
                        int r = fsRead.Read(buffer, 0, buffer.Length);
                        //如果返回一个0，也就意味什么都没有读取到，读取完了
                        if (r == 0)
                        {
                            break;
                        }
                        fsWrite.Write(buffer, 0, r);
                    }

                 
                }
            }
        }



     StreamRead和StreaWriter如何用
     //使用StreamReader来读取一个文本文件
            //using (StreamReader sr = new StreamReader(@"C:\Users\SpringRain\Desktop\抽象类特点.txt",Encoding.Default))
            //{
            //    while (!sr.EndOfStream)  //判断有没有读到最后一个字节
            //    {
            //        Console.WriteLine(sr.ReadLine());
            //    }
            //}


            //使用StreamWriter来写入一个文本文件
            using (StreamWriter sw = new StreamWriter(@"C:\Users\SpringRain\Desktop\newnew.txt",true))//true追加的意思
            {
                sw.Write("看我有木有把你覆盖掉");
            }
            Console.WriteLine("OK");
            Console.ReadKey();

            
    多态概念：让一个对象能够表现出多种状态
    实现多态的手段：
    1：虚方法(virtual )可重写（Override）

1：虚方法
步骤：
  1,将父类的方法标记为虚方法，使用关键字virtual 这个函数可以被子类重新写一遍
  怎么重写啊，加一个Override在子类的方法的void前面
    如何实现的多态：      其实我们最终调用的是父类的，只不过这个方法别子类重写了，我调的时候不在执行自己的了而去执行子类重写的那个具体调用别那个子类重写的方法，取决于你装的是谁的对象
  多态练习
 
 

抽象类和虚方法一个父类里有实现，一个父类里没实现
练就一个神功，自攻 ，火攻，刀切 ，不能想到你是怎样的方法完成的事，抽象类
//狗狗会叫 猫咪也会叫
Public void Test(); //方法体 空实现
        当我们的父类中的方法不知道去如何实现的时候，可以考虑将父类写成抽象类，将方法写成抽象方法 父类关键字：abstract
    ============================================
    抽象类是没有方法体的
    抽象类是不允许创建对象的(没意义) 接口也是不允许创建对象的
    =============================================
Animal a=new Dog();
a.Bark();
Console.WriteLine();

publi  abstract  class Animal
{
 Public abstract void Bark();//存在的意义：让子类重写
 
}

Public class Dog:Animal
{
  publi override Bark()
  {
    Console.WriteLine("狗狗旺旺的叫");
  }
}
Public class Cat:Animal
{
  publi override Bark()
  {
    Console.WriteLine("猫喵喵的叫");
  }
}

父类的方法有意义用虚方法
抽象类中写非抽象成员（字段，属性，）
1。抽象成员必须标记为abstract ,并且不能有任何实现
2.抽象成员必须在抽象类中 （不能在非抽象中写抽象类）
3.抽象类不能被实例化
4.子类继承抽象类后，必须把父类中所有抽象成员都重写
  (除非子类成员也是一个抽象类，则可以不重写父类的抽象成员)
5.抽象类的访问修饰符不能是Private
6.在抽象类中可以包含实例成员。
  并且抽象类的实力成员可以不被子类实现
7.每个类中默认都会有构造函数，抽象类是有构造函数的，虽然不能实例化。
8.如果父类的抽象方法中有参数，那么，继承这个抽象父类的子类重写父类的方法的时候必须传入对应的参数。

如果抽象类的抽象方法中有返回值，那么子类再重写这个抽象类方法的时候必须要传入返回值。
(子类重写父类的方法的签名必须跟父类抽象方法的签名一样  签名：返回值和参数
===
如果父类中的方法有默认的是实现，并且父类需要被实例化，这时我们考虑将父类定义成一个普通类，用虚方法实现多态；
如果父类中的方法没有默认实现，父类也不需要被实例化，则可以考虑将该类定义为抽象类。

我能不能在抽象类中写一个虚方法：可以

        byte[] buffer = File.ReadAllBytes(@"C:\Users\SpringRain\Desktop\抽象类特点.txt");
            将字节数组中的每一个元素都要按照我们指定的编码格式解码成字符串
            UTF-8  GB2312简体中文 GBK简繁 ASCII  Unicode全部的编码
            //string s = Encoding.Default.GetString(buffer);
            //Console.WriteLine(s);
            //Console.ReadKey();