C#中的面向对象编程

所有的面向对象语言都具有3个基本特征，C#也是不例外的。

封装---把客观事物封装成类，并将类内部的实现隐藏，以保证数据的完整性；
继承---通过继承可以复用父类的对象；
多态---允许将子对象赋值给扶对象的一种能力。

1、封装

封装指的是把类内部的数据隐藏起来，不让对象实例直接对其操作。在C#中，封装可以通过public private protected和internal等关键字来体现。

C#对保护内部数据状态提供了一种方式，叫做属性机制。

public class Person
{
private string _name;
private int _age;

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

public int Age
{
get{return _age;}
set
{
//在属性定义中，可以根据系统的业务逻辑添加逻辑代码
if(value<0 || value>120)
{
throw(new ArgumentOutOfRangeException("AgeIntProperty",value,"年龄必须在0-120之间"))；
}
_age=value;
}
}
}

2、继承

在C#中，一个类可以继承另外一个已有的类，子类会获得基类除构造函数和析构函数以外的所有成员。同时静态类和密封类是不能被继承的。

C#与C++不一样，只支持单继承。

//基类

public class Animal

{

　　private int _age;

　　public int Age

　　{

　　　　get{return _age;}

　　　　set

　　　　{

　　　　　　 if(value<0 || value>10)
　　 {
　　 throw(new ArgumentOutOfRangeException("AgeIntProperty",value,"年龄必须在0-10之间"));
　　 }
　　　_age=value;

　　　　}

//子类(马)

public class Horse:Animal

{}

//子类（羊）

public class Sheep:Animal

{}

有一点需要注意：子类并不能对父类的私有成员进行直接访问，它只可对保护成员和公有成员进行访问。

私有成员也会被子类继承，但子类不能直接访问私有成员，子类可以通过调用公有或保护方法来间接地对私有成员进行访问。

2.1 密封类

public sealed class SealedClass

{

　　//在这里定义类成员

}

//密封类不能作为其他类的基类，下面代码编译时会出错

public class Test :SealedClass

{}

2.2 子类的初始化顺序

当我们初始化一个子类时，除了会调用子类的构造函数外，同时也会调用基类的构造函数。子类的初始化顺序如下：

（1）初始化类的实例字段；

（2）调用基类的构造函数，如果没有指明基类，则调用System.Object的构造函数；

（3）调用子类的构造函数。

下面就通过一个实例来说明：

//父类

public class Parent

{

　　//②调用基类的构造函数

　　public Parent()

　　{

　　　　Console.WriteLine("基类的构造函数被调用了");

　　}

//子类

public class ChildA:Parent

{

　　//创建一个ChildA对象时

　　//①初始化它的实例字段

　　private int FieldA=3;

　　//③调用子类构造函数

　　public ChildA()

　　{

　　　　Console.WriteLine("子类的构造函数被调用");

　　}

　　public void Print()

　　{

　　　　Console.WriteLine(FieldA);

　　}

class Program

{

　　static void Main(string[] args)

　　{

　　　　ChildA childa=new ChildA();

　　}

3、多态

多态的定义：即相同类型的对象调用相同的方法却表现出不同行为的现象。

3.1 使用virtual和override关键字实现方法重写

只有基类成员声明为virtual或abstract时，才能被派生类重写；而如果子类想改变虚方法的实现行为，则必须使用override关键字。

public class Animal

{

　　private int _age;

　　public int Age

　　{

　　　　get{return _age;}

　　　　set

　　　　{

　　　　　　if(value<0 || value>10)

　　　　　　{

　　　　　　　　 throw(new ArgumentOutOfRangeException("AgeIntProperty",value,"年龄必须在0-10之间"));

　　　　　　}

　　//几乎所有动物都具有发出声音的能力

　　//但是对于动物来说，每种动物发出的声音是不一样的

　　public virtual void Voice()

　　{

　　　　Console.WriteLine("动物开始发出声音");

　　}

//马（子类）,子类应重写基类的方法，以实现自己特有的行为

public class Horse:Animal

{

　　//通过override关键字来重写父类方法

　　public override void Voice()

　　{

　　　　Console.WriteLine("马叫");

　　}

//羊（子类）

public class Sheep:Animal

{

　　//通过override关键字来重写父类方法

　　public override void Voice()

　　{

　　　　Console.WriteLine("羊叫");

　　}

class Program

{

　　static void Main(string[] args)

　　{

　　　　Animal horse=new Horse();//把子类对象赋给父类变量

　　　　horse.Voice();

　　　　Animal horse=new Horse();//把子类对象赋给父类变量

　　　　horse.Voice();

　　　　Console.ReadKey();

　　}

如果在子类中还要访问父类中虚的方法，就必须要用base关键字来完成调用。base.Voice();

对于上面那种情况，建议把Animal类设置成抽象类，采用abstract关键字来防止在代码中直接创建这样类的实例。

3.2 阻止派生类重写虚成员

public class Horse:Animal

{

　　//采用sealed关键字，Horse就不能再扩展Voice方法了

　　public sealed override void Voice()

　　{

　　　　//调用基类方法

　　　　base.Voice();

　　　　Console.WriteLine("马叫");

　　}

3.3 使用新成员隐藏基类成员

可以在子类中采用new的关键字来隐藏父类成员

public class Horse:Animal

{

　　public new void Voice()

　　{

　　　　......

　　}

采用这样的形式，如果要调用父类的方法，只能把对象强制转换成父类类型。

4、所有类的父类

在C#中，所有的类都派生自System.Object类，底下是Object类的一些成员：

public class Object

{

　　//方法

　　//构造函数

　　public Object();

　　//虚成员，子类可以重写这些方法

　　public virtual bool Equals(object obj);

　　protected virtual void Finalize();

　　public virtual int GetHashCode();

　　public virtual string ToString();

　　//实例成员

　　public Type GetType();

　　public object MemberwiseClone();

　　//静态成员

　　public static bool Equals(object objA,object objB);

　　public static bool ReferenceEquals(object objA,object objB);

}

小结：此篇文章讲的是C#在面向对象方面的一些基本知识点，如果能把这3个特性搞熟透的话，在做项目的时候，你的思路就会比较多了。

巴特西

C#中的面向对象编程

最新文章

热门文章