C#笔记

1.数据类型
  数值类型：char , double ,float ,int ,bool ,decimal ,结构体 ，枚举 ...
  引用类型：数组 ，String ,委托 ...
  注意的是String也是引用类型
  还有就是关于装箱，拆箱的问题(大的数据类型转换为小的为拆箱，反之为装箱)注意装箱是把数据类型也装入了；
  举例如下：
          (装箱) double k = 3.3;
            object g;
            g = k;
            Console.WriteLine(g);
            这个就是装箱，但是装箱会很耗系统资源；
             double k = 3.3;
            object g;
            g = k.ToString();
            Console.WriteLine(g);
            这样就不会消耗太多系统资源，因为string型也是引用类型不用转；
         （拆箱）
            object k = 5;
            int i;
            i = int.Parse(k.ToString());
            Console.WriteLine(i);
            拆箱的时候必须转化为原来装箱时的数据类型，不然会出错；
           
  object是所有数据类型的父类，他是引用类型其实多数的引用类型都是类，所有的数值类型都是结构体
 
  注意：
      float k = 1.5;
      Console.WriteLine(k);
      这样是不对的，因为系统默认是double，所以必须显示的表示，所以要在1.5后加f；
      与float相同的还有decimal也要加后缀M或者m；
      其他的一次类推，实践才会知道；
     
  关于引用类型和数值类型的比较：数值类型存储在线程堆栈中，而引用类型存储在委托敦中；
  for example:
                int a = 3;
            int b = 5;
            Console.WriteLine(a);
            Console.WriteLine(b);
            changnum chk = new changnum();
            chk.chang(a, b);
            Console.WriteLine(a);
            Console.WriteLine(b);
        }

        class changnum
        {
            public void chang(int a, int b)
            {
                int temp;
                temp = a;
                b = a;
                b = temp;
            }
        这个就是值传递；传后数值不变
            int[] arri = new int[] { 8};
            int[] arrj;
            arrj = arri;
            arrj[0] = 100;
            Console.WriteLine(arri[0]);
        这个就是引用类型，区别在于引用类型的发生了交换；
       
  数组的定义：int[] arri=new int[]{1,3,5.....};这样比较简单
              也可以是：int[] arri=new int[5];
                        arri[0]=1;
                        arri[1]=2;
                        ................

2.流程控制

   1.for语句，while语句，do while语句，switch语句，if..else..语句
     这个C已经很清楚的话就没问题
   2.foreach语句
     这个C中是没有的，下面举个例子
            int[] arri = new int[3];
            arri[0] = 7;
            arri[1] = 8;
            arri[2] = 9;
            foreach (int i in arri)
            {
                Console.WriteLine(i);
            }
      遍历整个数组；
     
     
 3.集合和数组
  
    有两种堆栈，和队列
   
      堆栈：先进后出（FILO）
            Stack<int> stk = new Stack<int> { };
            stk.Push(1);
            stk.Push(2);
            foreach(int i in stk)
            {
                Console.WriteLine(i);
            }
            取出用push，取出来看是peek；
      队列：FIFO
            Queue<int> que = new Queue<int> { };
            que.Enqueue(1);
            que.Enqueue(2);
            foreach (int i in que)
            {
                Console.WriteLine(i);
            }
            取出是Dequeue,取出来看是peek；
      hashtable:
            HashSet<int> hs = new HashSet<int> { };
            hs.Add(1);
            hs.Add(2);
            hs.Add(3);
            foreach (int i in hs)
            {
                Console.WriteLine(i);
            }
            还有交错数组就不说了；

3.面向对象(慢慢想，比较抽象)

    class Program
    {
        static void Main(string[] args)
        {
            car car1 = new car();
            string name=car1.name;
            Console.WriteLine(name);
            car1.menony();
        }
      
    }
    public class car
    {
        public string  name="兰博基尼";
        public void menony()
        {
            Console.WriteLine("$1000000000");
        }
    }

4.类的语法....（4种）
  1.普通的类
   public class car
    {
        public string  name="兰博基尼";
        public void menony()
        {
            Console.WriteLine("$1000000000");
        }
    }
  2.静态类
    static void Main(string[] args)
        {
            car car1 = new car();
            string name=car1.name;
            Console.WriteLine(name);
            car1.menony();
        }
  3.抽象类abstract
  4.密封类sealed
 
5.继承

  普通函数的继承：
       static void Main(string[] args)
        {
            ZClass zl = new ZClass();
            zl.F1();
            FClass fl = new FClass();
            fl.F1();
            C#中还允许用子类实现父类
            比如
             FClass fl = new ZClass();
             fl.F1();
        }
       
        class FClass
         {
            public void F1()
          {
            Console.WriteLine("F1 father");
          }
         }
        class ZClass:FClass
         {
 
          }
   
        私有成员不能继承；
        internal是本应用程序中可以与public等同；
        protected是只能在子类中访问；

        子类可以影藏父类的方法属性等，可以用new关键字或者没有都可以；
        如果要覆盖就用virtul和override关键字，这样的话，用子类实例父类的时候条用的是子类的方法和属性，因为已经覆盖；
        关键字中乐意没有virtul但是不能没有override；

 2.静态类
   不能被继承；
   但静态方法和属性属于类；
  
 3.密封类
   也不能被继承；
  
 4.抽象类
  
   抽象类中的抽象方法等不能在抽象类中实现，只能定义；
   抽象类中的抽象方法等定义，必须在继承它的类中实现；
   抽象类不能实例，只能通过它的子类来实现，并且实现时应该用override关键字覆盖；
  
  
   关于构造函数的继承，应该是不能继承的，但是如果实现子类的构造方法和父类的构造方法
   不一致，那么我们必须base关键字调用父类的构造函数；
   this关键字自己看，一样的！
  
  
  

接口：
     接口可以继承接口，抽象类可以继承接口；
     类可以继承接口，接口不能继承类；
     具体的在研究设计模式的时候再深入；
     类只能单重继承，接口可以多重继承；
    
    
委托和事件：
    delegate  and event