C#面向对象

   class Fenbi
   {
       static string _Color;

    public static string Color
    {
      get { return Fenbi._Color; }
      set { Fenbi._Color = value; }
    }
       int _Lenght;

    public int Lenght
    {
      get { return _Lenght; }
      set { _Lenght = value; }
    }  
   }

      Fenbi.Color ="Yellow";
      Fenbi b = new Fenbi();
      b.Lenght = 10;

     public static void xiezi()
       {
           Console.WriteLine("写出"+_Color+"的文字了");
       }

     public void change()
        {
            Console.WriteLine(_Color+"的粉笔长度变为："+_Lenght);
         }

      public Ren(string name, int age)
      {
          _Name = name;
          _Age = age;
      }

      public Chinese(string name, int age, string yuyan):base(name,age)
        {
            _Yuyan = yuyan;
        }

    class Ren
    {
        protected string _Name;
        protected string _Country;
        public virtual void Eat()
        {
            Console.WriteLine("正在吃饭...");
        }
    }
    class American : Ren
    {
        public override void Eat()
        {
            Console.WriteLine("正在用叉子和刀子吃饭....");
        }
    }
    class Chinese : Ren
    {
        public override void Eat()
        {
            Console.WriteLine("正在用筷子吃饭...");
        }
    }

    Random rand = new Random();
    int n = rand.Next(100);
    Ren a;
    if (n % 2 == 0)
    {
        a = new American();
    }
    else
    {
        a = new Chinese();
    }
    a.Eat();

class Monster
    {
        public void EatFood(Ren r)   //r = a;
        {
            r.Cry();
            Console.WriteLine("人类真好吃，吃饱了！");
        }
    }
    class Ren   
    {
        public virtual void Cry()
        {
            Console.WriteLine(".......");
        }
    }
    class American:Ren
    {
       
        public override void Cry()
        {
              Console.WriteLine("MyGod,God bless me!");
        }
    }
    class Chinese:Ren
    {
        public override void Cry()
        {
            Console.WriteLine("天哪，老天爷保佑我！");
        }
    }

            Monster m = new Monster();
            Random rand = new Random();
            int n = rand.Next(100);
            if (n % 2 == 0)
            {
                American a = new American();
                //或者是这样写 Ren a = new American();

                m.EatFood(a);
            }
            else
            {
                Chinese c = new Chinese();
                //或者是这样写 Ren c = new Chinese();

                m.EatFood(c);
            }

一：抽象方法

1. 在面向对象编程语言中抽象方法指一些只有方法声明，而没有具体方法体的方法。抽象方法一般存在于抽象类或接口中。

    在一些父类中，某些行为不是非常明确，因此无法用代码来具体实现，但是类还必须具备此方法，因此，把这样的方法定义为抽象方法。

2. 声明方法：public abstract Eat(); 方法声明只是以一个分号结束，并且在签名后没有大括号，没有函数体，因为太抽象不清楚，具体的实现由各个子类中重写函数实现。

3. 它的特点：

（1） 抽象方法是隐式的 virtual 方法。

（2） 只允许在抽象类中使用抽象方法声明。

（3） 因为抽象方法只声明不提供实实现，所以没有方法体。抽象方法只在派生类中真正实现，这表明抽象方法只存放函数原型(方法的返回类型，使用的名称及参数)，而不涉及主体代码。

（4） 加abstract关键词。

（5）抽象方法的目的在于指定派生类必须实现与这一方法关联的行为。

二：抽象类

1. 抽象类：无法被实例化的类。关键词是abstract，凡是带有abstract关键词的类都无法被new出来。抽象类是不完整的，它只能用作基类。在面向对象方法中，抽象类主要用来进行类型隐藏和充当全局变量的角色。

2. 声明：抽象类声明：public abstract class Ren{}；

3. 注意：

（1）凡是带有抽象方法的类肯定是抽象类；抽象类却不一定包含抽象方法。

（2）构造方法，静态成员方法不能声明为抽象方法。

（3）一个非抽象类必须实现从父类继承来的所有抽象方法，如果有一个抽象方法没有实现，则此类必须要加abstract关键字。如果父类被声明为抽象类，并存在未实现的抽象方法，那么子类就必须实现父类中所有的abstract成员，除非该类也是抽象的。

4. 特征：

（1）抽象类不能实例化。

（2）一个抽象类可以同时包含抽象方法和非抽象方法。

（3）不能用sealed修饰符修饰抽象类，因为这两个修饰符的含义是相反的，采用sealed修饰符的类无法继承，而abstract修饰符要求对类进行继承。

（4）从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实际实现。

例子：Ren类中有一个抽象方法Eat()，在其派生类Chinese和American中必须重写这个方法

abstract class Ren
    {
        protected string name;
        public abstract void Eat();
    }

    class Chinese:Ren
    {
        public override void Eat()
        {
            Console.WriteLine("用筷子吃饭");
        }
    }
    class American : Ren
    {
        public override void Eat()
        {
            Console.WriteLine("用刀叉吃饭");
        }
    }

三：接口

1. 关键字：interface，用interface 关键词来定义。

2. 概念：极度抽象的类，无成员变量，无实例属性和实例方法，只有抽象方法或抽象属性，生活中的例子：标准，规则。

 

3. 写法：接口不用class，用interface，名字一般以I作为首字母；不用写abstract，里面所有都是，不用写public，必须是public。

    interface IUSB         //接口
    {
        void start();
        void stop();
    }

4. 特点：

（1）接口中的方法都是抽象的，因此无需加abstract修饰符。

（2）接口中的方法都是公用的，因此无需加public修饰符。

（3）接口就是一个规则标准。

（4）接口可以继承父接口。

（5）一个类可以实现（继承）多个接口。一个类只能有一个父类，但可以实现多个接口。

例子：简单的IUSB接口，里面有两个抽象方法start()和stop()，派生类实现接口必须实现接口中的所有方法。

 interface IUSB         //接口
    {
        void start();
        void stop();
    }
    class UDisk : IUSB  //实现接口必须实现里面的所有方法
    {
        public void start()
        {
            Console.WriteLine("U盘启动了");
        }
        public void stop()
        {
            Console.WriteLine("U盘停止了");
        }
    }
    class Cammer : IUSB
    {

        public void start()
        {
            Console.WriteLine("摄像头启动了");
        }

        public void stop()
        {
            Console.WriteLine("摄像头关闭了");
        }
    }

    class computer
    {
        public void CheckUSB(IUSB usb)
        {
            usb.start();
        }
        public void CloseUSB(IUSB usb)
        {
            usb.stop();
        }
    }

用的时候：

       computer c = new computer();
       UDisk u = new UDisk();
       Cammer m = new Cammer();

       c.CheckUSB(u); //插入U盘
       c.CheckUSB(m); //插入摄像头

       c.CloseUSB(u); //拔出U盘
       c.CloseUSB(m); //插入摄像头

四：命名空间

1. 概念：namespace 相当于一个包，它是对类进行分类管理的工具，给计算机看的，相同命名空间下的类可以分在不同的文件中存储。

2. 一般写法：namespace 公司名.项目名.模块名

3. 在别的命名空间上面要使用其它命名空间内的类，可以在它的上面写 using 要使用的命名空间；

五：项目名

一般默认：ConsoleApplication1，用来给人类标识出这个项目是做什么的，给人看的。

六：程序集

在项目名上打右键：属性，即可修改程序集名称

编译出来的exe或dll文件就是程序集。exe是控制台应用程序，dll是库类。

程序集的名字就是编译出来的exe或dll名字。

如果一个项目分三个人来写，A写一个类库，B写一个类库，C写Main函数，把他们整合在一起的流程是：

1. A写完了编译出一个名字如 cc.dll 的文件；

2. B写的时候要用到A命名空间中的某个类，B先将A的cc.dll文件拷贝到自己的目录下，B需要在项目中的引用上打右键：添加引用，通过浏览找到该引用添加进来，然后using A 的命名空间;

3. B写完了编译出一个名字如 dd.dll 的文件；

4. C要写Main函数，在Main函数中操作AB中的类，他需要将AB的dll文件拷贝过来，然后再项目中的引用上打右键，添加引用，通过浏览找到该引用添加进来，然后using A 的命名空间; using B的命名空间，这样就可以在Main函数中用了。

5. 如果A的命名空间中有个类Ren和B的命名空间中有个类Ren重名了，这C在用的时候要用哪一个命名空间下的Ren类就要用该命名空间点出来再用。