没有合适的资源？快使用搜索试试~ 我知道了~

首页《Head First OOA&D》：面向实践者的软件设计入门指南

《Head First OOA&D》：面向实践者的软件设计入门指南

5星 · 超过95%的资源需积分: 22 118 下载量 161 浏览量更新于2024-07-18 收藏 22.35MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

试读

636页

"Head First Object-Oriented Analysis & Design（简称HFOOAD）是一本针对面向对象分析与设计（Object-Oriented Analysis & Design, OOA & D）领域的开创性著作。这本书以其独特的方法和视角在众多同类书籍中脱颖而出。它的核心理念是注重学习实践，而不是仅仅理论讲解。作者们深刻理解到，未来的软件开发趋势将更加倾向于实践者的实际操作能力。 Ivar Jacobson, Ivar Jacobson Consulting的创始人，高度评价了这本书，他认为市面上许多关于OOA & D的书籍虽然能解释原理，但往往缺乏让开发者真正开始项目的能力。HFOOAD则不同，它强调内容的实用性，旨在帮助读者快速掌握UML（统一建模语言）和用例分析等核心概念，并深入讲解如何进行优秀软件设计。作者通过清晰、易懂的方式，引导读者理解为什么进行OOA & D，其目标是为了写出高质量的软件。书中不仅涵盖了对象导向分析的基本步骤，还着重探讨了如何通过每个阶段的设计决策推动实现编写出色软件的目标。这对于即使是经验丰富的Java程序员来说，也是一本能够启发他们理解OOA & D重要性的入门佳作。因此，HFOOAD不仅适合初学者，也是任何希望提升设计技能的软件工程师的理想选择。阅读这本书，读者不仅能获得扎实的OOA & D技术知识，还能学会如何将这些理论应用到实际项目中，从而提高软件开发的效率和质量。对于软件工程教育和职业发展来说，这是一本不可多得的实用指南。"

资源详情

资源推荐

xiv

table of contents

5 (part 1)

Nothing Ever Stays the Same

Change is inevitable. No matter how much you like your software right

now, it’s probably going to change tomorrow. And the harder you make it for

your software to change, the more difcult it’s going to be to respond to your

customer’s changing needs. In this chapter, we’re going to revisit an old friend,

try and improve an existing software project, and see how small changes can

turn into big problems. In fact, we’re going to uncover a problem so big that it will

take a TWO-PART chapter to solve it!

good design = flexible software

Rick’s Guitars is expanding 198

Abstract classes 201

Class diagrams dissected (again) 206

UML Cheat Sheet 207

Design problem tipoffs 213

3 steps to great software (revisited) 215

5 (interlude)

$100$100$100$100$100

$200$200$200$200$200

$300$300$300$300$300

$400$400$400$400$400

Software

Neuroses

Maintenance

and Reuse

Code

Constructs

Famous

Designers

Risk

Avoidance

table of contents

5 (part 2)

Give Your Software a 30-minute Workout

Ever wished you were just a bit more flexible?

When you run into problems making changes to your application, it probably

means that your software needs to be more exible and resilient. To help stretch

your application out, you’re going to do some analysis, a whole lot of design, and

learn how OO principles can really loosen up your application. And for the grand

nale, you’ll see how higher cohesion can really help your coupling. Sound

interesting? Turn the page, and let’s get back to xing that inexible application.

good design = flexible software

Back to Rick’s search tool 234

A closer look at the search() method 237

The benets of analysis 238

Classes are about behavior 241

Death of a design (decision) 246

Turn bad design decisions into good ones 247

“Double encapsulation” in Rick’s software 249

Never be afraid to make mistakes 255

Rick’s exible application 258

Test driving well-designed software 261

How easy is it to change Rick’s software? 265

The Great Ease-of-Change Challenge 266

A cohesive class does one thing really well 269

The design/cohesion lifecycle 272

Great software is “good enough” 274

OOA&D Toolbox 276

xvi

table of contents

“My Name is Art Vandelay... I am an Architect”

It’s time to build something REALLY BIG. Are you ready?

You’ve got a ton of tools in your OOA&D toolbox, but how do you use those tools

when you have to build something really big? Well, you may not realize it, but

you’ve got everything you need to handle big problems. We’ll learn about some

new tools, like domain analysis and use case diagrams, but even these new tools

are based on things you already know about—like listening to the customer and

understanding what you’re going to build before you start writing code. Get ready...

it’s time to start playing the architect.

solving really big problems

Solving big problems 280

It’s all in how you look at the big problem 281

Requirements and use cases are a good place to start... 286

Commonality and variability 287

Figure out the features 290

The difference between features and requirements 292

Use cases don’t always help you see the big picture 294

Use case diagrams 296

The Little Actor 301

Actors are people, too (well, not always) 302

Let’s do a little domain analysis 307

Divide and conquer 309

Don’t forget who the customer really is 313

What’s a design pattern? 315

The power of OOA&D (and a little common sense) 318

OOA&D Toolbox 320

Small

Problem

Small

Problem

Small

Problem

Small

Problem

Big

Problem

This BIG PROBLEM is

really just a collection of

functionalities, where each

piece of functionality is really

a smaller problem on its own.

Small

Problem

xvii

table of contents

Bringing Order to Chaos

You have to start somewhere, but you better pick the

right

somewhere! You know how to break your application up into lots of small

problems, but all that means is that you have LOTS of small problems. In this chapter,

we’re going to help you gure out where to start, and make sure that you don’t waste

any time working on the wrong things. It’s time to take all those little pieces laying

around your workspace, and gure out how to turn them into a well-ordered, well-

designed application. Along the way, you’ll learn about the all-important 3 Qs of

architecture, and how Risk is a lot more than just a cool war game from the ‘80s.

architecture

Feeling a little overwhelmed? 324

We need an architecture 326

Start with functionality 329

What’s architecturally signicant? 331

The three Qs of architecture 332

Reducing risk 338

Scenarios help reduce risk 341

Focus on one feature at a time 349

Architecture is your design structure 351

Commonality revisited 355

Commonality Analysis: the path to exible software 361

What does it mean? Ask the customer 366

Reducing risk helps you write great software 371

Bullet Points 372

Giant Risk-O-Meter

Unit

type: String

properties: Map

setType(String)

getType(): String

setProperty(String, Object)

getProperty(String): Object

Board.java

class

Unit {

Unit(){

}

Unit.java

class

Tile

{ ge-

tUnit()

}

Tile.java

class

Board

{ ge-

tUnit()

}

Not a chance in hell of

coming in on time.

One in a hundred that

you get it right.

Only a few things can

go really wrong.

As close to a sure

thing as software gets!

xviii

table of contents

Originality is Overrated

Imitation is the sincerest form of not being stupid. There’s

nothing as satisfying as coming up with a completely new and original solution to a

problem that’s been troubling you for days—until you nd out someone else solved

the same problem, long before you did, and did an even better job than you did! In

this chapter, we’re going to look at some design principles that people have come up

with over the years, and how they can make you a better programmer. Lay aside your

thoughts of “doing it your way”; this chapter is about doing it the smarter, faster way.

design principles

Design principle roundup 376

The Open-Closed Principle (OCP) 377

he OCP, step-by-step 379

The Don’t Repeat Yourself Principle (DRY) 382

DRY is about one requirement in one place 384

The Single Responsibility Principle (SRP) 390

Spotting multiple responsibilities 392

Going from multiple responsibilities to a single responsibility 395

The Liskov Substitution Principle (LSP) 400

Misusing subclassing: a case study in misuing inheritance 401

LSP reveals hidden problems with your inheritance structure 402

Subtypes must be substitutable for their base types 403

Violating the LSP makes for confusing code 404

Delegate functionality to another class 406

Use composition to assemble behaviors from other classes 408

Aggregation: composition, without the abrupt ending 412

Aggregation versus composition 413

Inheritance is just one option 414

Bullet Points 417

OOA&D Toolbox 418

The Open-Closed

Principle

The Don’t Repeat

Yourself Principle

The Single

Responsibility Principle

The Liskov

Substitution

Principle

剩余635页未读，继续阅读

void deleteBook(Book** head, int pos) { Book* p, * q; if (pos == 1) { p = head; head = (head)->next; } else { q = head; for (int i = 1; i < pos - 1 && q != NULL; i++) { q = q->next; } if (q == NULL || q->next == NULL) { printf("删除位置无效！\n"); } else { p = q->next; q->next = p->next; } } }中的问题

这段代码中存在一个问题，即当删除的位置 `pos` 为 1 时，虽然删除了第一个节点，但是链表的头指针 `head` 没有被更新，导致链表的头节点没有被正确删除。可以将 `head` 的值改为 `*head`，这样就可以正确更新头...

head first design patterns-深入浅出设计模式.pdf

《Head First设计模式-深入浅出设计模式》是一本以简单有趣的方式介绍设计模式的书籍。设计模式是在软件开发中解决特定问题的一种经验总结，它们提供了在实际开发中可重用、可靠、灵活的解决方案。该书的主要特点...

详细解释： double center_distance = (sensor_object->GetBaseObject()->center - fused_object->GetBaseObject()->center) .head(2) .norm();

1. `(sensor_object->GetBaseObject()->center - fused_object->GetBaseObject()->center)` 这一部分是计算两个物体中心点在三维空间中的距离向量。 2. `.head(2)` 是 Eigen 库中的一个函数，表示只取这个向量的前...

void Snake_Grow(body Head, int* len, body* rear, int* button) { (len)++; body q = (body)malloc(sizeof(BODY)); //将蛇增加的结点插入蛇头后面 q->next = Head->next; if (q->next != NULL) { q->next->prex = q; } Head->next = q; q->prex = Head; //插入新的结点坐标 q->x = Head->x; q->y = Head->y; Show_Snake(Head); switch (button) { case 72: Head->y = Head->y - 20; break; case 80: Head->y = Head->y + 20; break; case 75: Head->x = Head->x - 20; break; case 77: Head->x = Head->x + 20; break; default: break; } if ((rear) == NULL) //达到尾指针的值 rear = q; } void Snake_move(int* button, int* len, body Head, body* rear, food Food) { //把原来的蛇隐藏 Hide_Snake(Head); //移动蛇身 body p = (rear); while (p && p != Head) { p->x = p->prex->x; p->y = p->prex->y; p = p->prex; } //移动蛇头 switch (button) { case 72: Head->y = Head->y - 20; break; case 80: Head->y = Head->y + 20; break; case 75: Head->x = Head->x - 20; break; case 77: Head->x = Head->x + 20; default: break; } if (Head->x + 10 >= Food->x && Head->x + 10 < Food->x + 20 && Head->y + 10 >= Food->y && Head->y + 10 < Food->y + 20) { //隐藏食物 Hide_Food(Food); //更新食物位置 Rnew_Food(Head, Food); //蛇变长 Snake_Grow(Head, len, rear, button);}为什么蛇的第二个结点图形没有显示

= Head) { p->x = p->prex->x; p->y = p->prex->y; Show_Body(p); // 显示每一个结点的图形 p = p->prex; } ``` 在每次移动一个结点的坐标之后，调用Show_Body函数显示这个结点的图形。这样就可以保证每个蛇...

void deleteNode(List head){ int i; Node p = head; printf("请输入要删除的位置：\n"); scanf("%d", &i); //输入要删除的位置 for(int j=0; j<i-1 && p->next; j++){ //遍历单链表找到指定位置的前驱结点 p = p->next; } if(!p->next){ //删除位置不合法 printf("删除位置不合法\n"); return; } Node q = p->next; //q指向要删除的结点 p->next = q->next; //当前结点的指针域指向要删除结点的后继结点 free(q); //释放要删除的结点 printList(head); //输出单链表所有结点值 }并整合成一个完整的程序

List *head = (List*)malloc(sizeof(Node)); head->next = NULL; Node *p = head; for(int i=0; i; i++){ Node *newNode = (Node*)malloc(sizeof(Node)); printf("请输入第%d个结点的值：", i+1); scanf("%d...

public void deleteNode(ListNode head, int i) { if (i == 0 || head == null) { return; } if (i == 1) { head = head.next; return; } ListNode prev = head; for (int j = 1; j < i - 1 && prev != null && prev.next != null; j++) { prev = prev.next; } if (prev == null || prev.next == null) { return; } prev.next = prev.next.next;}

函数的参数包括链表头节点head和需要删除的节点位置i。具体实现如下： 1. 如果i为0或者head为null，则直接返回。 2. 如果i为1，则将head指向下一个节点即可，然后返回。 3. 如果i大于1，则需要遍历链表找到要删除...

优化代码 /* 解析头部 / case SERIAL_PROTOCOL0_RECEIVE_TYPE_SRATUS_HEAD: if (data == DEF_SERIAL_PROTOCOL0_HEAD) { pfm_ctr_blk->Count = 0; pfm_ctr_blk->Status = SERIAL_PROTOCOL0_RECEIVE_TYPE_SRATUS_LEN; } break; / 解析长度 / case SERIAL_PROTOCOL0_RECEIVE_TYPE_SRATUS_LEN: pfm_ctr_blk->temp[pfm_ctr_blk->Count++] = data; if ((pfm_ctr_blk->Count & DEF_SERIAL_PROTOCOL0_HEAD) == 2) { pfm_ctr_blk->Count = 0; pfm_pkge->Length = pfm_ctr_blk->temp[1]<<8 | pfm_ctr_blk->temp[0]; / 长度效验 */ if (pfm_pkge->Length > pfm_pkge->BufLen-1) { DEF_SERIAL_PROTOCOL0_CORE_ERROR("len error! = %d", pfm_pkge->Length); SERIAL_Protocol0Clear(pframe_buffer); } else { pfm_ctr_blk->Status = SERIAL_PROTOCOL0_RECEIVE_TYPE_SRATUS_CMD; } } break;

这段代码的判断语句 `(pfm_ctr_blk->Count & DEF_SERIAL_PROTOCOL0_HEAD) == 2` 可以使用位运算符 `&` 和常量 `DEF_SERIAL_PROTOCOL0_HEAD - 1` 来替代，从而提高代码的可读性和可维护性。此外，对于一些常量，也...

head first c# pdf

Head First C是一本教授C语言编程的书籍，它的特点是以生动有趣的方式呈现，采用图表、绘画、故事等方式来解释抽象的计算机概念，旨在让学习者在充满趣味的学习过程中掌握C语言。 Head First C以启发式学习方式为荣...

详细解释：double center_distance = (sensor_object->GetBaseObject()->center - fused_object->GetBaseObject()->center) .head(2) .norm();

其中，`sensor_object`和`fused_object`是两个指向物体的指针，通过`GetBaseObject()`方法可以获取到它们的基本信息。`center`是一个Eigen库中的向量，表示物体的中心点坐标。`.head(2)`表示只取向量的前两个元素，...

hanshiwangzi

粉丝: 0
资源: 1

上传资源快速赚钱

我的内容管理展开

我的资源快来上传第一个资源

我的收益

登录查看自己的收益

我的积分登录查看自己的积分

我的C币登录后查看C币余额

我的收藏

我的下载

下载帮助

《Head First OOA&D》：面向实践者的软件设计入门指南

深入浅出面向对象的分析与设计Head.First.Object-Oriented.Design.and.Analysis

Head First Object Oriented Analysis and Design

Head.First.Object-Oriented.Design.and.Analysis.part5

有关面向对象思想的文献

first head object oriented pdf

head first design patterns-深入浅出设计模式.pdf

详细解释： double center_distance = (sensor_object->GetBaseObject()->center - fused_object->GetBaseObject()->center) .head(2) .norm();

Java获取文件编码

c++设计模式有什么书籍

git fetch origin `git rev-parse --abbrev-ref HEAD` && git reset --hard FETCH_HEAD

if(sscanf((const CHAR *)tmp, "0x%x", &head_info->image_head_size) == -1)

head first c pdf

head first java 3rd pdf

head first c# pdf

详细解释：double center_distance = (sensor_object->GetBaseObject()->center - fused_object->GetBaseObject()->center) .head(2) .norm();

最新资源