C#面向对象

Dog d1 = new Dog();

class circle
    {
        float r;
        public circle(float a)
        {
            r = a;
        }
        public double zhouchang()
        {
            return 2 * 3.14 * r;
        }
        public double mianji()
        {
            return 3.14 * r * r;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            circle m = new circle(10);
            circle n = new circle(20);
            double bc = m.zhouchang();
            double mj = (n.mianji()-m.mianji());
            Console.WriteLine("内圆的周长为："+bc);
            Console.WriteLine("花砖的面积为："+mj);
        }
    }

 class Ren
    {
        string _Name;
        int _Age;

        public Ren()
        {
            _Name = "龙神";
            _Age = 25;
        }
    }

    class Ren()
        {
            string _Name;
            int _Age;

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

Ren a = new Ren("王大锤");

    string _Name;
    public string Name
   {
      get { return _Name; }
      set { _Name = value; }
   }

     Ren a = new Ren("王大锤");
     a.Name = "王尼玛";

  public class Mydate
    {
        int _Year;
        int _Month;
        int _Day;
        int _Hours;

       public Mydate(int year,int month) 
       {
           _Year = year;
           _Month = month;
       }
       public Mydate(int year,int month,int day,int hours): this(year,month)
       {
           _Day = day;
           _Hours = hours;
       }
    }

 Console.WriteLine(a is Ren);

非静态变量称为实例变量，非静态方法称为实例方法，实例成员的数据存在每个对象中，用对象名来调用。

静态成员包括：静态变量，静态属性，静态方法。

定义一个成员为静态的：在变量或方法前加static，如：static int a;

静态变量是属于类的，每个对象都有的并且相同的东西只保存一份，不和实例变量那样在每个对象里都面保存一份。

可以说它不属于任何对象，也可以说它又属于任何一个对象，给每个对象用，节省空间。

例如：每包粉笔的颜色是静态成员，每支粉笔的剩余长度是实例成员。

静态变量或方法不需要new出来。

在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; }
    }  
   }

（1）在当前类的花括号外，静态成员只能用类名来调用，不能用对象名来调用，而实例成员只能用对象名来调用，不能用类名来调用。

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

（2）在当前类的花括号内，静态方法只能直接调用静态成员，不能调用非静态成员，实例方法可以调用非静态和静态的成员。

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

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

10.  拷贝

浅拷贝：传递引用，不赋值对象。
深拷贝：创建一个新的对象。

（二）： 继承

1. 语法：public 子类名：父类名；如：class Dog:Pet。

2. 特点：单继承，一个父类可以派生多个子类，但每个子类只能有一个父类

             如果一个类，没有明确指定父类是谁，默认是object。除了object类之外，所有类都有一个父类。

             子类可以从父类继承下父类的成员变量和成员方法。

3. 访问修饰符合访问权限：

private 的成员不被继承，只能在该类中访问。

protected成员可以被继承，能在该类和派生类中访问到，在外界访问不到。父类中的变量一般用protected。

public成员可以被继承，能在所有地方访问到。

4. base 关键字：子类中可以用（base.父类中的成员 ）来调用父类中的成员，base()调用父类构造，base.xxx()调用父类成员方法。

调用的参数值会被覆盖，方法也会被覆盖。

5. 继承关系中实例化子类的流程：

先执行父类的构造函数，再执行子类的构造函数。

6. 继承关系的实例化：

如果父类的构造函数没有空参构造函数，全是带参数的，则子类必须要写构造函数，构造函数的形参中必须包含父类构造函数所需要的参数，还要用base()把父类构造函数所需要的参数传递父类。

      例如：父类中只有这个构造函数

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

那么子类中的构造函数应该这样写：

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

7. sealed 关键字：

如果用来修饰class，称为密封类，此类无法被继承；如果用来修饰方法，该方法无法被重写。

如： sealed class Ren{}；

（三）： 多态

1. 概念：父类引用指向不同子类实例的时候，父类引用所调用的函数都是子类的函数，由于子类对象不同，父类引用调用的成员表现出来的不同状态就是一种多态。

2. 实现的方式：多态需要通过继承来实现

3. 分类：分为编译多态（重载overload）和运行多态（重写override）。父类方法被重写了之后也可以在子类中用base.方法 调用。

4. virtual关键字：虚方法，允不允许重写，要重写父类方法必须是虚方法：public virtual void Eat()。

5. 运行多态实现的条件：

（1）子类对父类方法的重写（override），父类和子类中都有相同的方法。

（2）父类引用指向子类实例。

例如，有一个Ren类是父类，一个Chinese类和American是子类，Ren r = new Chinese();父类的引用 r 指向子类实例。

    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("正在用筷子吃饭...");
        }
    }

父类Ren中有个Eat方法为虚方法，在子类Chinese和American中进行了重写，在Main函数中：

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

随机让父类引用 a 指向 不同的子类实例，这样用父类引用 a 调用方法Eat()的时候表现出不同对象的操作。

6. 里氏代换原则和抽象依赖原则

里氏代换原则，如果某个方法接收的是父类引用，可以向里面传父类或其子类的元素，子类对象替代父类对象。

抽象依赖原则，用父类的引用来指向子类的实例。

例子：怪兽吃人，传入Ren的引用 r ，则r.Cry()表现出来不同的结果。

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("天哪，老天爷保佑我！");
        }
    }

在Main函数中 ，先实例出一个怪兽，随机生成一个Ren的对象，将此对象的引用传入怪兽类里，通过这个引用来表现出不同的状态。          

            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类就要用该命名空间点出来再用。