面向程序设计方法的主要特征(面向对象程序设计语言主要有哪些技术特点)

程序设计 102
本篇文章给大家谈谈面向程序设计方法的主要特征,以及面向对象程序设计语言主要有哪些技术特点对应的知识点,希望对各位有所帮助,不要忘了收藏本站喔。 本文目录一览: 1、面向对象程序设计有哪些基本特征?

本篇文章给大家谈谈面向程序设计方法的主要特征,以及面向对象程序设计语言主要有哪些技术特点对应的知识点,希望对各位有所帮助,不要忘了收藏本站喔。

本文目录一览:

面向对象程序设计有哪些基本特征?

【回答】

面向对象程序设计有4个主要特点,分别是:抽象、封装、继承、多态。以下是具体解释;

一、抽象和封装

类和对象体现了抽象和封装

抽象就是解释类与对象之间关系的词。类与对象之间的关系就是抽象的关系。一句话来说明:类是对象的抽象,而对象则是类得特例,即类的具体表现形式。

封装两个方面的含义:一是将有关数据和操作代码封装在对象当中,形成一个基本单位,各个对象之间相对独立互不干扰。二是将对象中某些属性和操作私有化,已达到数据和操作信息隐蔽,有利于数据安全,防止无关人员修改。把一部分或全部属性和部分功能(函数)对外界屏蔽,就是从外界(类的大括号之外)看不到,不可知,这就是封装的意义。

二、继承

面向对象的继承是为了软件重用,简单理解就是代码复用,把重复使用的代码精简掉的一种手段。如何精简,当一个类中已经有了相应的属性和操作的代码,而另一个类当中也需要写重复的代码,那么就用继承方法,把前面的类当成父类,后面的类当成子类,子类继承父类,理所当然。就用一个关键字extends就完成了代码的复用。

三、多态

没有继承就没有多态,继承是多态的前提。虽然继承自同一父类,但是相应的操作却各不相同,这叫多态。由继承而产生的不同的派生类,其对象对同一消息会做出不同的响应。

【拓展回答】

一、面向对象程序设计概念

面向对象程序设计(Object Oriented Programming)作为一种新方法,其本质是以建立模型体现出来的抽象思维过程和面向对象的方法。模型是用来反映现实世界中事物特征的。任何一个模型都不可能反映客观事物的一切具体特征,只能对事物特征和变化规律的一种抽象,且在它所涉及的范围内更普遍、更集中、更深刻地描述客体的特征。通过建立模型而达到的抽象是人们对客体认识的深化。

类当中有两个方面,一是封装属性,二是封装函数。在自己声明的类当中要既有属性又有函数,这就是类。

其实结构体的声明当中有很多不同数据类型的成员,在一个结构体当中,这就是对属性的封装,但是结构体与类相比较,还缺少了一个重要的环节,结构体当中只有属性,只封装了属性,但没有封装相应的操作,也就是没有封装操作成员属性的函数。

在结构体中声明一个结构体就相当于我们设计了一个类,定义一个结构体就相当于我们定义了一个对象,定义给两个结构体,相当于我们定义了两个对象。初始化结构体,相当于对象的初始化。

客观世界中任何一个事物都可以看成一个对象(Object),任何一个对象都有两个要素:一个是静态特征,这种静态特征称为属性。  一个是动态特征,这种动态特征称为行为(或功能)。

二、面向对象程序设计架构特点

面向对象设计方法以对象为基础,利用特定的软件工具直接完成从对象客体的描述到软件结构之间的转换。这是面向对象设计方法最主要的特点和成就。面向对象设计方法的应用解决了传统结构化开发方法中客观世界描述工具与软件结构的不一致性问题,缩短了开发周期,解决了从分析和设计到软件模块结构之间多次转换映射的繁杂过程,是一种很有发展前途的系统开发方法。

但是同原型方法一样, 面向对象设计方法需要一定的软件基础支持才可以应用,另外在大型的MIS开发中如果不经自顶向下的整体划分,而是一开始就自底向上的采用面向对象设计方法开发系统,同样也会造成系统结构不合理、各部分关系失调等问题。所以面向对象设计方法和结构化方法仍是两种在系统开发领域相互依存的、不可替代的方法。

【参考资料】

百度百科——面向对象程序设计

面向对象程序设计的特点

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

面向对象程序设计的三大特征是多态(Polymorphism)、继承(Inheritance)、封装(Encapsulation)。

1、多态

多态核心的思想就是,父类的引用能够指向子类的对象,或者接口类型的引用能够指向实现该接口的类的实例。多态会这样的原因是因为子类就是父类。

2、继承

Java是单继承的,这一点和C++有所不同,这也就意味着,一个类只能继承于一个类,被继承的类叫父类,或者是叫基类baseclass,继承的类叫子类。

Java当中的继承使用关键字extends。可是,一个类能够实现多个接口,多个接口之间用逗号进行分割。实现接口使用关键字implements。

3、封装(Encapsulation)

封装比较的简单,类包含了方法和数据,将方法和数据放在一个类当中,就构成了封装。封装的优点:将变化隔离,便于使用,提高重用性,提高安全性;封装的缺点:将变量等使用private修饰,或者封装进方法内,使其不能直接被访问,增加了访问步骤与难度!

面向对象程序设计的六大基本原则:

1、单一职责原则

不要存在多于一个导致类变更的原因,即一个类只承担一个职责。

2、开放-封闭原则

对扩展开放,对修改封闭。无论模块多么封闭,都会存在一些无法对之封闭的变化,既然不能完全封闭,我们必须对于自己设计的模块应该对哪种变化封闭做出选择,必须先猜测出最有可能发生的变化种类,然后构造抽象来隔离这些变化。

3、迪米特原则

一个对象应该对其他对象有最少的了解,减少类与类之间的耦合。如果两个类不必彼此通信,那么这两个类就不应当发生直接的相互作用。类与类之间的耦合越弱,越有利于复用,一个处于弱耦合的类被修改,不会对有关系的类造成波及。

4、依赖倒转原则

上层模块不要依赖底层模块,它们都要依赖于抽象。抽象不能依赖于细节,细节要依赖于抽象。面向接口编程,不要面向实现编程。

5、里氏替换原则

子类型必须能够替换掉它们的父类型。只有当子类可以替换掉父类,软件单位的功能不受影响时,父类才能真正的被复用,而子类也能够在父类的基础上增加新的行为。

6、接口隔离原则

客户端不应该依赖于它不需要的接口,一个类对一个类的依赖应该建立在最小的接口上。不要让与自己无关的修改影响到自己功能模块的变化。

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

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

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时加入面向对象特性。

面向对象程序设计的基本特征?

面向对象三大特性:封装,继承,多态

面向对象(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#的多态性。

关于面向程序设计方法的主要特征和面向对象程序设计语言主要有哪些技术特点的介绍到此就结束了,不知道你从中找到你需要的信息了吗 ?如果你还想了解更多这方面的信息,记得收藏关注本站。

扫码二维码