学习Siki学堂C#初级教程、中级教程过程中的笔记和最后完成的自定义列表MyList

初级篇：
1、输出语句：Console.WriteLine("...")==Console.Write("...\n");
   输入语句：得到输入的字符串，sting xxx =Console.ReadLine();(返回类型为string)
             得到输入的整数：先得到这个整数的字符串然后转化为整数。
       string str="123";
                            int num = Convert.ToInt32(str);
             得到输入的小数：类似整数。
       Convert.ToDouble(str);
2、命名空间>类>方法（函数）；
3、变量类型：
 整数类型：
  sbyte   -128~127
  byte    0~255
  short   -32768~32767
  ushort  0~65535
  int     -2147483648~2147283647
   uint 0~4294967295
   long ...
   ulong ...
 小数类型：
  float<double<decimal
  a.float赋值时需要在之后加“f”，如“float myFloat = 12.5f;”(默认的小数类型是double)
 Bool类型：
  true/faulse;
 ***在给float类型的变量赋值时需要后缀f，因为小数默认为double型
4、格式化输出：Console.WriteLine("...{0}...{1}...{...}",a,b,...);
5、转义字符可用Unicode值来表示如"\'"=="\u0027"(16进制)
6、字符串前加'@'使得转义字符失效，如果要在这样的一个字符串中表示引号应该在目标位置放下两个引号
 1）加@后可以把字符串定义在不同行，编译器不会再去识别字符串中的转义字符
        2）表示路径时用@更为方便，如"c:\\xxx\\xxx\\xxx.doc"==@"c:\xxx\xxx\xxx.doc"
7、goto + 标签名；标签名 + ':'
8、函数Math.Sqrt(i)可以得到一个数的平方根
9、生成随机数：
 Random random = new Random();
 int num = random.Next(x,y);(x为随机数的最小值，y为上限但不包括，即x<=结果<y)
10、定义a为数组，则a.Length为该数组的长度
11、遍历数组：
 foreach(int temp in scores){...};(foreach会以此去到数组中的值，然后赋给temp，然后执行循环体)
12、常用字符串处理函数：
 1）int res = str.Length  (字符串长度)
 2）string res = str.ToLower();(将字符串转化为全部小写的形式) 
 3）string res = str.ToUpper();(将字符串转化为全部大写的形式)
 4）string res = str.Trim();(将字符串中的前后的空格去掉)
 5) string res = str.TrimStart();(去除开头空格，str.TrimEnd()类似)
 6）string[] strArray = str.Split(char ...);(把原字符串按照指定的字符进行拆分得到字符串数组)
13、string str = "...";char[] arr;arr = str.ToCharArray();(把字符串转化为字符数组)
    string res = new string(arr);(把字符数组转化为字符串)
14、数组常用函数：Array.Sort(目标数组名)  (升序排序)
          Array.Reverse(目标数组名)  (降序排序)
   Array.Copy(array1,array2,int count)  （将array1中的前count个元素复制到array2中）
15、参数数组：static int Plus(params <baseType>[] array),当参数个数不确定（但类型相同）时，这样编译器会将传入的数据自动组拼为一个数组传过去。
16、委托：
    委托的定义（放在namespace下）制定了一个返回类型和参数列表，定义之后声明一个变量，可以将一个相同返回类型和参数列表的函数赋值给这个变量。相当于函数的别名。关键字：delegate
 public delegate double MyDelegate(......(参数列表))；

中级篇：
17、调试和错误处理：
 1）正常模式下的调试，利用Console.WriteLine()输出程序运行过程中异常量的值，以此判断(Unity中使用      Debug.Log("") Debug.Error("") Debug.LogWarn("")像Unity的Console窗口输出信息帮助我们调试错误。)
 2）中断模式下的调试，利用编译器提供的Debug功能进行逐步调试。
18、异常处理try...catch...finally...
 try{
  ...
 }
 catch(<exceptionType> e){
  ...
 }
 finally{
  ...
 }
    其中catch块可以有0个或多个，finally块可以有0个或1个。但是如果没有catch块，必须有finally块，没有    fanally块，必须有catch块，finally块和catch块可以同时存在
 1）try块：
   包含了可能出现异常的代码（一条或多条语句），在try块中如果一条代码发生了异常，那么try块中剩余 的代码就不会执行（实现循环，try块末尾加入break）
 2）catch块：
   用来捕捉异常，当代码发生异常，且异常的类型和catch块中的类型一样的时候，就会执行catch块，如果 catch块的参数不写，表示发生任何异常都执行这个catch块
 3）finally块：
   包含了始终会执行的代码，不管有没有异常产生都会执行
19、类：定义对象的模板。每个类都包含数据，并提供处理和访问数据的方法。
 使用类定义一个对象（实例）之后首先应该初始化（初始化后string默认为空串，int 默认为0），如定义一个Customer类之后，
 Customer customer1；
 customer1 = new Customer();
20、构造函数：对象在初始化时所遵照的模板。
 在类内定义构造函数，构造函数无返回类型，函数名与类名相同。编译器默认提供一个无参构造函数，在我  们所定义的构造函数中未涉及的字段将根据编译器默认方法进行初始化，构造函数可以重载
21、属性：
 1）定义：
 public <type> <name>{
  get{
   //get code
  }
  set{
   //set code
  }
 }
 //属性的使用和字段一样，当我们对属性赋值时调用set块，使用属性的值时调用get块
 //set块中关键字value即为属性的值
 //set和get块不要求同时存在，当没有get时就无法取值，没有set时就无法赋值
 //可以设置属性为只读或者只写（在set或get前加private修饰符，或者删除set或get块）
 2）简写形式：
 public string Name{get;set;}//编译器会自动给我们提供一个字段，来存储name
22、匿名类型：
 使用var关键字声明一个变量，当初始化的时候这个变量的类型就被确定下来，并且以后不可以修改
23、值类型：整数,bool,struct,char,小数
    引用类型：sring,数组，类
    值类型存储在栈中，引用类型有两部分，实际数据存储在堆中，引用部分（指向堆中数据）存储在栈中
24、继承：1）父类中只有公有的字段和方法能够被子类继承
   2）父类声明的对象可以用子类进行构造（初始化）且可以使用子类的方法和字段：
  Enemy enmey = new Boss();
  Boss boss = (Boss)enemy;
25、虚方法：在父类中方法声明前加virtual就可以在任何子类中重写：
 class MyBaseClass{
  public virtual string VirtualMethod(){
   return "Method is called in case class";
  }
 }
     在子类中重写另一个函数时，要使用override关键字：
 class MyDerivedClass{
  public override string VirtualMethod(){
   return "Method is called in derivedclass";
  }
 }
 //我们在子类中重写虚函数之后，不管在哪里调用都是调用重写后的函数
26、this和base关键字
 this:调用当前类内的字段和方法（包括继承所得字段和方法）
 base:访问父类中的字段和方法
27、抽象类：
 abstract关键字，当类中存在抽象函数时，类也必须定义为抽象，抽象类不能去实例化一个对象（但可以声  明之后使用完善的子类进行实例化）
 当子类以抽象函数为父类继承时必须完善父类中缺少的函数（抽象函数）
28、密封类和密封方法：
 sealed关键字，表示该类不能被继承或重写后的子类方法不能被再次重写（即sealed关键字只能用于修饰子 类中被重写后的方法） 
29、派生类的构造函数(base关键字)（可用于给父类中private的变量赋值）：
 public class MyDerivedClass{
  public MyDerivedClass():base(){
   ...
  }
 }
 //这样，当调用子类的构造函数时，先调用父类的，然后调用子类的
30、修饰符protected和static:
 1)protected：只有继承该类的子类可以访问（区别于private）
 2)static：可以修饰字段或方法，使用static修饰的成员只能通过类名访问（不能使用对象访问）
31、接口（类的模板）：interface关键字
 public interface IFlyHandler{
  public viod Fly();
 }
 实现接口的类必须完善所有的接口函数（类似抽象函数），接口之间也可以继承（类似类的继承）
32、集合类 列表List（类似于C语言可变数组，当列表中的成员数超过上限列表就会自动扩充为原来的两倍（以4为起点）而不是一个一个的增加）：
 1）定义（关键字List）：List<...(baseType)> <listName> = new List<...(baseType)>();
       //var <listName> = new List<...(baseType)>();
       //var <listName> = new List<...(baseType)>(){...,...,...};
 2)列表中常用的方法（函数）和属性：
  a.Add(...)  向列表中插入数据
  b.Insert(int index,int item)  在目标位置插入一个数据（并不删除原数据，原数据依次向后移动）
  c.[index]  访问元素
  d.Capacity属性  获取和设置容量
  e.Count属性  获取列表内数据个数（区别于容量）
  f.RemoveAt(int index)  移除指定位置的元素(其他元素也依次改变位置)
  g.IndexOf(var item)  查找item所在的位置(从前往后)，返回int index,如果元素不存在则会返回-1
  h.LastIndexOf(var item)  从后往前查找item并返回int index
  i.Sort()  将列表中的元素进行排序   
 3）列表的遍历（与数组相同）：
  a.for(i=0;i<list.Count;i++)
  b.foreach(var temp in list)
33、泛型
 1）泛型类：类中存在类型不确定的成员，在实例化时需要指定该不确定的类型
 class ClassA<T>{
  private T a;
  private T b;
  public ClassA(T a,T b){
   this.a=a;
   this.b=b;
  }
  public T FunA(){
   ...
  }
 }
 2）泛型方法：这个方法的参数的类型可以是不确定的，调用这个方法时再去确定类型
 public static T Function<T>(T a,T b){
  ...
 }
 //泛型中可以存在多个泛型，在尖括号中写出替代类名
 //泛型成员无法进行布尔运算，如果要判断两者是否相等则利用<成员名>.Equals(...)，如果相等则返回      true；如果一定要进行其他布尔运算，则需要在类名后加"where T:IComparable"，继承可比较类，然后          字段可使用<成员名>.CompareTo(obj)，如果返回值大于零，则说明该成员大于obj
34、索引器：使得对象可以用索引访问其元素（如应用在自定义列表中）
 class MyList<T>{
  ...
  public T this[int index]{
   get{...}
   set{...}
  }
  ...
 }
 //使用索引器时应当注意索引是否超出范围，如果超出，可以使用throw new Exception("...")命令

常用快捷键：
Ctrl + k然后Ctrl + c可以注释选中行
Ctrl + k然后Ctrl + u可以取消注释选中行
Ctrl + d直接复制并粘贴到下一行
F9 在光标所在行添加断点（单击行首也有相同功能）
Shift + F5 结束中断调试模式

自定义列表“MyList”：

class MyList<T>where T:IComparable
    {
        private T[] array;
        private int count=0;//表示当前添加的元素的个数
        public int Count { get { return count; } }
        public MyList(int size)
        {
            if (size >= 0)
            {
                array = new T[size];
            }
        }
        public MyList()
        {
            array = new T[0];
        }
        public int Capacity
        {
            get
            {
                return array.Length;
            }
          
        }
        public void Add(T item)
        {
            T[] newArray;
            if (count == Capacity)
            {
                if (Capacity == 0)
                {
                    newArray = new T[4];
                }else
                {
                    newArray = new T[count * 2];
                    //for (int i = 0; i < array.Length; i++)
                    //{
                    //    newArray[i] = array[i];
                    //}         //这是利用索引的基础方法
                    Array.Copy(array, newArray, count);
                }
                array = newArray;
            }
            array[count] = item;
            count++;
        }
        public T GetItem(int index)
        {
            if (index >= count||index<0)
            {
                throw new Exception("索引超出了范围！");
            }else
            {
                return array[index];
            }
        }
        public T this[int index]//索引器
        {
            get//当我们通过索引器取值的时候调用get块
            {
                return GetItem(index);
            }
            set//当我们通过索引器赋值的时候调用set块
            {
                if (index >= count || index < 0)
                {
                    throw new Exception("索引超出了范围！");
            }
                else
                {
                    array[index] = value;
                }
            }
        }
        public void Insert(int index,T item)
        {
            if (index >= 0 && index <count)
            {
                T[] newArray;
                if (Count == Capacity)
                {
                    if (Count == 0)
                    {
                        newArray = new T[4];
                    }
                    else
                    {
                        newArray = new T[Count * 2];
                    }
                }
                else
                {
                    newArray = new T[Count];
                }
                Array.Copy(array, newArray, index - 1);
                newArray[index] = item;
                for (int i = index + 1; i <= Count; i++)
                {
                    newArray[i] = array[i-1];
                }
                array = newArray;
                count++;
            }
            else
            {
                throw new Exception("索引超出范围！");
            }
          
        }
        public void RemoveAt(int index)
        {
            if (index >= 0 && index < count)
            {
                for(int i = index + 1; i < count; i++)
                {
                    array[i - 1] = array[i];
                }
                count--;
            }else
            {
                throw new Exception("索引超出了范围！");
            }
        }
        public int IndexOf(T item)
        {
            int index = -1;
            for(int i = 0; i < count; i++)
            {
                if (array[i].Equals(item))
                {
                    index = i;
                    break;
                }
            }
                return index;
        }
        public int LastIndexOf(T item)
        {
            int i;
            for( i = count - 1; i >= 0; i++)
            {
                if (array[i].Equals(item))
                {
                    return i;
                }
            }
            return i;
        }
        public void Sort()
        {
            //冒泡排序法
            for(int j = 0; j < count - 1; j++)
            {
                for (int i = 0; i < count - 1-j; i++)
                {
                    if (array[i].CompareTo(array[i + 1]) > 0)
                    {
                        T temp = array[i];
                        array[i] = array[i + 1];
                        array[i + 1] = temp;
                    }
                }
            }
        }
   }