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 (;;) ;
}