面向对象程序设计的三大特征是什么?

面向对象程序设计的三大特征是：

1、封装性

封装是一种信息隐蔽技术，者型它体现于类的说明，是对象的重要特性。封装使数据和加工该数据的方法（函数）封装为一个整体，以实现独立性很强的模块，使得用户只能见到对象的外特性，而对象的内特性对用缓棚户是隐蔽的。封装的目的在于把对象的设计者和对象的使用者分开，使用者不必知晓其行为实现的细节，只须用设计者提供的消息来访问该对象。

2、继承性

继承性是子类共享其父类数据和方法的机制。它由类的派生功能体现。一个类直接继承其他类的全部描述，同时可修改和扩充。继承具有传递性。继承分为单继承和多重继承。类的对象是各自封闭的，如果没继承扰嫌则性机制，则类的对象中的数据、方法就会出现大量重复。继承不仅支持系统的可重用性，而且还促进系统的可扩充性。

3、多态性

对象根据所接收的消息而做出动作。同一消息被不同的对象接受时可产生完全不同的行动，这种现象称为多态性。利用多态性用户可发送一个通用的信息，而将所有的实现细节都留给接受消息的对象自行决定，如是，同一消息即可调用不同的方法。

面向对象三大特性：封装，继承，多态

面向对象（Object Oriented,缩写为OO）是现代软件技术的精髓。从早期的SmallTalk到如日中天的Java，都渗透着面向对象思想。

OO具有三大特性：封装性、继承性和多态性。想掌握面向对象思想，就必须深入理解

其三大特性。这里我尽量少谈概念，只用一个生活中的例子和一段代码来解释它们。

1、封装性(Encapsulation)

所谓封装，就是将某些东西包装和隐藏起来，让外界无法直接使用，只能通过某些特定的方式才能访问。OO将万物都视为“对象”(Object)，任何对象都具有特性和行为。我们将其特性称为“成员变量” (MemberVarible)，将其行为称之为“成员函数"(Member Function)，被封装的特性只能通过特定的行为去访问。

大家都见过旅馆里常用的一种茶叶吧，就是用纸袋把茶叶包装起来再系是一根线。用的时候只需要将其放在水杯里泡就行。这样的好处是不会将茶叶渣和茶垢弄的满杯子都是。

好！这就是一个封让李装的例子。

我们喝茶的目的是享受茶叶的香冽；所以茶叶的味道(Flavour）就是茶叶所具有的最

重要特性之一；可是我们无法直接享受它的清香，因为被外面的纸袋“封装”起来了。唯一的办法就是坦举迟“泡”(Dilute），将茶袋扔在开水中泡，它的味道就出来了，融入水中。

如果我们把袋装茶叶看作一个对象的话，它提供了成员变量Flavour和成员函数Dilute

。并且Flavour是私有(Private）的，我们不能直接把它吞进肚子去，而只能通过成员函

数Dilute才能享受Flavour。

下面用C++代码来描述这个例子：

Class CTea

{

Private:

Cstring m_Flavour//味道

Cstring m_Color //颜色

...... //等等其它属性

Private:

Void CTea() //构造函数

Void ~CTea()//析构函数

Public:

Cstring Dilute（）//沏茶

...... //等等其它方法

}

Cstring CTea::Dilute()

{

//怎样泡出味道来的代码

}

这就是封装。通过将对象的某些属性声明为Private隐藏起来，只能使用其提供的特定

方法去访问。

2、继承(Inheritance)

如果只是封装，那么非面向对象语言也能部分的做到。比如在C中，用结构(Struct)、

VB中用自定义类型（Type）也能封装一些变量。

OO最有吸引力的特性是继承。通俗的说后代具有祖先的某些特点就叫继承，当然后代还可以具有自己独有的特征。举个例子吧，菜刀。

菜刀(cutlery）是钢(Steel)做的，钢是一种金属(Metal)，金属则是大千世界里的一种物质(Substance)。所以菜刀的一些特性可以追溯到物质具有的一般属性。正是因为这个道理，MFC中所有类均从CObject继承而来。

这就答简是继承。菜刀直接继承了钢的特性，钢又继承了金属的特性，......下面的代码描

述了这种复杂而有独特的继承关系：

Class CSubstance

{

Private:

int m_color

void CSubstance()

void ~CSubstance()

//......(我是学文科的，具体属性说不上来）

}

Class CMetal:Public CSubstance

{

void CMetal()

void ~CMetal()

//......

}

Class CSteel:Public CMetal

{

void CSteel()

void ~CSteel()

//......

}

Class CCutlery:Public CSteel

{

private:

Cstring m_Blade

void CCutlery()

void ~CCutlery()

//......

Public:

void Cut()

}

这里，CSubstance被称为基类(Base class)，其它被称为衍生类(Derived class)。衍生类与基类是“Is kind of”的关系。子类与其祖先类之间复杂的函数调用关系不在本文讨论之列。

继承是一种树状的层次关系。子类在继承祖先类的成员变量和成员函数的同时也可以

定义自己的成员变量和成员函数。比如，Metal 除了继承了Substance的一般特性外，还具有自己的属性诸如可延展性；CCutlery在继承CSteel的特性后还具有自己的成员诸如“刀刃”（Blade)、“锋利”（Sharpness)、行为有如“切”（Cut）等。

面向对象技术是对现实生活的抽象，你可以用生活中的经验去思考程序设计的逻辑。

3、多态性(Polymorphism)

讨论多态之前先要明白什么是“虚拟”(Virtual)。C++/MFC就是用虚拟这种方式实现多态的。为什么“虚拟”这个概念？看下边的例子：

Class Cincect //昆虫类

{

private:

int m_foot //脚的数量

...... //其它成员变量

private:

void Cincect()

void ~Cincect()

public:

void Bite()//咬人

{

......//怎样咬人的代码，比如张开嘴啃

}

}

我把Bite(咬）这个动作在基类中定义为一般化动作。可是，不是所有昆虫咬

人的方法都一样（况且还有的根本就不咬人呢，比如蜻蜓），比如蚊子是用嘴那个

吸管叮人而蚂蚁是用嘴去夹。

从昆虫这个类别衍生出以下两个类别：Cant(蚂蚁）、Cmosquito（蚊子）。

class Cant :public Cincect //蚂蚁类

{

......

}

class Cmosquito :public Cincect //蚊子类

{

......

}

它们都继承了Cincect的所有成员，当然也继承了Bite()这个动作。现在就有问题了：

同样继承自昆虫，当我们使用Bite()这个动作时怎么才能区分蚂蚁和蚊子各自的独有的咬人方式呢？

方法之一是用“::”符号指明具体引用的是那一个，但这样明显失去了灵活性；

另一种方法就是“虚拟”。使用关键字virtual将Bite()声明为虚拟函数，然后在每个

衍生类中重新定义，描述它们各自的咬人方法，调用的时候也不会都一种结果啦。于是上边的例子可以改写为：

Class Cincect //昆虫类

{

private:

int m_foot //脚的数量

...... //其它成员变量

private:

void Cincect()

void ~Cincect()

public:

virtual Bite(){}//咬人，但我们只声明这个成员函数，

//却让它什么动作都不做，让衍生类自己去定

//义各自的咬人方法

}

class Cant :public Cincect //蚂蚁类

{

......

virtual Bite()

}

Cant::Bite()

{

...... //蚂蚁具体的咬人方式

}

class Cmosquito :public Cincect //蚊子类

{

......

virtual Bite()

}

Cmosquito::Bite()

{

...... //蚊子具体的咬人方式

}

所以，虚拟的目的是只在基类中将一般化动作声明一个成员函数的原型而不做

具体定义，让衍生类自己去定义。

这就是面向对象的特征之三：多态性。基类的同一个成员在不同的衍生类中可以具

有不同的形态，更好地抽象和描述大千世界中的诸多“对象”。

1.了解什么是多态性

2.如何定义一个虚方法

3.如何重载一个虚方法

4.如何在程序中运用多态性

面向对象程序设计中的另外一个重要概念是多态性。在运行时，可以通过指向基类的指针，来调用实现派生类中的方法。 可以把一组对象放到一个数组中，然后调用它们的方法，在这种场合下，多态性作用就体现出来了，这些对象不必是相同类型的对象。当然，如果它们都继承自某个类，你可以把这些派生类，都放到一个数组中。 如果这些对象都有同名方法，就可以调用每个对象的同名方法。本节课将向你介绍如何完成这些事情。

1.清单9-1. 带有虚方法的基类：DrawingObject.cs

using System

public class DrawingObject

{

public virtual void Draw()

{

Console.WriteLine("I'm just a generic drawing object.")

}

}

说明

清单9-1 定义了DrawingObject类。这是个可以让其他对象继承的基类。该类有一个名为Draw()的方法。Draw()方法带有一个virtual修饰符，该修饰符表明：该基类的派生类可以重载该方法。DrawingObject类的 Draw()方法完成如下事情：输出语句"I'm just a generic drawing object."到控制台。

2.清单9-2. 带有重载方法的派生类：Line.cs, Circle.cs, and Square.cs

using System

public class Line : DrawingObject

{

public override void Draw()

{

Console.WriteLine("I'm a Line.")

}

}

public class Circle : DrawingObject

{

public override void Draw()

{

Console.WriteLine("I'm a Circle.")

}

}

public class Square : DrawingObject

{

public override void Draw()

{

Console.WriteLine("I'm a Square.")

}

}

说明

清单9-2定义了三个类。这三个类都派生自DrawingObject类。每个类都有一个同名Draw()方法，这些Draw()方法中的每一个都有一个重载修饰符。重载修饰符可让该方法在运行时重载其基类的虚方法，实现这个功能的条件是：通过基类类型的指针变量来引用该类。

3.清单9-3. 实现多态性的程序：DrawDemo.cs

using System

public class DrawDemo

{

public static int Main(string[] args)

{

DrawingObject[] dObj = new DrawingObject[4]

dObj[0] = new Line()

dObj[1] = new Circle()

dObj[2] = new Square()

dObj[3] = new DrawingObject()

foreach (DrawingObject drawObj in dObj)

{

drawObj.Draw()

}

return 0

}

}

说明

清单9-3演示了多态性的实现，该程序使用了在清单 9-1 和清单9-2中定义的类。在DrawDemo类中的Main()方法中，创建了一个数组， 数组元素是DrawingObject 类的对象。该数组名为dObj，是由四个DrawingObject类型的对象组成。

接下来， 初始化dObj数组， 由于Line， Circle和Square类都是DrawingObject类的派生类，所以这些类可以作为dObj数组元素的类型。 如果C#没有这种功能，你得为每个类创建一个数组。继承的性质可以让派生对象当作基类成员一样用，这样就节省了编程工作量。

一旦数组初始化之后，接着是执行foreach循环，寻找数组中的每个元素。在每次循环中， dObj 数组的每个元素（对象）调用其Draw()方法。多态性体现在：在运行时，各自调用每个对象的Draw()方法。尽管dObj 数组中的引用对象类型是DrawingObject，这并不影响派生类重载DrawingObject 类的虚方法Draw()。 在dObj 数组中，通过指向DrawingObject 基类的指针来调用派生类中的重载的Draw()方法。

输出结果是：

I'm a Line.

I'm a Circle.

I'm a Square.

I'm just a generic drawing object.

在DrawDemo 程序中，调用了每个派生类的重载的Draw()方法。 最后一行中，执行的是DrawingObject类的虚方法Draw()。这是因为运行到最后，数组的第四个元素是DrawingObject类的对象。

小结

现在对多态性有所了解之后，你可以在派生类中，实现一个重载基类虚方法的方法。虚方法和重载的派生类方法之间的关系就体现出C#的多态性。

封装性、继承性、多态性。

1、封装性：

具备封装性（Encapsulation）的面向对象编程隐藏了某一方法的具体运行步骤，取而代之的是通过消息传递机制发送消息给它。封装是通过限制只有特定类的对象可以访问这一特定类的成员，而它们通常利用接口实现消息的传入传出。

通常来说，成员会依它们的访问权限被分为3种：公有成员、私有成员以及保护成员。有些语言更进一步：Java可以限制同一包内不同类的访问；C#和VB.NET保留了为类的成员聚集准备的关键字：internal（C#）和Friend（VB.NET）；Eiffel语言则可以让用户指定哪个类可以访问所有成员。

具备封装性（Encapsulation）的面向对象程序设计隐藏了某一方法的具体执行步骤，取而代之的是通过消息传递机制传送消息给它。

2、继承性：

继承性是面向对象技术中的另外一个重要特点，其主要指的是两种或者两种以上的类之间的联系与区别。继承，顾名思义，是后者延续前者的某些方面的特点，而在面向对象技术则是指一个对象针对于另一个对象的某些独有的特点、能力进行复制或者延续。

如果按照继承源进行划分，则可以分为单继承（一个对象仅仅从另外一个对象中继承其相应的特点）与多继承（一个对象可以同时从另外两个或者两个以上的对象中继承所需要的特点与能力，并且不会发生冲突等现象）。

如果从继承中包含的内容进行划分，则继承可以分为四类，分别为取代继承（一亩判颂个对象在继承另一个对象的能力与特点之后将父对象进行取代）；

包含继承（一个对象在将另一个对象的能力与特点进行完全的继承之后，又继承了迅郑其他对象所包含的相应内容，结果导致这个对象所具有的能力与特点大于等于父对象，实现了对冲李于父对象的包含）、受限继承、特化继承。

3、多态性：

从宏观的角度来讲，多态性是指在面向对象技术中，当不同的多个对象同时接收到同一个完全相同的消息之后，所表现出来的动作是各不相同的，具有多种形态。

从微观的角度来讲，多态性是指在一组对象的一个类中，面向对象技术可以使用相同的调用方式来对相同的函数名进行调用，即便这若干个具有相同函数名的函数所表示的函数是不同的。

扩展资料：

面向对象编程语言

支持部分或绝大部分面向对象特性的语言即可称为基于对象的或面向对象的语言。Simula (1967)被视为第一个具有面向对象特性的语言。早期，完全面向对象的语言主要包括Smalltalk等语言，目前较为流行的语言中有Java、C#、Eiffel等。

随着软件工业的发展，比较早的面向过程的语言在近些年的发展中也纷纷吸收了许多面向对象的概念，比如C→C++，C→Objective-C，BASIC→Visual Basic→Visual Basic .NET，Pascal→Object Pascal，Ada→Ada95。

“纯粹”的面向对象语言, 因为所有的东西都是由对象所组成，例如：Eiffel,Emerald,JADE,Obix,Ruby,Scala,Smalltalk,Self。

脚本中的OOP

近年来，面向对象的程序设计越来越流行于脚本语言中。Python和Ruby是创建在OOP原理的脚本语言，Perl和PHP亦分别在Perl 5和PHP 4时加入面向对象特性。

---