C#面向对象

面向对象一些名词：

类：一个带有接口集合，是面向对象的实现方法

字段：类内所声明的内部变量。

属性：对字段当从外部使用get；set；方法去设置或者读取时，即可视为属性

方法：类内函数

构造函数/析构函数：类必有方法，对所以类成员的初始化都放在构造函数里，所有成员的内存释放都放在析构函数，构造函数与类同名，析构函数位（~类名）

静态成员：静态成员的生命周期是整个程序，因此可作为全局变量在类之间传递

静态构造函数：用来初始化静态成员，不可调用，使用静态成员时自动调用，只调用一次

静态类：只包含静态成员，全局只初始化一次，不能实例化，直接作为已经实例化对象调用就行，可用于类之间的传值

 

问:为何要new一个对象？

因为所有的声明后的类必须先初始化，初始化就要调用构造函数，new关键是就是调用构造函数的一种方式。

 

接口

接口：为何相当于抽象基类，接口只能包含方法、属性、索引器定义，没有实现代码，不能实例化。

使用接口：需要先在某一个类中继承接口，实现接口的所有方法，这样接口起到一个管理类与类之间连接问题，达到低耦合的目的。

public interface OneInterface//定义接口
        {void Hello();//方法
            string Name//属性
            {get;
             set; }
            string this[int index]//索引器
            {get;
             set; }
        }

 public string Name {    //实现接口
           private string[] arr = new string[10];
            private string name;
          public  void Hello()    //实现方法
            {Console.Write("hello!");}
 public string Name {    //实现属性
                get {return name; }
                set {name = value;}
     }
            public string this[int index] {  //实现索引器
                get  {return arr[index];}
                set {arr[index] = value;}
            }
        }

 static void Main(string[] args)
        {
            OneInterface example = new OneClass();
            example.Name = "jack";
            example[0] = "  arr[0]";
            example[1] = "  arr[1]";
            example.Hello();
      Console.WriteLine(example.Name+example[0]+example[1]);//输出Hello Jack  arr[0]  arr[1]
            for (;;) ;
        }

继承

继承：继承是指用在父类（基类）的基础上创造子类，子类可以添加重写方法

抽象类：abstract修饰，不包含实现代码的类，只能用于继承，不能实例化

使用接口：需要先在某一个类中继承接口，实现接口的所有方法，这样接口起到一个管理类与类之间连接问题，达到低耦合的目的。

密封类：sealed修饰，防止派生，禁止子类继承。

虚拟成员：virtual修饰，子类如果对父类使用override重写，父类会被覆盖。

抽象方法：abstract修饰，必须在派生类重写

隐藏方法：new修饰，类内隐藏，子类父类同名函数互不相干

多态：多态是指同类型东西的多种状态，多态通过重载、继承、重写、抽象、虚方法实现。

 

安全性：pubic<protect<private

继承重写方法时子类安全性不能低于父类。

 

多态实现

public  class FatherClass {
    public virtual void ao() {    
    //父类方法作为虚函数
                Console.Write("ao");}
        }
    class ChildClass1: FatherClass{
            public new void ao() {        
     //隐藏方法，子类父类互不相干
                Console.Write("bo");}
        }
       class ChildClass2 : FatherClass  {
            public override void ao() {    
    //对父类方法进行重写，覆盖父类方法
                Console.Write("bo"); }
        }
        static void Main(string[] args) {
            FatherClass Class1 = new ChildClass1();
            Class1.ao();      //输出ao     不能实现多态
            FatherClass Class2 = new ChildClass2();
            Class2.ao();    //输出bo   实现多态
            for (;;) ;
        }

另一种方法：

 public abstract class FatherClass {
            public abstract void ao();    
    //抽象方法，子类必须重写
        }
    public class ChildClass1: FatherClass{
            public override void ao() {    //重写方法类
                Console.Write("bo");
            }
          
        }
        static void Main(string[] args) {
            FatherClass Class1 = new ChildClass1();
            Class1.ao();    //输出bo 实现多态
            for (;;) ;
        }