第6章 面向对象设计

合集下载

第六章 面向对象的设计

第六章  面向对象的设计

处理并发操作
❖ 并发的对象(子系统)
同时 异步 作用于同一事件
❖ 处理
将并发子系统分配到不同处理器 将并发子系统分配到同一处理器
❖系统提供同步控制
描述子系统间的通信
❖ 子系统协作模型
客户/服务器 端对端
客户 子系统
请求
服务器 子系统
peer subsystem
请求 请求
contract
peer subsystem
❖ 追求“聪明”和“技巧”---〉提倡“简明”和“直 接”
消息设计
责任设 计
属性、操作、 协作者
类/对
象 模型
使用 实例
对象关系模型
对象-行为模 型
系统设计过程
⑴ 划分子系统; ⑵ 确定需要并发运行的子系统并为它们分配处理
器; ⑶ 描述子系统之间的通信; ⑷ 确定系统资源的管理和控制; ⑸ 确定人机交互构件;
⑹ 选择实现数据管理和任务管理的基本策略。
四种主要子系统
打印队列
打印服务器
[打印机就绪] 打印文件
打印机
活动图Activity Diagram
Win.printAll()
Disk full
显示磁盘满
Disk free
显示在打印
建立打印文件
^printer.print()
删去显示信息
物理架构建模
❖ 逻辑架构和物理架构
逻辑架构 物理架构
❖ 构件图 ❖ 配置图
学生
姓名:string
学号:string
1

购买 0..* 属于
书名:string 价格:real
对象图Object Diagram
王平:学生

面向对象设计

面向对象设计

面向对象设计面向对象设计是一种软件开发方法,它将现实世界中的事物抽象为对象,并通过定义对象的属性和方法来描述其特征和行为。

面向对象设计的核心思想是将系统组织为一系列相互协作的对象,每个对象都有自己的状态和行为,并且可以通过消息传递来与其他对象进行交互。

面向对象设计具有以下优点:1. 模块性:面向对象设计将系统分解为多个独立的对象,每个对象负责一部分功能。

这种模块化的设计使得系统易于维护和扩展。

2. 可重用性:面向对象设计鼓励通过继承和多态来实现代码的重用。

通过定义通用的父类和子类的特殊化实现,可以在不改变现有代码的情况下添加新功能。

3. 灵活性:面向对象设计可以应对需求的变化。

由于每个对象都相对独立,因此可以更容易地修改或替换单个对象,而不会影响到整个系统。

4. 可理解性:面向对象设计使用自顶向下的抽象思维模型,将现实世界的复杂性抽象为简单的对象和类的关系,使得系统的结构更加清晰可理解。

为了更好地应用面向对象设计,我们需要遵循一些基本原则和模式:1. 单一职责原则(SRP):一个类应该只有一个引起它变化的原因。

每个类都应该有一个清晰而独立的责任范围,这样可以提高代码的可维护性。

2. 开放封闭原则(OCP):软件实体(类、模块、函数等)应该对扩展开放,对修改关闭。

通过利用接口、抽象类和多态,可以在不改变现有代码的情况下添加新功能。

3. 里氏替换原则(LSP):子类对象可以替换父类对象,并且其行为不会改变。

这个原则确保继承关系的正确性,避免了代码的混乱和错误。

4. 接口隔离原则(ISP):客户端不应该依赖于它不需要的接口。

接口应该尽可能小,具体到客户端的需求,避免了不必要的代码依赖。

5. 依赖倒置原则(DIP):高层模块不应该依赖于低层模块,二者都应该依赖于抽象。

抽象类和接口在面向对象设计中起到了关键的作用,通过它们来定义高层模块和低层模块之间的关系。

除了以上原则,还有一些常用的面向对象设计模式,例如单例模式、工厂模式、观察者模式等。

面向对象设计

面向对象设计

面向对象设计面向对象设计(Object-oriented design,简称OOD)是一种软件设计方法,强调将现实世界中的事物抽象成对象并建立对象间的关系来解决问题。

面向对象设计是面向对象编程(OOP)的基础,它通过封装、继承和多态等机制,提供了一种灵活、可扩展和易于维护的软件设计方法。

面向对象设计的基本原则是封装、继承和多态。

封装将数据和操作封装在一个对象中,通过接口暴露对象的行为,隐藏内部实现细节。

继承通过派生新的类扩展或修改现有类的功能,提高代码的复用性和扩展性。

多态通过定义一组相同的接口,不同的对象可以根据自身的类型实现不同的行为,提高代码的灵活性和扩展性。

在面向对象设计中,首先要分析问题,确定问题空间中的对象及其关系。

然后,根据对象的属性和行为,设计对象的类。

类是对象的抽象,包含了对象的属性和方法。

接着,定义对象间的交互方式和协作关系,包括对象之间的消息传递和方法调用。

最后,实现类的具体代码,通过创建对象、调用对象的方法来解决问题。

面向对象设计有许多优点。

首先,它提供了一种自然的方式来描述问题空间,使得软件设计更加直观和易于理解。

其次,面向对象设计具有高内聚、低耦合的特点,可以减少软件的复杂性,提高代码的可维护性和可扩展性。

此外,面向对象设计也能够提高代码的重用性,通过继承和多态的机制,可以更好地复用已有的代码。

然而,面向对象设计也存在一些挑战。

首先,面向对象设计需要进行全局的系统分析和设计,涉及多个对象和类的交互,需要耗费大量的时间和精力。

其次,面向对象设计需要合理地划分对象和类的职责,避免出现职责不清晰和耦合度过高的情况。

最后,面向对象设计需要谨慎地选择继承和多态的使用方式,以避免出现冗余的代码和复杂的继承关系。

综上所述,面向对象设计是一种强调对象和类的关系和交互的软件设计方法,通过封装、继承和多态等机制,提供了一种灵活、可扩展和易于维护的软件设计方法。

面向对象设计能够提高代码的可维护性、可扩展性和重用性,但也需要进行全局的系统分析和设计,并且需要合理地划分职责和选择继承和多态的使用方式。

面向对象设计知识点

面向对象设计知识点

面向对象设计知识点面向对象设计(Object-Oriented Design,简称OOD)是软件工程领域中的重要概念,它是一种以对象为基本构建单元的设计方法。

对象是由数据属性(属性)和操作方法(方法)组成的封装体,通过类的定义来创建对象。

面向对象设计具有灵活、模块化、易维护等优点,被广泛应用于各种软件系统开发场景。

本文将介绍面向对象设计中的一些重要知识点,包括封装、继承、多态和抽象等。

一、封装封装是面向对象设计的核心概念之一,它将数据和行为封装在一个对象内部,对象对外部隐藏了具体的实现细节,只暴露出一组接口供其他对象使用。

封装可以有效地保护对象的数据,提高了代码的可维护性和可重用性。

在封装中,我们需要关注以下几点:1. 数据隐藏:将对象的数据设置为私有(private)属性,通过公有(public)方法来获取和修改数据,确保对象数据的访问受到限制。

2. 隐藏实现细节:对象应该将内部的实现细节隐藏起来,只提供有限的接口给外部使用,这样可以避免外部对对象的依赖,同时也方便后续对实现进行修改和优化。

二、继承继承是面向对象设计中实现代码重用的一种方式。

通过继承,一个类可以继承另一个类的属性和方法,并在此基础上进行扩展或修改。

被继承的类称为父类或基类,继承的类称为子类或派生类。

继承有以下特点:1. 单继承和多继承:单继承表示一个子类只能继承自一个父类,而多继承允许一个子类同时继承自多个父类。

2. 继承关系:子类继承了父类的属性和方法,并可以添加新的属性和方法或覆盖父类的方法。

3. 代码复用:继承可以避免重复编写相同的代码,提高代码的可维护性和可读性。

三、多态多态是面向对象设计的重要特性,它允许子类对象对父类的方法进行不同的实现。

多态性使得我们可以通过父类引用指向不同子类的对象,并根据实际的子类类型来调用相应的方法。

多态性的特点包括:1. 重写(覆盖):子类可以重写父类的方法,实现自己的特定逻辑。

2. 动态绑定:运行时根据对象的实际类型来动态地调用方法,而不是根据引用类型来确定调用哪个方法。

软件工程面向对象设计

软件工程面向对象设计
重构策略与技巧
运用提取方法、移动方法、重命名等重构手法,提高代码质量。
版本控制工具使用
利用Git等版本控制工具管理代码变更,确保团队协作顺畅进行。
测试驱动开发与自动化测试
01
测试驱动开发实践
先编写测试用例,再实现功能代码,以确保代码质量和可测试性。
02
自动化测试框架选择
根据项目需求选择合适的自动化测试框架,如JUnit、TestNG等。
方法(Method)
方法是对象的行为或操作,用于改变对象的状态或与其他对象交互。
封装与继承
封装(Encapsulation)
封装是将对象的属性和方法结合成一个独立的单元,并隐藏内部实现细节。封装提供了安全性和数据 隐藏,只允许通过对象的方法来访问和修改其状态。
继承(Inheritance)
继承是一种允许类继承另一个类的属性和方法的机制。子类(派生类)可以继承父类(基类)的属性 和方法,并可以添加新的属性和方法或覆盖父类的方法。继承实现了代码重用和层次化的类结构。
数据库设计与ORM技术
数据库设计
根据领域模型和业务需求,设计数据库表结构、索引和约束等。
ORM技术
使用对象关系映射(ORM)技术,实现数据库表与程序中的类之 间的映射,简化数据访问操作。
数据库操作优化
针对数据库操作的性能瓶颈,进行优化设计,如使用连接池、缓存 等技术。
界面设计与交互体验优化
界面设计
03
单元测试与集成测试
编写高质量的单元测试和集成测试,提高代码覆盖率,降低缺陷率。
团队协作与敏捷开发方法
编码规范与代码审查
制定统一的编码规范,进行定期的代码审查, 提高代码质量。
任务分解与优先级排序

VFP第6章面向对象的程序设计

VFP第6章面向对象的程序设计

03
Visual FoxPro中的事件 驱动编程
事件驱动编程的概念
事件驱动编程是一种编程范式,它通 过事件来触发程序的执行。在事件驱 动的程序中,事件是由用户操作或其 他系统事件触发的,例如点击按钮、 键盘输入等。
在事件驱动的程序中,程序的状态由 事件和事件处理程序来管理。当某个 事件发生时,相应的事件处理程序会 被调用,以响应该事件。
什么是对象
对象是面向对象程序设计的基本单元,代表了现实世界中的 事物或概念。
对象由属性和方法组成,属性描述对象的状态,方法定义对 象的行为。
对象的属性、方法和事件
属性
描述对象特性的数据元素,如颜色、大小等。
方法
定义在对象上的操作,用于实现特定的功能 或行为。
事件
由用户或系统触发,导致对象状态改变或执 行特定操作。
根据项目需求选择合适的数据访问方式,如直接访问数据 库、使用ORM框架等。
01
数据流控制
设计合适的数据流控制结构,如顺序、 循环、条件等,实现数据的处理和流转。
02
03
数据验证
对输入数据进行验证,确保数据的合 法性和准确性。
THANKS FOR WATCHING
感谢您的观看
为控件编写事件处理程序,以响应用户的操 作或系统事件。
调用方法
通过调用控件的方法来执行特定的操作,如 显示或隐藏控件。
05
面向对象程序设计在 Visual FoxPro中的应用
数据库应用程序的设计
数据库模型选择
根据项目需求选择合适的数据库模型,如关系 型、层次型或网络型。
数据结构设计
定义数据库中的表、字段、主键、外键等,以 及表之间的关系。
事件处理程序

面向对象的设计

面向对象的设计
总结词
多态是指同一消息可以被不同的对象接收并 产生不同的结果。
详细描述
多态是面向对象编程的三大特性之一,它使 得程序具有更好的扩展性和灵活性。在多态 中,父类引用指向子类对象,通过父类引用 来调用子类的方法,实现了动态绑定。例如 ,一个父类类型的变量可以引用多种子类的 对象,当调用该变量上的方法时,会根据实
THANK YOU
感谢各位观看
பைடு நூலகம்
际引用的对象类型来决定执行哪个方法。
03
面向对象设计的应用场景
游戏开发
游戏开发中面向对象设计的应用场景非常广泛,例如角色、场景、物品等都可以作为对象进行设计。 通过面向对象的方法,可以将游戏中的各个元素抽象为对象,并定义其属性和行为,从而实现更加灵 活和可维护的游戏开发。
游戏中的角色可以抽象为具有生命值、攻击力、防御力等属性的对象,场景可以抽象为具有地图、障 碍物、资源等属性的对象,物品可以抽象为具有属性、效果等属性的对象。通过面向对象的设计,可 以更加方便地实现游戏逻辑和交互功能,提高游戏开发的效率和可维护性。
接口
定义了一组方法,没有实现细节,实现类需要提供具体实现 。
代码复用和重构
代码复用
通过继承、接口、组合等方式实现代 码复用,避免重复代码。
重构
对代码进行修改和调整,以提高可读 性、可维护性和可扩展性。
05
面向对象设计的挑战与解决方案
大规模系统的设计
总结词
在设计和实现大规模系统时,需要关注系统的可扩展性和模块化。
• 应用场景:在企业级软件开发中,面向对象的设计方法可以帮助开发者更好地 理解和组织复杂的业务需求,提高软件的质量和稳定性。例如,在财务管理软 件中,可以抽象出“凭证”、“账目”等对象,使得软件更加符合实际业务需 求。

Python程序设计-清华大学出版社-董付国第6章 面向对象程序设计

Python程序设计-清华大学出版社-董付国第6章 面向对象程序设计

6.1 类的定义与使用
>>> class A: def __init__(self, value1 = 0, value2 = 0): self._value1 = value1 self.__value2 = value2 def setValue(self, value1, value2): self._value1 = value1 self.__value2 = value2 def show(self): print self._value1 print self.value2 >>> a = A() >>> a._value1 0 >>> a._A__value2 0
6.1 类的定义与使用
属性有两种,一种是实例属性,另一种是类属性。实例属 性是在伪构造函数__init__中定义的,定义时以self作为前 缀;类属性是在类中方法之外定义的属性。在主程序中 (在类的的外部),实例属性属于实例(对象)只能通过对 象名访问;类属性属于类可通过类名访问。 在类的方法中可以调用类的其它方法,可以访问类属性、 对象属性。 类和对象都可以动态地增加成员
6.3.2 Python3.x中的属性
>>> class Test: def show(self): print(self.value) print(self.__v) >>> t = Test() >>> t.show() 出错信息 AttributeError: 'Test' object has no attribute 'value' >>> t.value = 3 >>> t.show() 3 出错信息 AttributeError: 'Test' object has no attribute '_Test__v' >>> t.__v = 5 >>> t.show() 3 出错信息 AttributeError: 'Test' object has no attribute '_Test__v' >>> t._Test__v = 5 >>> t.show() 3 5

第6面向对象开发的分析与设计

第6面向对象开发的分析与设计

• 2)数据模型和数据库设计
• 数据模型的设计需要确定类—对象属性的 内容、消息连接的方式、系统访问、数据 模型的方法等。最后每个对象实例的数据 都必须落实到面向对象的库结构模型中。
• 3)优化 • OOD的优化设计过程是从另一个角度对分析结果
和处理业务过程的整理归纳,优化包括对象和结 构的优化、抽象、集成。 • 对象和结构的模块化表示OOD提供了一种范式, 这种范式支持对类和结构的模块化。这种模块符 合一般模块化所要求的所有特点,如信息隐蔽性 好,内部聚合度强和模块之间耦合度弱等。
• 2)继承
• 继承是面向对象技术能够提高软件开发效率的重 要原因之一,其定义是:特殊类的对象拥有其一 般类的全部属性与服务,称作特殊类对一般类的 继承。
• 继承分为单继承(一个子类只有一个父类)和多 重继承(一个类有多个父类)。类的对象是各自 封闭的,如果没继承性机制,则类的对象中数据、 方法就会出现大量重复。继承不仅支持系统的可 重用性,而且还促进系统的可扩充性。
• 通过类比,发现对象间的相似性,这就是 构成对象类的依据。在“类”、“父类”、 “子类”的概念构成对象类的层次关系时, 若不加特殊说明,则处在下一层次的对象 可自然地继承位于上一层次的对象的属性。
• 3.通过定义一组“操作”来说明该对象的 功能
• 对象间的相互联系是通过传递“消息”来 完成的,消息就是通知对象去完成一个允 许作用于该对象的操作,至于该对象将如 何完成这个操作的细节,则是封装在相应 的对象类的定义中的,细节对于外界是隐 蔽的。
• 3)多态性 • 同一消息为不同的对象接受时可产生完全不同的
行动,这种现象称为多态性。利用多态性用户可 发送一个通用的信息,而将所有的实现细节都留 给接受消息的对象自行决定,因此,同一消息即 可调用不同的方法。多态性的实现受到继承性的 支持,利用类继承的层次关系,把具有通用功能 的协议存放在类层次中尽可能高的地方,而将实 现这一功能的不同方法置于较低层次,这样,在 这些低层次上生成的对象就能给通用消息以不同 的响应。在面向对象编程语言中可通过在派生类 中重定义基类函数(定义为重载函数或虚函数) 来实现多态性。

C++面向对象程序设计第六章课后习题答案(第2版—谭浩强)

C++面向对象程序设计第六章课后习题答案(第2版—谭浩强)

第六章课后习题答案(第二版谭浩强)1://xt6—1/cpp#include <iostream> //如用VC++应改为∶#include 〈iosttram。

h>using namespace std;//如用VC++应取消此行#include "cylinder.h"#include ”point。

cpp”#include ”circle。

cpp”#include "cylinder。

cpp”int main(){Cylinder cy1(3。

5,6。

4,5.2,10);cout<<"\noriginal cylinder:\nx="<<cy1。

getX()<〈”,y=”〈<cy1。

getY()〈〈",r=”〈〈cy1。

getRadius()<<”, h=”<<cy1。

getHeight()<<"\narea="<<cy1.area()〈〈",volume="<〈cy1.volume()〈〈endl;cy1.setHeight(15);cy1。

setRadius(7.5);cy1.setPoint(5,5);cout<〈"\nnew cylinder:\n"〈〈cy1;Point &pRef=cy1;cout〈〈"\npRef as a point:"〈〈pRef;Circle &cRef=cy1;cout〈<"\ncRef as a Circle:”<〈cRef;return 0;}3:解法一#include <iostream>using namespace std;class Point{public:Point(float a,float b):x(a),y(b){}~Point(){cout〈<"executing Point destructor”〈<endl;}private:float x;float y;};class Circle:public Point{public:Circle(float a,float b,float r):Point(a,b),radius(r){}~Circle(){cout〈〈"executing Circle destructor"<〈endl;}private:float radius;};int main(){Point *p=new Circle(2。

面向对象设计主要内容

面向对象设计主要内容

• 通常用一个名词给代表对象的类命名。一个类代表一个实 体,根据类可以建立程序所需要的任意多个实例。
• 类识别时候还要处理一个问题: 是将某一事物表示为一个 对象还是另一个对象的基本属性。
• 6.2.2 类职责的分派
• 类职责的分派是软件设计工作的一部分,每个类代表一个 具有某些行为的对象,对象的行为由这个类的方法定义。
5-7
• 6.4 类间关系 • 类之间最基本的关系是:依赖、聚合和继承。
• 6.4.1 依赖关系 • 类之间的依赖关系通常体现在一个类的方法调用另一个类
的一个方法。 • 一般而言,如果类A使用类B,则在类A中由一个或者多个
方法调用类B中一个或者多个方法。如果被调用的方法是 静态方法,则类A只需要通过类名引用B,如果被调用的方 法是非静态的,则A必须通过访问类B的实例来调用该方法。 • 一个对象获得对另一个类的对象访问控制的方式,是软件 设计中的重要决策。
面向对象设计主要内容
13
• 一个类也可以实现多个接口,在这种情况下,这个类应提 供所有接口种所有方法的实现代码。
• 使用implements字句声明一个类实现多个接口,接口名 用逗号分隔开。
class ManyThings implements interface1,interface2,interface3
{ =name;
this.acctNumber = acctNumber;
this.balance = balance;
}
面向对象设计主要内容
11
• 6.5 接口
• 接口表示一组公共的方法,通过这组方法可以与一个对象 交互。
• 一个Java接口是一组常量和抽象方法的集合。
• 抽象方法是没有实现的方法,即对于抽象方法没有已定义 的实现代码,包含参数列表的方法声明头后面仅跟这一个 分号。

面向对象设计

面向对象设计

面向对象设计面向对象程序由对象组成,对象包括数据和对数据进行操作的过程(通常称为方法)。

面向对象设计最困难的部分是将系统分解成对象集合。

因为要考虑许多因素:封装、粒度、依赖关系、灵活性、性能、扩展、复用等等,并且这些因素通常还是互相冲突的。

那么科学地对实体进行分解,合理地设计类与类、对象与对象之间的依赖关系的是至关重要的。

1. 面向对象七大设计原则•单一职责原则:设计目单一的类;•开闭原则(OCP):对扩展开放(对提供方),对修改封闭(对使用方)。

用抽象构建框架,用实现扩展细节。

o当软件需要变化时,尽量通过扩展来实现,而不是通过修改原有的方法。

•里氏替换原则:子类可以对父类进行扩展,但不能改变父类原有功能;o子类尽可能不重写父类的非抽象方法,继承实际是让两个类的耦合性增强了。

运用里氏替换原则可以将父类设计为抽象方法或者接口,让子类继承父类或实现接口,并实现父类中的抽象方法,尽量不要重写父类的非抽象方法。

•依赖倒置原则:要依赖于抽象,而不是具体的实现;针对接口编程;o依赖倒置的三种方式:构造器、接口、set方法;•接口隔离原则:使用多个专门的接口比使用单一的总接口要好;(接口的单一职责,尽量使用最小接口)o即接口的定义要尽量实现单一职责,子类不应实现自己不需要的方法。

同时也要注意接口的粒度,接口不能过小,过小会导致接口泛滥,不利于代码维护。

•组合重用原则:要尽量使用组合/聚合,而不是继承来达到重用的目的;•迪米特法则(最少知识法则):一个对象应当对其他对象尽可能少的了解;2. 设计模式(一)设计模式的基本概念设计模式:是对软件设计中普遍存在的(反复出现)的问题,所提出的解决方案。

主要关注软件系统的设计,与具体实现语言无关;•架构模式:软件设计中的高层决策(如C/S架构就属于架构模式);•惯用法:与语言相关,是最底层的模式,关注软件系统的设计与实现,实现时通过特定的编程语言来描述构件与构件之间的关系。

第6 章 面向对象的软件设计PPT课件

第6 章 面向对象的软件设计PPT课件

第6 章 面向对象的软件设计
(7)效率 (8)持久保存对象 (9)参数化类 (10)开发环境 2.面向对象语言的选择 (1)可复用性 (2)类库和开发环境 (3)其他因素
第6 章 面向对象的软件设计
6.4.2 程序设计风格 1.提高可重用性 (1)提高方法的内聚 (2)减小方法的规模 (3)保持方法的一致性 (4)把策略与实现分开 (5)全面覆盖
第6 章 面向对象的软件设计
举例:
第6 章 面向对象的软件设计
6.3 详细设计
6.3.1 系统详细设计 1.细化和重组类 2.增加遗漏的属性,指定属性的类型和可见性 3.分配职责,定义执行每个职责的方法 通用职责分配软件模式 : (1)专家模式:应该将职责分配给信息专家 (2)创建者模式:如果类A和类B满足下列条件中的一个,
第6 章 面向对象的软件设计
2.详细设计 (1)细化、补充类的属性和操作 (2)设计类操作的实现算法 (3)优化数据访问路径 (4)实现外部交互式的控制 (5)调整类结构,增加继承性 (6)设计类之间的关联的实现方式 (7)确定对象属性的精确表示 (8)把类和关联打包归纳到模块中
第6 章 面向对象的软件设计
(6) 尽量不使用全局信息 (7)利用继承机制
第6 章 面向对象的软件设计
2.提高可扩充性 (1)封装实现策略 (2)不要用一个方法遍历多条关联链 (3)避免使用多分支语句 (4)精心确定公有方法 3.提高健壮性 (1)预防用户的操作错误 (2)检查参数的合法性 (3)不要预先确定限制条件 (4)先测试后优化
只和该子系统中的其他类协作; ✓ 子系统的数量不宜太多; ✓ 可以在子系统内部再次划分,以降低复杂度。
第6 章 面向对象的软件设计
6.2.2 物理体系结构建模 用构件图和部署图来描述系统的物理体系结构 1.构件图 构件图就是描述构件类及其它们之间的关系。 (1)构件间的依赖关系:主要是依赖关系,用
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
println(String s) println(int i) println(double d) … 分析System.out.println(“Number of students: ”+count);
25
本章内容
6.1 软件开发活动 6.2 识别类和对象 6.3 静态类成员 6.4 类间关系 6.5 接口 6.6 枚举类型 6.7 方法设计 6.8 方法重载 6.9 测试 *6.10 GUI设计
2、类职责的分派
对识别出来的类,指定属性和方法。
5
本章内容
6.1 软件开发活动 6.2 识别类和对象 6.3 静态类成员 6.4 类间关系 6.5 接口 6.6 枚举类型 6.7 方法设计 6.8 方法重载 6.9 测试 *6.10 GUI设计
6
6.3 静态类成员
1、静态变量(类变量)
private static int count=0; 只能是成员变量,可以由所有的类实例共享。对于类的所有对象 只存在一个静态变量实体,因此在一个对象中改变静态变量的值 将直接影响其他所有对象。(注意和实例变量的区别) 用final声明的常量经常用static修饰符。
2、静态方法(类方法)
可以通过类名来引用,因此调用类方法不必实例化类的对象。 为了使解释器执行main方法时,不用实例化含main方法的类, Java的main方法必须用static修饰。 Main方法只能访问静态变量或局部变量。
7
6.3 静态类成员
例6.1 SloganCounter
toString() 是Object的基本方法 ,若你定义了一个 类 myclass 如果你直接输出System.out.println(myclass); 这句话实际上是System.out.println(myclass.toString()) ; 这是系统默认的...
3
本章内容
6.1 软件开发活动 6.2 识别类和对象 6.3 静态类成员 6.4 类间关系 6.5 接口 6.6 枚举类型 6.7 方法设计 6.8 方法重载 6.9 测试 *6.10 GUI设计
4
6.2 识别类和对象
1、类的识别
找出需求中的实体对象,并能够针对问题,确定出对 解决问题有关的类。
26
6.9 测试
测试时针对不同的输入数据运行已完成编码的程序并发现 程序问题的活动。此外测试还包含评价工作,即由人或机 器所完成的,对改进系统质量的评估。这些评估工作应当 在编写代码前很早就开始进行。 测试的目标是发现错误。人们通常依靠测试来确定和评价 程序的质量 回归测试:确定一个错误后,在确定引起错误的原因并修 改错误,当错误导致的问题解决后,应当重新运行从前的 测试,确保修改错误的过程中没有产生新的错误。
接口中还可以定义常量,当一个类实现了一个接 口时,这个类就获得了对该接口定义的所有常量 的访问权限
16
6.5 接口
<<interface>> Complexty +getComplexity():int +setComplexty(int):void
MiniQuiz
+main(args:String[]):void
27
6.9 测试
1、审查
一种用于评价设计和代码的技术称为审查
2、缺陷测试
测试的目的是发现错误,故常称为缺陷测试 测试方案,测试用例 测试方法:白盒测试和黑盒测试
28
1黑盒测试:
又称功能测试、数据驱动测试,其测试用例完全是根 据程序的功能说明来设计。用数据驱动,比较实际结 果与预期结果的异同。 考虑:一两位数加法器可设计多少测试用例? 常见的黑盒测试用例设计方法:等价类划分、边界值、 因果图、判定表、错误猜测、失败与通过测试、随机 测试。
22
6.7 方法设计
2、 方法参数的传递方法
在Java中,所有参数以传值的方式传递,即调用方法 是实际参数的当前值将复制给方法声明头的形参。 参数传递实质上类似一条赋值语句,将实参保存值的 副本赋给形参。所有形参只是实参的一个副本,所以 对形参的任何修改都不会影响实参。 若将一个对象传递给一个方法,传过去的是对象的引 用,此时形参名和实参名互为对方的别名。此时若通 过调用方法内的形参引用而改变了对象的状态,同时 也就改变了由实参引用的对象。另外,若改变的是形 参本身,则不会影响实参。 例6.15ParameterTester.Java,例6.16,6.17
2 X2
测试数据 预期结果
4
29
2白盒测试
又称结构测试、逻辑测试、透明盒测试,它是基于程 序内部的逻辑结构和执行路径来进行测试用例的设计。 常见的白盒测试用例设计方法:逻辑覆盖测试(语句 覆盖、判定覆盖、条件覆盖…)、循环覆盖测试、基 本路径覆盖测试
2、Iterator接口
大多数的迭代器是利用Iterator接口定义,处理集合中 的所有元素。它提供了在对象集合中每操作一次移动 到下一个对象的方法。 主要方法:hasNext和next,还有个remove方法,该方 法无参数,返回类型为void,它删除最近一次由next方 法返回的对象。
18
本章内容
6.1 软件开发活动 6.2 识别类和对象 6.3 静态类成员 6.4 类间关系 6.5 接口 6.6 枚举类型 6.7 方法设计 6.8 方法重载 6.9 测试 *6.10 GUI设计
19
6.6 枚举型类
一种特殊的类,枚举型的值是枚举类型的实例
Enum Season {winter,spring,summer,fall} Season time; 这里time是一个对象引用变量,它的取值只能是Season类列出的枚 举值。所有的枚举值实际上是Season对象的引用,并且作为 public static 属性的变量保存在Season类中,因此可以对变量 time赋值如下: time=Season.fall;
23
本章内容
6.1 软件开发活动 6.2 识别类和对象 6.3 静态类成员 6.4 类间关系 6.5 接口 6.6 枚举类型 6.7 方法设计 6.8 方法重载 6.9 测试 *6.10 GUI设计
24
6.8 方法重载
在Java中及其他一些面向对象的语言中,可以使 用具有不同参数表的相同方法名调用多个方法, 这种技术称为方法重载。 在Java中,只要参数个数,参数类型和/或参数的 顺序不同,就可以将一个方法名用于多个方法。
Question
MiniQuiz程序的UML类图
+getQuestion():String +getAnswer():String +answerCorrect(String):boolean +toString():String
17
6.5 接口
1、Comparable接口
包含于ng中,接口中有 int compareTo(object) 一个方法。 该接口目的是提供对两个对象进行比较的通用机制。 String类里有个compareTo(),可见String类实现了 Comparable接口。
9
6.4 类间关系(依赖、聚合、继承) 类间关系(依赖、聚合、继承)
1依赖
建立类间的使用关系 一个类的方法调用另一个类的方法 一个类的对象作为另一个类中方法的参数 类的依赖关系强度越小越好
2同一个类的对象之间的依赖性
某些情况下一个类依赖于本身,例 str3=str1.concat(str2) 例6.3RationalTester.java(有理数测试器) 例6.4RationalNumber.java
第6章 面向对象设计 章
本章内容
6.1 软件开发活动 6.2 识别类和对象 6.3 静态类成员 6.4 类间关系 6.5 接口 6.6 枚举类型 6.7 方法设计 6.8 方法重载 6.9 测试 *6.10 GUI设计
2
6.1 软件开发活动
一个软件项目应包含下述4个基本的开发过程:
建立软件需求:明确软件的功能和性能要求 软件设计(概要设计、详细设计) 实现软件设计(编码) 软件测试:针对需求,保证软件能解决预定的问题。
例6.2 Slogan.java
静态变量 count 静态方法getCount(),作为静态方法,只能引用静态变 量。
8
本章内容
6.1 软件开发活动 6.2 识别类和对象 6.3 静态类成员 6.4 类间关系 6.5 接口 6.6 枚举类型 6.7 方法设计 6.8 方法重载 6.9 测试 *6.10 GUI设计
11
6.4 类间关系(依赖、聚合、继承) 类间关系(依赖、聚合、继承)
StudentBody Student -firstName:String -lastName:String -homeAddress:Address -schoolAddress:Address +toString():String
+main(args:String[]):void
表示聚合关系etAddress:String -city:String -state:String -zipCode:long +toString():String
12
6.4 类间关系(依赖、聚合、继承) 类间关系(依赖、聚合、继承)
4、this引用
是Java程序的一个特殊引用,允许对象引用自己,可 用于引用当前正在运行的对象。 This引用也常用于区分同名的构造方法参数和实例变量
13
本章内容
6.1 软件开发活动 6.2 识别类和对象 6.3 静态类成员 6.4 类间关系 6.5 接口 6.6 枚举类型 6.7 方法设计 6.8 方法重载 6.9 测试 *6.10 GUI设计
21
6.7 方法设计
1、方法分解
可以将对象提供的一个复杂服务分解为由多个 private 方法支持的简单服务。 例2.13 PigLatin.java 例6.14 PigLatinTranslator.java str.indexof(char);//返回指定字符在此字符串中第一次 出现的索引,若没有找到返回-1. 当一个方法比较庞大或复杂时,就应该考虑将这个方 法分解为多个方法,以建立一个可以理解好的类结构 设计。
相关文档
最新文档