c#学习笔记

首先，我要说明，这是写给我自己看的，记录自己以前不牢固的知识点，如果你进来了，我只能说：“sorry !”。

其次，小小的抱怨一下-----csdn的博客不支持无限极分类，以后笔记只能笼统的放一起了。

最后，正文~~

类和接口

1.密封。

使用 sealed 关键字来禁止类的继承或成员的重写，如 string 类。

public sealed class String
{
    //...
}
public class Parent
{
    public sealed void Method()
    {
        //...
    }
}

2.重写。

重写的目的是：使用基类实例调用派生类的方法。关键字为一对，virtual----override。

    class Program
    {
        static void Main(string[] args)
        {
            Parent c1 = new C1();
            Parent c2 = new C2();
            c1.WriteName();//out:c1
            c2.WriteName();//out:parent
        }
    }

    class Parent
    {
        public virtual void WriteName()
        {
            Console.WriteLine("Parent");
        }
    }
    class C1 : Parent
    {
        public override void WriteName()
        {
            Console.WriteLine("c1");
        }
    }
    class C2 : Parent
    {
        public new void WriteName()
            //不指定new关键字是一个结果，但是会有一个警告
        {
            Console.WriteLine("c2");
        }
    }

3.扩展方法。
不利于扩展，建议已修改源码或者继承的方式实现。但对于无法获得源码又没法继承的类就只能这样了。 注：扩展方法也可以用于接口和集合。

    class Program
    {
        static void Main(string[] args)
        {
            string str = "123";
            Console.WriteLine(str.ToInt() + 12);
        }
    }

    public static class Hander
    {
        public static int ToInt(this string str)
        {
            return Int32.Parse(str);
        }
    }

4.接口。

接口可以提供方法或属性的契约，如果是属性，需指定get或set。实现时必须给出实现，即{};另外接口的定义不应该包含任何访问修饰符。显式实现(即方法名前加接口名.)必须与接口一致。隐式实现则可指定为public，并使用其他修饰符，如:virtual、sealed。

5.运算符重载。

可以对+  -  *  /  %  &  |  ^  <<  >> 及其与赋值运算符的复合运算符(自动)，  ==  !=  true  false，转换运算符（隐式转换implicit，显式转换expliclit）   进行重载。

    class Class1
    {
        private int data;
        public static int operator +(Class1 left, Class1 right)
        {
            return left.data + right.data;
        }
        public static bool operator true(Class1 c)
            //必须和false成对出现
            //可用于if、do、while、for
        {
            return c.data != 0;
        }
        public static bool operator false(Class1 c)
        {
            return c.data == 0;
        }
        public static implicit operator int(Class1 c)//隐式
        {
            return c.data;
        }
        public static explicit operator Class1(int d)
        {
            return new Class1();
        }

    }