面向方法编程

⑴ 如何学习面向对象编程

尽管我们都是从OOP发展而来，事实上，真正的面向对象来自于OOD。没有OOD的过程，就无法真正的面向对象。
书上那些小例子只不过是在展示“如何OOP”的手段，也就是在告诉大家“面向对象的语言有哪些特点”，而并没有回答“什么是面向对象”以及“为什么要面向对象”。
事实上，这种小程序永远也不能体现出“为什么要面向对象”。面向对象与传统的面向功能与面向数据的开发相比，最大的优势在于业务逻辑的可重用性。传统的开发最容易重用的是数据结构和底层代码，而上面的调用代码则很难重用，而面向对象则专注于如何另维护了业务逻辑的调用代码更容易地被其它项目或是后继项目使用。
同时，面向对象的开发也有利于提高可移植性。我前面说过，传统的开发成果越是底层的代码可重用性就越高，但如果牵涉到大量OS相关的内容时——比如GUI，则越是底层的调用就越难以移植，这就形成了一个矛盾。而面向对象的方法解决了调用代码的可重用性，也就顺带提高了代码的可移植性。

⑵ 面向方面编程的比较

为了说明更实用的使用 AOP 的方法，我们将创建一个应用程序，从名为 ContactService.Service 的 Web 服务接收 people对象的集合。在 .NET 开发中使用 Web 服务的最常见方法是调用返回 XML 的 Web 服务，该服务通过框架自动反序列化为一个对象。这些对象仅包含数据而不包含任何行为。在 .NET Framework 2.0 中，通过使用 partial 关键字并创建行为，能够对这些自动代码生成的对象添加功能。但是在一些 Web 服务或代理对象之间重用某个特定行为时仍然存在一个问题。如前所述，多数情况下，共享的公共行为将包含在一个抽象类中，其他所有类从该类继承。但是，我们不能使 Web 服务对象继承功能。借此良机，通过这个问题说明 AOP 功能如何强大。
我们的应用程序用于显示联系人信息。最初它的用途是显示信息，但是需要添加某些行为。为了查看代码示例，我们需要创建一个称为 TheAgileDeveloper.ContactService 的虚拟目录。该目录必须指向 TheAgileDeveloper.ContactService 项目在本地计算机上的位置。
注 通过 http://localhost/TheAgileDeveloper.ContactService 可以访问此项目，这一点很重要。
图 1. 应用程序屏幕快照。
应用程序有一个视图，它是一个名为 MainForm 的 WinForm，用于显示左侧 ListView 中 Web 服务返回的联系人对象。选定一个联系人时，名字、姓氏和 Web 页将显示在右侧的文本框中。载入 MainForm 时，它调用 ServiceManager 类来获取联系人信息。下列 ServiceManager 类乍看起来似乎没有添加任何值，只不过在窗体和 Web 服务之间添加了另一层。但是，它的价值就在于提供了一个在 Web 服务中添加新功能的位置，而不用重复代码。另一个优点是，它将 Web 服务的“足迹”抽象出来，并从整个应用程序中移除出去。
Public Class ServiceManager
Public Shared Function GetAllContacts() As ContactService.Contact()
Dim service As ContactService.Service = New ContactService.Service
Dim contacts() As ContactService.Contact = service.GetAllContacts
Return contacts
End Function
Public Shared Sub SaveContact(ByVal contact As ContactService.Contact)
Dim service As ContactService.Service = New ContactService.Service
service.SaveContact(contact)
End Sub
End Class
请查看 TheAgileDeveloper.Client 项目中的 Reference.vb 文件。它是在导入 ContactService 的 Web 引用时通过 wsdl.exe 创建的。它从 WSDL 自动生成以下 Contact 类。
'<remarks/>
<System.Xml.Serialization.XmlTypeAttribute(_
[Namespace]:=http://。。。。。/TheAgileDeveloper.ContactService/Service1 _ )> _
Public Class Contact
'<remarks/>
Public Id As Integer
'<remarks/>
Public FirstName As String
'<remarks/>
Public LastName As String
'<remarks/>
Public WebSite As String
End Class
注意，Contact对象只处理数据，而且我们不想以任何方式编辑该代码，因为 wsdl.exe 会为我们自动生成，所以下一次生成时更改将丢失。我想引入行为，这样就能够通过调用名为 Save 的方法保存对象，这很容易通过一个混入 来完成。混入 是多继承的翻版，只是它有局限性，例如只能混入接口实现。我们使用的 Encase 框架包含一个 Encaser 类，它负责接收并包装一个对象。包装对象的行为实际上意味着创建新的对象，在本例中就是新的 Contact 对象，它包含配置的混入和切点。
为了创建允许在 Contact对象上调用 Save 方法的混入，需要指定一个接口，我称之为 ISavable。实际混入对象的就是 ISavable 接口。我们需要在另一个称为 ContactSave 的新类中实现该接口。
Public Interface ISaveable
Sub Save()
End Interface
Public Class ContactSave
Implements ISavable
Public Contact As ContactService.Contact
Public Sub Save() Implements ISavable.Save
ServiceManager.SaveContact(Me.Contact)
End Sub
End Class
在我们的应用程序中，混入 Contact对象中 ContactSave 实现的适当位置是 ServiceManager。我们能够混入这个行为，但是不更改任何客户端代码（即，MainForm），因为应用混入后，结合 Contact 和 ContactSave 的新 Contact对象仍然保持为最初的 Contact 类型。以下代码是经过更改的 ServiceManager 的 GetAllContacts 方法，它处理混入行为。
Public Shared Function GetAllContacts() As ContactService.Contact()
Dim service As ContactService.Service = New ContactService.Service
Dim contacts() As ContactService.Contact = service.GetAllContacts
'//Wrap each contact object
For i As Integer = 0 To contacts.Length-1
'//Create a new instance of the
'//encaser responsible for wrapping our object
Dim encaser As encaser = New encaser
'//Add mixin instance of ContactSave
Dim saver As ContactSave = New ContactSave
encaser.AddMixin(saver)
'//Creates a new object with
'//Contact and ContactSave implementations
Dim wrappedObject As Object = encaser.Wrap(contacts(i))
'//Assign our new wrapped contact object
'//to the previous contact object
contacts(i) = DirectCast(wrappedObject, _
ContactService.Contact)
'//Notice the wrapped object is still the same type
'//Assign the new wrapped Contact object to
'//target field of the ContactSave mixed in
saver.Target = contacts(i)
Next
Return contacts
End Function

⑶ 什么是面向对象的编程方法

面向对象编程（Object
Oriented
Programming，OOP，面向对象程序设计）是一种计算机编程架构。OOP
的一条基本原则是专计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP
达到了软件工程的三个主要目标：重用性、灵活性和扩展属性。为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息。

⑷ 什么是面向过程编程，什么是面型对象编程

面向过程编程就是分析待解决的问题所涉及的步骤，然后通过函数来逐一把每一步骤实现。它是以事件（问题）为中心的。代表语言有C……
其实质是按照计算机处理问题的过程来进行程序设计：输入——操作——输出。这样设计者需要变更思维的习惯来完成涉及工作。面向过程程序设计所具有的流的工作性质，试图通过信息流及其转换来认识系统，不仅加大了程序设计的难度，亦使得程序的可理解性比较差。这种程序设计思维同样为软件的后期维护升级或是修改留下了较大的麻烦——可复用性差。
面向过程程序设计方法一种普遍采用的优化方法是自上而下的程序设计思路。要求设计开始就得全面系统了解整个工程的架构。
面向对象程序设计将问题抽象成为若干对象组成。当然，建立对象目的是为了叙述某个对象在问题中的行为，而不是针对问题的某一具体步骤。代表语言：Java、C++……特点：继承、封装、多态。
为了更好地理解，下面引用别人的一个例子：
五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用分别的函数来实现，问题就解决了。而面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为 1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的i变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。 可以明显地看出，面向对象是以功能来划分问题，而不是步骤。同样是绘制棋局，这样的行为在面向过程的设计中分散在了总多步骤中，很可能出现不同的绘制版本，因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中，绘图只可能在棋盘对象中出现，从而保证了绘图的统一。 功能上的统一保证了面向对象设计的可扩展性。比如我要加入悔棋的功能，如果要改动面向过程的设计，那么从输入到判断到显示这一连串的步骤都要改动，甚至步骤之间的循序都要进行大规模调整。如果是面向对象的话，只用改动棋盘对象就行了，棋盘系统保存了黑白双方的棋谱，简单回溯就可以了，而显示和规则判断则不用顾及，同时整个对对象功能的调用顺序都没有变化，改动只是局部的。 再比如我要把这个五子棋游戏改为围棋游戏，如果你是面向过程设计，那么五子棋的规则就分布在了你的程序的每一个角落，要改动还不如重写。但是如果你当初就是面向对象的设计，那么你只用改动规则对象就可以了，五子棋和围棋的区别不就是规则吗？（当然棋盘大小好像也不一样，但是你会觉得这是一个难题吗？直接在棋盘对象中进行一番小改动就可以了。）而下棋的大致步骤从面向对象的角度来看没有任何变化。 当然，要达到改动只是局部的需要设计的人有足够的经验，使用对象不能保证你的程序就是面向对象，初学者或者很蹩脚的程序员很可能以面向对象之虚而行面向过程之实，这样设计出来的所谓面向对象的程序很难有良好的可移植性和可扩展性。

⑸ 编程作业：利用面向对象的方法编程实现如下结果输出

/**
* @author Administrator
* 方法一
*/
public class Dog {
public Dog() {
// TODO Auto-generated constructor stub
}
public void meetMaster() {
// TODO Auto-generated method stub
System.out.println("听主人的命令");
}
public void meetEnemy() {
// TODO Auto-generated method stub
System.out.println("狂叫，并冲上去狠咬");
}
public void meetFriend() {
// TODO Auto-generated method stub
System.out.println("晃动尾巴，表示欢迎");
}
public void meetFellow() {
// TODO Auto-generated method stub
System.out.println("嬉戏打闹");
}
}
public class Main {
public static void main(String[] args) {
/**
* @author Administrator
* 方法一
*/
Dog dog = new Dog();
dog.meetMaster();
dog.meetEnemy();
dog.meetFriend();
dog.meetFellow();
}
}

/**

* 方法二
*/
public interface DogHabitInterface {
public void action();
}
public class DogMeetMaster implements DogHabitInterface{

@Override
public void action() {
// TODO Auto-generated method stub
System.out.println("听主人的命令");
}

}
public class DogMeetEnemy implements DogHabitInterface{

@Override
public void action() {
// TODO Auto-generated method stub
System.out.println("狂叫，并冲上去狠咬");
}

}
public class DogMeetFriend implements DogHabitInterface{

@Override
public void action() {
// TODO Auto-generated method stub
System.out.println("晃动尾巴，表示欢迎");
}

}
public class DogMeetFellow implements DogHabitInterface{

@Override
public void action() {
// TODO Auto-generated method stub
System.out.println("嬉戏打闹");
}

}
public class Main {
public static void main(String[] args) {

/**
* 方法二
*/
action(new DogMeetMaster());
action(new DogMeetEnemy());
action(new DogMeetFriend());
action(new DogMeetFellow());
}
static void action(DogHabitInterface dog){
dog.action();
}
}

⑹ 什么叫面向对象编程

面向对象编程是一本书的名字，也是一门课程，上几课就知道了。

⑺ 什么是面向对象为什么要用面向对象的方法来编程

面向对象分析属于软件开发过程中的问题定义阶段，其目标是清晰、精确地定义问题领域。传统的系统分析产生一组面向过程的文档，定义目标系统的功能;面向对象分析则产生一种描述系统功能和问题领域的基本特征的综合文档。 原则 面向对象分析的主要原则如下。 1.抽象 从许多事物中舍弃个别的、非本质的特征，抽取共同的、本质性的特征，就叫做抽象。抽象是形成概念的必须手段。 抽象原则有两方面的意义：第一，尽管问题域中的事物是很复杂的，但是分析员并不需要了解和描述它们的一切，只需要分析研究其中与系统目标有关的事物及其本质性特征。第二，通过舍弃个体事物在细节上的差异，抽取其共同特征而得到一批事物的抽象概念。 抽象是面向对象方法中使用最为广泛的原则。抽象原则包括过程抽象和数据抽象两个方面。过程抽象是指，任何一个完成确定功能的操作序列，其使用者都可以把它看做一个单一的实体，尽管实际上它可能是由一系列更低级的操作完成的。数据抽象是指根据施加于数据之上的操作来定义数据类型，并限定数据的值只能由这些操作来修改和观察。数据抽象是面向对象分析的核心原则。它强调把数据(属性)和操作(服务)结合为一个不可分的系统单位(即对象)，对象的外部只需要知道它做什么，而不必知道它如何做。 2.封装 封装就是把对象的属性和服务结合为一个不可分的系统单位，并尽可能隐蔽对象的内部细节。 3.继承 特殊类的对象拥有的其一般类的全部属性与服务，称作特殊类对一般类的继承。 在面向对象分析中运用继承原则，就是在每个由一般类和特殊类形成的一般—特殊结构中，把一般类的对象实例和所有特殊类的对象实例都共同具有的属性和服务，一次性地在一般类中进行显式定义。在特殊类中不再重复地定义一般类中已定义的东西，但是在语义上，特殊类却自动地、隐含地拥有它的一般类(以及所有更上层的一般类)中定义的全部属性和服务。继承原则的好处是：使系统模型比较简练也比较清晰。 4.分类 就是把具有相同属性和服务的对象划分为一类，用类作为这些对象的抽象描述。分类原则实际上是抽象原则运用于对象描述时的一种表现形式。 5.聚合 聚合的原则是：把一个复杂的事物看成若干比较简单的事物的组装体，从而简化对复杂事物的描述。 6.关联 关联是人类思考问题时经常运用的思想方法：通过一个事物联想到另外的事物。能使人发生联想的原因是事物之间确实存在着某些联系。 7.消息通信 这一原则要求对象之间只能通过消息进行通信，而不允许在对象之外直接地存取对象内部的属性。通过消息进行通信是由于封装原则而引起的。在OOA中要求用消息连接表示出对象之间的动态联系。 8.粒度控制 一般来讲，人在面对一个复杂的问题域时，不可能在同一时刻既能纵观全局，又能洞察秋毫。因此需要控制自己的视野：考虑全局时，注意其大的组成部分，暂时不详察每一部分的具体的细节;考虑某部分的细节时则暂时撇开其余的部分。这就是粒度控制原则。 9.行为分析 现实世界中事物的行为是复杂的。由大量的事物所构成的问题域中各种行为往往相互依赖、相互交织。 阶段 面向对象分析过程可分为问题领域分析和应用分析两个阶段。 问题领域分析是软件开发的基本组成部分，目的是使开发人员了解问题领域的结构，建立大致的系统实现环境。问题领域分析给出一组抽象概念(从高层来表示问题领域知识，常常超出当前应用的范围)作为特定系统需求开发的参考。问题领域分析实际上是一种学习过程。软件开发人员在这个阶段应该尽可能地理解当前系统中与应用有关的知识，应该放开思维，放宽考虑的范围，尽可能地标识与应用有关的概念。问题领域分析的边界可能很模糊。有了广泛的问题领域知识，涉及到具体的应用时，就可以更快地进入状态，掌握应用的核心知识。而且，在用户改变对目标系统的需求时，广泛的分析可以帮助我们预测出目标系统在哪些方面会发生哪些变化。通常进行小组分析，小组成员可以包括领域专家和分析员等。在分析过程中，应该标识出系统的基本概念(对象、类、方法、关系等)、识别问题领域的特征，并把这些概念集成到问题领域的模型中。问题领域的模型必须包含概念之间的关系，以及每个概念的全部信息。标识出来的相关概念应该根据信息内容来有机地融合到问题领域的综合视图中。 应用分析是依据在问题领域分析时建立起来的问题领域模型来进行的。应用分析时，把问题领域模型用于当前特定的应用之中。首先，通过收集到的用户信息来对问题领域进行取舍，把用户需求作为限制条件来使用，以缩减问题领域的信息量。因此，问题领域分析的视野大小直接影响到应用分析保留的信息量。一般来说，问题领域分析阶段产生的模型并不需要用程序设计语言来表示，而应用分析阶段产生的影响条件则需要用某种程序设计语言来表示。模型识别的要求可以针对一个应用，也可以针对多个应用。通常我们着重考虑两个方面，即应用视图和类视图。在类视图中，必须对每个类的属性和操作进行细化，并表示出类之间的相互作用关系。 目标 Coad和Yourdon 认为，面向对象分析主要应该考虑与特定应用有关的对象，以及对象之间在结构和相互作用上的关系。在面向对象分析中，需要建立分析模型来描述系统的功能。 面向对象分析需要完成如下两个任务： — 形式化地说明所面对的应用问题，最终成为软件系统基本构成的对象，以及系统所必须遵从的、由应用环境所决定的规则和约束条件。 — 明确地规定构成系统的对象如何协同工作和完成指定的功能。 通过面向对象分析所建立的系统模型是以概念为中心的，因此称为概念模型。概念模型由一组相关的类组成。面向对象分析可以通过自顶向下地逐层分解来建立系统模型，也可以自底向上地从已经定义的类出发，逐步构造新的类。概念模型的构造和评审由如下5个层次构成： — 类和对象层 — 属性层 — 服务层 — 结构层 — 主题层 这5个层次不是构成软件系统的层次，而是分析过程中的层次。也可以说是问题的不同侧面。每个层次的工作都为系统的规格说明增加了一个组成部分。当5个层次的工作全部完成时，面向对象分析的任务也就完成了。 在实际操作中，面向对象分析的目标是得出问题领域的功能模型、对象模型和动态模型，并用相应的UML图将它们表示出来。 步骤 面向对象分析通常按照下面的步骤来进行： (1)标识对象和类。可以从应用领域开始，逐步确定形成整个应用的基础类和对象。这一步需要分析领域中目标系统的责任，调查系统的环境，从而确定对系统有用的类和对象。 (2)标识结构。典型的结构有两种，即一般—特殊结构和整体—部分结构。一般—特殊结构表示一般类是基类，特殊类是派生类。比如，汽车是轿车和卡车的基类，这是一种一般—特殊结构。整体部分结构表示聚合，由属于不同类的成员聚合成为新的类。比如，轮子、车体和汽车底盘都是汽车的一部分，这些不同功能的部件聚合成为汽车这个整体。 (3)标识属性。对象所保存的信息称为它的属性。类的属性描述状态信息，在类的某个实例中，属性的值表示该对象的状态值。需要找出每个对象在目标系统中所需要的属性，并将属性安排在适当的位置，找出实例连接，最后再进行检查。应该给出每个属性的名字和描述，并指定该属性所受的特殊限制(如只读、属性值限定在某个范围之内等)。 (4)标识服务。对象收到消息后执行的操作称为对象提供的服务。它描述了系统需要执行的处理和功能。定义服务的目的是为了定义对象的行为和对象之间的通信。其具体步骤包括： — 标识对象状态 — 标识必要的服务 — 标识消息连接 — 描述服务 可以用类似于流图的图形来表示服务。 (5)标识主题。为了更好地理解包含大量类和对象的概念模型，需要标识主题，即对模型进行划分，给出模型的整体框架，划分出层次结构。可以按照如下步骤来标识主题。 — 识别主题 — 对主题进行改进和细化 — 将主题加入到分析模型 主题是一个与应用相关的概念，而不是人为任意引出来的，主题层的工作有助于理解分析的结果。 优点 面向对象分析的主要有点有： (1)加强了对问题域和系统责任的理解; (2)改进与分析有关的各类人员之间的交流; (3)对需求的变化具有较强的适应性; (4)支持软件复用; (5)贯穿软件生命周期全过程的一致性; (6)实用性; (7)有利于用户参与.......

⑻ 什么是面向对象编程方法

面向对象的程序设计(Object-Oriented Programming，简记为OOP)立意于创建软件重用代码，具备更好地模拟现实世界环境的能力，这使它被公认为是自上而下编程的优胜者。它通过给程序中加入扩展语句，把函数“封装”进编程所必需的“对象”中。面向对象的编程语言使得复杂的工作条理清晰、编写容易。说它是一场革命，不是对对象本身而言，而是对它们处理工作的能力而言。对象并不与传统程序设计和编程方法兼容，只是部分面向对象反而会使情形更糟。除非整个开发环境都是面向对象的，否则对象产生的好处还没有带来的麻烦多。

⑼ 用面向对象的方法编写程序,求梯形面积

#include<iostream>
using namespace std;
class Ts{
public:
int up,low,h;
S()
{
double sum;
sum=(up+low)*h/2;
cout<<"梯形面积:"<<sum;
}
};
int main()
{
Ts s;//创建一个对象
cin>>s.up;//上底
cin>>s.low;//下底
cin>>s.h;//高
s.S();
return 0;
}

⑽ 面向对象、面向接口、面向方法编程的区别

其实不论是面向接口还是面向对象还是面向方面编程，只是设计模式的一种体现，用最简单的话来解释就是：

----------------------------------------------------------------------------

面向对象编程就是一堆对象，通过封装、继承、多态等更加有效的组织程序。
面向接口编程就是一堆接口，通过接口规约对象的属性和方法，是面向对象一部分。

来源：(http://blog.sina.com.cn/s/blog_5396eb530100fkla.html) - 关于面向接口、面向对象、面向方面编程的比较区别_simoniu_新浪博客
面向方面编程把业务的主逻辑和次逻辑分开的一种思想。

面向对象不好解释，可以理解为以一切元素都是对象，在设计时以对象为单位，考虑它的属性及方法。设计中采用了封装、继承、抽象的手法
面向接口本身就是面向对象的，无所谓区别，只不过面向接口的好处是耦合性低
面向方面Aspect-Oriented Programming (AOP)就是大名鼎鼎的AOP。其实有点象struts里的拦截器。
举例：假设有在一个应用系统中，有一个共享的数据必须被并发同时访问，首先，将这个数据封装在数据对象中，称为Data Class，同时，将有多个访问类，专门用于在同一时刻访问这同一个数据对象。
为了完成上述并发访问同一资源的功能，需要引入锁Lock的概念，也就是说，某个时刻，当有一个访问类访问这个数据对象时，这个数据对象必须上锁Locked，用完后就立即解锁unLocked，再供其它访问类访问。 这种加锁与解锁的操作可以使用拦截器来实现。而拦截器本身就是面向方面编程的一个具体应用。