C#面向对象的笔记

1，把值类型赋值到引用类型成为装箱。object obj= 10; 

2,  把引用类型赋值给值类型用到拆箱操作。int a = (int)obj;

3，is 操作符，用于检查对象是否是某类型，返回结果是个bool类型。

     object obj=10;

     if(num is Int32){ int a = (int)obj; }//前面只是判断是否是int类型，当操作的时候，应该再有个强制转换

4，重载：1，方法名相同；

                 2，参数的数量不同，或者参数数量相同，参数类型不同。

5，a++,先赋值操作，再加1；

     ++a,先加1再赋值操作。

6，as 如果可以转换，就转换过去，不能转换，返回NUll。

     as 后面只能跟引用类型，只是为引用类型服务的。

7，范型：一个占位符，用于表示可变的类型的参数。  如： void Swap<T>(T a,T b);

8,为什么要用范型？

    1，当程序中，有多个方法功能相似，只是参数的数据类型不同的时候，比如一个int,一个string，我们需要写多个方法处理每种数据类型。

    2，如果用object处理的话有弊端：一是 值类型的需要大量的拆箱、装箱操作，影响性能；二是引用类型会有许多强制转换，也影响性能。

8，什么是范型？

      声名的时候类型不定，代用的时候，类型才决定下来。

9，范型自定义MyList泛型类

          public class MyList<T>

          {

                    private T[]  list;

                    public int Count;

                    public MyList<T>(int i):base()

                    {

                              this.list=new T[i];

                              this.Count=i;

                    }

                    public MyList<T>(T[] temp):base()

                    {

                              this.list=temp;

                              this.Count=temp.Length;

                    }

                    public void Clear()

                    {

                              this.list=null;

                              this.Count=0;

                    }

          }

10，ref out 传递引用的关键字

          相同点：

          两者都是按地址传递的，使用后都会改变原来变量的数值。

          调用函数和被调用函数中都要用ref,out修饰参数。

          不同点：

          ref是有进有出，out是只出不进，

          1，ref修饰的参数在调用之前，变量一定要赋值；

               在被调用函数内可以不用再赋值。

          2，out修饰符，在调用函数之前，变量可以不进行初始化；

               out参数数值不能进入被调用函数，当out参数进入被调用函数后会变为空，需要你初始化一次。

          注意：

           一个方法有ref或out,一个方法没有ref或out，可以实现重载。

          两个方法一个是ref的参数，一个是out修饰的参数，则不能实现重载，因为在编译的时候两者相同，只是在运行时才加以区分。

11，析构方法

          结构器与构造器正好相反，用于清空操作，释放对象的一些资源，例如流，句柄，文件的引用等。

12，var a =10 推导型变量，通过右边的数据类型，推导到左边的变量。

13，抽象方法和虚方法的异同：

       1）抽象方法一定不能有实现；虚方法一定有实现。

       2）抽象方法被继承后，必须要重写；虚方法被继承后，可以不被重写。

       3）抽象类中可以有虚方法；类中如果有抽象方法，则该类必须声明为抽象类。

14，抽象类的一些特点：

         1）抽象方法只作声明不做实现，旨在派生类中实现，所以抽象方法不能用private修饰。

         2）抽象类不能实例化。

         3）抽象类可以没有抽象属性和抽象方法，但是一旦有抽象方法，该类必须声明为抽象类。

         4）如果抽象类的派生类不是抽象类，那么必须重写抽象类中的所有抽象方法和抽象属性。

15，接口和抽象类的异同：

          相同点：

          1）两者都不可以直接实例化。

          2）两者都可以包含抽象成员。

          不同点：

          1）抽象类除了拥有抽象成员外，可以拥有非抽象的成员；接口所有的成员都必须是抽象的。

          2）抽象类的成员可以有私有的：接口中的成员默认都是共有的。

          3）接口中不能含有构造函数、析构函数、静态成员、常量。抽象类除了不能实例化，其他的和普通类没什么区别。

          4）C#只支持但继承；通过接口可以实现多继承。

          5）接口里面不能有静态函数，但是抽象类里面可以有。

2014-12-3

1，集合：创建和管理数组的另一种方式

      与数组的不同：对象集合可以根据需要动态的增长和收缩

     注意：

     非范型集合： 命名空间 ：System.Collections {ArrayList,Hashtable,Queue,Stack}

     范型集合：     命名空间： System.Collections.Generic

     只要类继承了IEnumerable接口， foreach() 就可以遍历

     IEnumerable 接口里面只有一个 public virtual GetEnumerator() 方法

     Stack 栈

     1)Stack类实现了ICollection和IEumerable接口。

     2)后进先出的一种数据结构

     3）Stack接受null作为有效值并且允许重复的元素

    public virtual void Push(object obj); 把一个对象推导栈中

  public virtual object Peek ();获得栈顶的元素。

  Queue 队列

  1)Queue类实现了ICollection和IEumerable接口。

  2）先进后出的类型。

  3)加入范型，用于约束传入参数的类型，使类型安全。

    public virtual void Enqueue(object obj);

  Dictionary<string,int> dic= new Dictionary<string,int>();

  字典

  索引器：就是对类里面的数组对象进行更改和查看操作的。是可以通过传入参数的类型的不同进行重载。

  public class Lanou

  {

     int[] age= new int[5];

     public int this[index]

     {

          get

          {

               if(index<age.length)

               {

                    return age[index];

               }

          }

          set

          {

               if(index<age.length)

               {

                    age[index]=value;

               }

          }

     }

  }

     Public void Main()

     {

          Lanou[] lanou= new Lanou[3];

          //这里不能通过 new Lanou[]() 构造函数来进行初始化。

          //构造函数初始化生成一个对象，这里是生成了包含3个对象的一个数组。

          //int[] arr= new int[3]{1,2,3}; 大括号初始化数组里 每个int成员。

          lanou[0] =new Lanou();

          lanou[1] =new Lanou();

          lanou[2] =new Lanou();

          lanou[1][1] = 10;//第一个1 是说第二个数组，第二个1 是说所引起的下标为1

          //这里的lanou数组和 数组内每个索引器是分开的.

     }

4，List和ArrayList的异同：

•      1）ArrayList 是动态的对数组操作的类型，弱类型的，它里面是对object类型的操作，会有大量的装箱和拆箱操作，影响性能。且类型不安全 ，缺少编译时候的类型检查,比如往数组里存取一个不同类型的对象，会引起错误。不推荐使用。
•      2）List<T> 是范型集合，强类型的，不存在装箱拆箱操作。在声明的时候类型就确定了，会限制存取的对象类型。推荐使用。
• 相同点：都可以动态的处理对数组对象。动态数组的好处是不必预先设置较大的数组，减小了不必要的内存开销。

2014-11-30     静态类进阶、抽象类

    静态类的特点：

1，静态类不能被实例化。

2，静态类不能被继承。静态类是密封的。

3，静态类里面只能有静态成员。不能有实例成员。

4，静态类里面可以有静态构造函数。不能有实例构造函数。

     静态构造函数：

1，静态类可以有静态构造函数，静态构造函数不可以被继承。

2，静态类可以有静态构造函数，非晶态类也可以有静态构造函数。

3，静态构造函数没有访问修饰符，没有参数，只有static关键字修饰。

4，静态构造函数不能直接被调用，只能当创建类实例或者引用静态成员变量之前，自动被自动执行，并且只被执行一次。

     注意

1，静态类在内存中是一直有位置的；

2，非静态类在实例化后是在内存中是独立的，它的变量是不会重复的，在使用后会及时销毁。不会出现未知错误，建议多使用非静态类。

 3，当定义的类不需要实例化的时候，我们使用静态类；如果需要实例化对象，需要继承等特性时，应该使用非静态类，并且将统一使用的方法和变量设为静态的，所有的实例对象都能访问。

2014-12-4委托

定义：

     1，委托是将方法作为一个参数传递给其他方法。

     2，委托类似于函数指针，但是与函数指针不同的是:委托是面向对象的，类型安全的和保险的。

     3，委托既能引用静态方法，也能引用实例方法。

     4，委托实际上是个类，可以将方法动态的传递给参数，避免大量使用if-else ,使程序具有更好的扩展性；

异常处理机制：

     try{}catch(Exception e){Console.WriteLine(e.ToString());}finally{}

     catch里面可以再加个try{}catch{}，但是finally只能有一个。finally肯定会被执行。

     catch后面可以再多加几个catch{}，多个catch用于抓获不同类型的异常信息，区分各种异常，用于不同的后边处理工

     作。所有的异常类型继承自Exception基类。

重写和覆盖的不同点：

1，不管重写和覆盖都不会影响父类的功能。

2，当调用子类创建父类的时候，如C1 c3 = new C2(); 重写会修改父类的功能；

而覆盖不会修改父类的功能，仍然会调用父类的原有功能。

3，虚方法、实方法都可以被覆盖（new），重写是只能虚方法可以重写，是方法不能重写,抽象方法，接口不可以被覆盖。

4，抽象方法，接口，标记为virtual的方法可以被重写（override）,实方法不可以。

5，重写使用的频率比较高，能实现多态；覆盖使用的频率比较低，用于对以前无法修改的类进行继承的时候。