C#面向对象

C#面向对象概念

 

一、面向对象的概念：

以接近现实的处理手法来处理项目中的设计。一个例子：

请描述一下森林中一只狮子捕食一只兔子的场景。

 

用结构化编程实现	用面向对象方式实现
strut Lion { int lId; string name; } strut Rubbit{ int 1Id; string name; } 定义函数： void lionRunning(Lion); void lionCatch(Lion,Rubbit) void lionEating(Lion,Rubbit ) void lionHappy(Lion); void rubbitCrying(Rubbit) void rubbitRunning(Rubbit) bool rubbitIsDead(Rubbit);	Class Lion {  int lIdl string name; public void Running(){}; public void Catch(Rubbit); public void Eating(Rubbit); public void Happy(); } class Rubbit { int rId; string name; public void Running() public void Crying() public bool Isdead() }
主程序： Lion fatty; Rubbit may; lionRunning(fatty); rubbitRunning(may); lionCatch(fatty,may); rubbitCrying(may); lionEating(fatty,may); if (rubbitIsDead(may))    lionHappy(fatty);	主程序 Lion fatty=new Lion(); Rubbit may = new Rubbit(); Fatty.Running(); May.Running(); Fatty.Catch(may); May.Crying(); Fatty.Eating(may); If (may.IsDead())    Fatty.Happy();

 

1．从左边的设计，我们看出代码是一系列的函数构成，有以下几点：

不直观，程序的组织性不强，函数调用时不容易确定具体调用哪一个

要传的参数太多

       2．右边代码，看起来要好一些，函数的参数少，而且都被组织到类的内部，要调用函数时只要确定是哪一个对象要调用，就很容易找到，从程序调用来进右边的主程序更接近现实世界的处理方式

 

二、面向对象的特点

1．  封装

从上表右边看来，函数代码写在类的内部，只能被类的对象所调用，别人不可随便访问，这样可以保护你的代码，而且函数与对象相关，方便调用

2．  继承

从代码重用方面，我们可以把共性的特征，和行为抽象出来，比如，程序的需求要我们实现所有的食肉动物都能捕食食草类动物，对于上表左边程序，我们要全面修改代码，而对于右边的程序我们可做如下抽象：

Class Carnivore

{

int aId;

string name;

public void running()

public void Catching(Vegetarian)

public void Eating(Vegetarian);

public void Happy();

}

class Vegetarian

{

int aId;

string name;

public void running()

public void crying()

public bool Isdead()

}

然后，我们使用继承 class Lion : Carnivore

Class Rubbit : Vegetarian

这样，我们不用构造两个类，就能使用它们公共的特征和函数了

这样一来，我们可以完成所有食肉动物与食草动物的捕食关系了

如果，我们要实现老虎捕食猎物，那也很容易了，

我们只要定义下面代码：

Class Tigger : Carnivore

就可以了

3．  多态

从上面的继承中我们可以看出，实现一个新的类是那么容易，

但大家想一个问题，老虎与狮子，毕竟不是一种动物，那们的方法不可能完全相同，针对不同的子类，它的方法也不可能相同。比如它们的happy方法可能是这样的

public void happy()

{

Console.WriteLine(“我高兴，所以我发出虎啸”);  //如果是狮子，就可能发出的是狮吼

}

这个问题我们放在下一课中祥细讨论

三、面向对象设计程序的作用

1．  重用代码

2．  可维护性高

3．  可插入性（这个特点与多态相关，下次课重点讲述）

意为：程序不需修改或少做修改，就可实现用户提出的新的问题

如上面

4．  直观,更接近现实

5．  方便调用

四、综合

 对象是什么

从概念层面讲，对象是某种拥有责任的抽象。（职能）

从规格层面讲，对象是一系列可以被其他对象使用的公共接口。（对象交互）

从语言实现层面来看，对象封装了代码和数据。（数据和程序）

 

一、接口

1．  接口的概念及作用

一个例子：一台电脑上的主板和光驱，其实对主板来说，光驱只要是符合它所要求的规格就可以了，具体是哪种光驱，并不重要，它都能兼容。如果我更换一个光驱，没有必要连主板也换。

当我们需要一个新的对象时，我们首先考虑，能否定义一个和原有对象功能一致的对象（兼容），而不是修改原有对象，或者做一个全新的对象

再如：一个数据库系统中对数据的SIUD操作，我们应该如何设计呢，假设我们的系统是不能确定具体的数据库，或者用户要求变更到新的数据库时，那我们是否要重新设计整个数据访问层及与其相关的调用呢？

我们定义一个接口：

interface IDataAccess

{

public bool insert(Item)

public bool delete(string id)

public bool update(Item)

public List getData();

public Item getDataById(string id);

}

如果我们使用Sqlserver

我们就定义一个类实现上述接口

class SqlDataAcess : IDataAcess

{

// 具体的sqlServer的操作

}

而在上层程序调用时我们可以简单的使用如下形式调用

Item item= new Item();

IDataAcess da = new SqlDataAccess(); //此处如果应用反射可从配置文件中直接初始化对象，而不需如此硬编码

//IDataAcess da = DataAccessFactory.createInstance(Configration.getDataType);

Da.insert(item);

 

现在如果要更换成Oracle，大家想应该如何做了

class OracleDataAcess : IDataAcess

{

// 具体的OracleServer的操作

}

再把配置文件中的DataType改为Oracle就行了，整个系统不用更改其它代码

如下图：

 

2．  接口的特性

为了应对可变化的需求，应该针对接口编程，而非针对具体类编程

针对完成相同功能的程序，要提供一致的程序接口，方便程序的即插即用

代码的实现是在具体类中，而非接口中，接口只声明程序的功能，并不实现

二、抽象类

与接口类似，但它可以包含属性，也可实现方法

 

三、面向对象设计原则

1．单一职责原则（SRP）：

一个类应该仅有一个引起它变化的原因。

2．开放封闭原则（OCP）：

类模块应该是可扩展的，但是不可修改（对扩展开放，对更改封闭）

3．Liskov 替换原则（LSP）:

子类必须能够替换它们的基类

4．依赖倒置原则（DIP）：

高层模块不应该依赖于低层模块，二者都应该依赖于抽象。

抽象不应该依赖于实现细节，实现细节应该依赖于抽象。

5．接口隔离原则（ISP）：

不应该强迫客户程序依赖于它们不用的方法。

四、设计模式与多态应用

多态的应用很广泛，有很多模式都用到它。如：工厂方法，策略，模板模式等

所谓设计模式：是指前人的一种编程经验。

上面的数据库系统的例子就是应用到工厂方法模式

一个产品接口：IDataAccess             实现一致的数据操作

两个具体实现类：SqlDataAccess和OracleDataAccess　　分别是具体数据库访问的实现

一个工厂类：DataAccessFactory 作用为针对不同的配置，生成不同的DataAccess

示例演示(演员表演节目项目)

用到的模式:工厂方法

多态的应用