Index

Symbols

{ } (braces), 58

+ (plus sign), 62

/ (slash), comment notations using, 69

A

aborting applications, 54

abstraction

abstract classes

interfaces compared to, 133–135

overview of, 121–123, 128–131

abstract factory design pattern, 165

abstract interfaces, 41–42

abstract methods, 129

nonportable code, 84

overview of, 25–26, 30–31

accessor methods, 13–14, 73–75

adapter design pattern, 169–171

aggregations

association and, 153

concept of, 112–113, 151–152, 153, 180

Alexander, Christopher, 162

Ambler, Scott, 173

analysis, role in system design, 95

antipatterns, 173–174

applications

aborting, 54

recovering, 54–55

“The Architecture of Complexity” (Simon), 149

artifacts

Reuseless, 173

Robust, 173

associations

aggregation and, 153

concept of, 112–113, 152–153

multiple object, 157–158

optional, 158–159

attributes

class, 18, 61–62, 69–71

importance of, 57–58

initialization of, 48

local, 58–59

object, 12, 59–61

public versus private, 20

static, 83

B

base classes, 24–25

behavioral inheritance, 63

behavioral patterns

categories of, 171–172

iterator, 172–173

behaviors, object. See also methods

overview of, 13–16, 44

separating out, 200–202

bitwise copies, 64

builder design pattern, 165

buyInventory() method, 142

C

C / C++ development. See OO (object-oriented) development

C# development. See OO (object-oriented) development

C++ Report, 173

Cabbie class

accessors, 73

attributes, 69–71

class diagram, 115–116

comments, 69

constructors

default, 49

example of, 47–48

overview of, 71–72

name, 68

overloaded methods, 50

calcArea() method, 188–189

CalculateAreas class, 189, 190–191, 192

CalculatePay() method, 14

calling constructors, 48

Car class, 137, 138

cardinality, 155–157

Cat class, 199, 202

catch keyword, 55–57

catching exceptions, 56–57

categories, design pattern, 164–165

CatNoise class, 201, 204

chain of response, 171

CIRCLE class, 167–169

Circle class, 27–30, 119, 130–131, 189

class diagrams

cardinality in, 156–157

composition, 113–114

creating, 51–52

DataBaseReader class, 51

Dog class, 159

e-business case study, 142–146

CustList class, 143

DonutShop class, 143–144

PizzaShop class, 144

Shop class, 142

overview of, 19–20, 92

class keyword, 67–69

classes. See also interfaces; methods; objects

abstract. See also abstraction

interfaces compared to, 133–135

overview of, 121–123, 128–131

attributes

class scope, 61–62

example of, 69–71

initialization of, 48

local scope, 58–59

object scope, 59–61

overview of, 18, 61–62

public versus private, 20

Cabbie

accessors, 73

attributes, 69–71

class diagram, 115–116

comments, 69

constructors, 47–49, 71–72

name, 68

overloaded methods, 50

CalculateAreas, 189, 190–191, 192

Car, 137, 138

Cat, 199, 202

CatNoise, 201, 204

Circle, 27–30, 119, 130–131, 167–169, 189

comments

design guidelines, 81–82

notation, 69

number of, 82

composition

advantages of, 175–177

aggregations, 112–113, 151–152, 153

associations, 112–113, 152–153, 157–159

building in phases, 149–151

cardinality, 155–157

class diagrams, 113–114

definition of, 105

dependencies, 154–155

example of, 112, 159–160

object reuse, 105–106

overview of, 30

relationships, 148–149

constructors

calling, 48

default, 48–49

design of, 53–54, 80–81

example of, 71–72

injection by, 184

lack of, 71

multiple, 49–50, 72

overview of, 47–48

purpose of, 48

return values, 47

Count, 49–50

CustList, 143

data hiding, 20

database reader example, 36–40

DataBaseReader

class diagrams, 51

constructors, 52

overview of, 36–40

testing, 87–88

definition of, 16–17

design guidelines, 10

code reuse, 82

comments, 81–82

constructors/destructors, 80–81

copying and comparison, 84

extensibility, 83

implementation, hiding, 79–80

interaction, 82

maintainability, 86

marshalling, 89

naming conventions, 83–84

nonportable code, 84

object persistence, 88–89

public interface, 78–79

real-world system modeling, 77–78

scope, 84–85

serialization, 89

stubs, 86–88

top-down, 77

destructors, 80–81

Dog

class diagram, 159–160

contract, 137–138

defining, 134

dependency injection, 182–184

design decisions, 110–112

generalization-specialization, 109–110

inheritance, 107–109

DonutShop, 143–144

Employee

behaviors, 13–16

cardinality, 155–157

multiple object associations, 157–158

optional associations, 158–159

encapsulation

importance of, 113–114

inheritance weakened by, 115–117

overview of, 20

error handling

applications, aborting, 54

design guidelines, 81

exceptions, catching, 56–57

exceptions, throwing, 55–57

ignoring problems, 54

overview of, 54

recovery, 54–55

Head, 133

highly coupled, 86, 175–177. See also dependencies

identifying, 96

implementation

characteristics of, 36

hiding, 79–80

inheritance

advantages and limitations, 106–109

behavioral, 63

composition as alternative to, 175–177, 179–182

definition of, 105

design decisions, 110–112

example of, 159–160, 177–179

generalization-specialization, 109–110

implementation, 63

multiple, 26, 63, 131–132

object reuse, 105–106

overview of, 23–24

polymorphism, 27–30

relationships, 131, 147

single, 26

subclasses, 24–25

superclasses, 24–25

weakened by encapsulation, 115–117

Integer, 169–170

interface/implementation paradigm

model of, 22–23

overview of, 21

real-world example, 21–22

interfaces

abstract, 41–42

characteristics of, 36

database reader example, 36–40

design guidelines, 41–42

extending, 79

IMammal, 197

implementation versus, 34–35

ISP (Interface Segregation Principle), 197–198

IWalkable, 183–184

minimum public, 78–79

overview of, 20–21, 131–132

prototypes, 97

public, 44–45, 75

testing, 86–88

Iterator, 172

MailTool, 170

MainApplication, 98

MakingNoise, 200

Mammal, 203

composition, 179–182

defining, 133

inheritance, 178–179

interfaces for, 197–198

makeNoise() method, 199

Math, 85

messages, 19

model of, 96–97

MyMailTool, 170–171

names, 67–69

Number

class attributes, 61–62

local attributes, 58–59

object attributes, 59–61

objects, creating from, 17–18

OpenClosed, 192, 194

Person

attributes, 18

class diagram, 19–20

creating, 18

extensibility, 83

methods, 19

PizzaShop, 144

Planet, 136, 137

polymorphism

object responsibility, 118–119

overview of, 117

Rectangle, 117, 119, 130–131, 192, 194–197

references, 64

relationships

has-a, 31

is-a, 26–27, 107

scope, 84–85

setters, injection by, 184

Shape, 165

calcArea() method, 188

child classes, 167–168

class hierarchy, 128–131

factory method design pattern, 165–169

generate() method, 167

is-a relationships, 26–27

polymorphism, 27–30, 117–121

ShapeFactory class, 168–169

ShapeCalculator, 192

ShapeFactory, 168–169

Shop, 142

SomeMath, 100

Sound, 101

Square, 22–23, 167–169

Star, 119

superclasses, 53

Swimmable, 181

TestBeep, 101

TestFactoryPattern, 169

TestMammal, 200, 201–202, 203–204

TestMath, 100

TestShape, 119–121, 190, 191

TestShop, 145–146

Triangle, 120, 167–169

Whale, 181

Window, 117

wrapping, 101–102

Coad, Peter, 106, 115

code reuse. See also abstraction; object reuse

advantages and limitations, 125

contracts

defining, 136–138

overview of, 128

as system plug-in points, 138–139

design guidelines for, 82

e-business case study

code reuse for, 141–142

non-reuse approach, 139–141

scenario, 139

UML object model, 142–146

frameworks, 126–127

interfaces

abstract, 41–42

abstract classes compared to, 133–135

characteristics of, 36

database reader example, 36–40

design guidelines, 41–42

extending, 79

IMammal, 197

implementation versus, 34–35

interface/implementation paradigm, 21–23

is-a relationships, 135–136

ISP (Interface Segregation Principle), 197–198

IWalkable, 183–184

minimum public interface, 78–79

overview of, 20–21, 131–132

prototypes, 97

public, 44–45, 75

terminology, 131

testing, 86–88

UML diagrams, 132

command design pattern, 171

comments

design guidelines, 81–82

notation, 69

number of, 82

communication, object-to-object, 10–11

comparing objects, 84

composition, 30

advantages of, 175–177

aggregations

association and, 153

concept of, 112–113, 151–152, 153

associations

aggregation and, 153

concept of, 112–113, 152–153

multiple object, 157–158

optional, 158–159

building in phases, 149–151

cardinality, 155–157

class diagrams, 113–114

definition of, 105

dependencies, avoiding, 154–155

example of, 112, 159–160, 179–182

object reuse, 105–106

relationships, 148–149

concatenation of strings, 62

conditions, 98–99

consequences, 162

constraints, environmental, 44

constructors

calling, 48

default, 48–49

design of, 53–54, 80–81

example of, 71–72

injection, 80

injection by, 184, 199

lack of, 71

multiple, 49–50, 72

overview of, 47–48

purpose of, 48

return values, 47

contracts

defining, 136–138

overview of, 128

as system plug-in points, 138–139

copies, 64–65

copying objects, 84

Count class, 49–50

coupling, 86, 175–177

“Creating Chaos” (Johnson), 173

creational patterns

categories of, 165

factory method, 165

curly braces ({}), 58

CustList class, 143

customers, 79

D

data hiding, 9, 20

data transfer objects (DTOs), 78

DataBaseReader class

class diagram, 51

constructors, 52

overview of, 36–40

testing, 87–88

databases. See also DataBaseReader class

NoSQL, 89

relational, 89

declaring methods

private implementation methods, 76

public interface methods, 75

static, 73–74

decoupling. See dependencies

deep copies, 64

default constructors, 48–49

definition inheritance. See inheritance

dependencies, 154–155. See also dependency injection; inheritance

composition, 30

advantages of, 175–177

example of, 179–182

DIP (Dependency Inversion Principle), 3

dependency injection and, 202–204

initial example, 199–200

overview of, 198–199

separating out behavior, 200–202

inheritance

composition as alternative to, 175–177, 179–182

issues with, 179–182

dependency injection, 182–184

by constructor, 80, 184, 199

definition of, 198

DIP (Dependency Inversion Principle), 3, 202–204

initial example, 199–200

overview of, 198–199

separating out behavior, 200–202

example of, 182–184

by parameters, 199

by setter, 184

Dependency Inversion Principle. See DIP (Dependency Inversion Principle)

design

classes, 10

code reuse, 82

comments, 81–82

constructors/destructors, 80–81

copying and comparison, 84

extensibility, 83

identifying, 96

implementation, hiding, 79–80

interaction, 82

maintainability, 86

naming conventions, 83–84

nonportable code, 84

public interface, 78–79

real-world system modeling, 77–78

scope, 84–85

comments, 81–82

constructors, 53–54

error handling, 81

global data, 8–9, 85

guidelines and best practices

iteration in, 86

marshalling, 89

object persistence, 88–89

serialization, 89

stubs, 86–88

top-down design, 77

inheritance, 110–112

interfaces, 41–42

objects, 12

patterns

adapter, 169–171

advantages of, 162

antipatterns, 173–174

best practices, 161

categories of, 164–165

elements of, 162

factory method, 165–169

iterator, 172–173

MVC (Model/View/Controller), 163–164

overview of, 161–162

SOLID principles

DIP (Dependency Inversion Principle), 198–204

ISP (Interface Segregation Principle), 197–198

LSP (Liskov Substitution Principle), 194–197

OCP (Open/Close Principle), 192–194

overview of, 187–188

SRP (Single Responsibility Principle), 187–188

system

analysis, 95

building in phases, 149–151

class identification, 96

class model, 96–97

object wrappers, 97–102

OO design process, 91–94

requirements documents, 95

safety versus economics, 94

SOW (statement of work), 95

system prototypes, 96

user interface prototypes, 97

waterfall model, 92–93

design patterns

adapter, 169–171

advantages of, 162

antipatterns, 173–174

best practices, 161

categories of, 164–165

elements of, 162

factory method, 165–169

iterator, 172–173

MVC (Model/View/Controller), 163–164

overview of, 161–162

Design Patterns (Gamma et al), 161–162. See also design patterns

destructors, 80–81

diagrams, class

cardinality in, 156–157

composition, 113–114

creating, 51–52

DataBaseReader class, 37, 51

Dog class, 156–157, 159

e-business case study, 142–146

CustList class, 143

DonutShop class, 143–144

PizzaShop class, 144

Shop class, 142

overview of, 19–20, 92

diagrams, interface, 132

Dictionary.com, 128

DIP (Dependency Inversion Principle), 3

dependency injection, 202–204

initial example, 199–200

overview of, 198–199

separating out behavior, 200–202

documentation. See also diagrams, class

amount of, 82

comments

design guidelines, 81–82

notation, 69

requirements documents, 95

SOW (statement of work), 95

Dog class, 182, 184

class diagram, 159–160

defining, 134, 137, 138

design decisions, 110–112

generalization-specialization, 109–110

inheritance, 107–109

domains, mixing, 155

DonutShop class, 143–144

draw() method, 119, 128–131

DTOs (data transfer objects), 78

E

e-business case study

code reuse for, 141–142

non-reuse approach, 139–141

scenario, 139

UML object model, 142–146

CustList class, 143

DonutShop class, 143–144

PizzaShop class, 144

Shop class, 142

economics, safety versus, 94

Effective C++ (Meyers), 63, 78, 109

Employee class

behaviors, 13–16

cardinality, 155–157

multiple object associations, 157–158

optional associations, 158–159

Employee object, 14

encapsulation

definition of, 10

importance of, 113–114

inheritance weakened by, 115–117

overview of, 20

enums, 167

environmental constraints, 44

error handling

aborting application, 54

design guidelines, 81

exceptions

catching, 56–57

throwing, 55–57

ignoring problems, 54

overview of, 54

recovery, 54–55

exceptions

catching, 56–57

throwing, 55–57

extensibility

design guidelines, 83

interfaces, 79

F

factory method design pattern, 165–169

flat file systems, 89

fragility, 187

frameworks, 126–127

G

Gamma, Erich, 161–162

Gang of Four, 161–162

garbage collection, 80

generalization-specialization, 109–110

generate() method, 167–168

generateHeat() method, 133

getArea() method, 29–30

getInventory() method, 142

getMail() method, 171

getSize() method, 133

getSocialSecurityNumber(), 14

getters, 13–14, 73–74

Gilbert, Stephen, 115

giveDestination() method, 75, 76

global data, 8–9, 85

GoF (Gang of Four), 161–162

H

handling errors. See error handling

has-a relationships, 31

hasMoreElements() method, 173

Head class, 133

Helm, Richard, 161–162

hiding

data, 9

implementation, 79–80

highly coupled classes, 86, 175–177. See also dependencies

hybrid apps, 7

I

ignoring problems, 54

IMammal interface, 197

immobility, 187

implementations. See also inheritance

characteristics of, 36

database reader example, 36–40

hiding, 79–80

identifying, 45–46

interface/implementation paradigm

model of, 22–23

overview of, 21

real-world example, 21–22

interfaces versus, 34–35

private implementation methods, 76

inheritance. See also composition; encapsulation

advantages and limitations, 106–109

behavioral, 63

composition as alternative to, 175–177, 179–182

definition of, 105

design decisions, 110–112

example of, 159–160

generalization-specialization, 109–110

implementation, 63

is-a relationships, 107

multiple, 26, 63, 131–132

object reuse, 105–106

overview of, 23–24

polymorphism, 27–30

relationships, 26–27, 131, 135–136, 147

single, 26

weakened by encapsulation, 115–117

init keyword, 47

initialization, attribute, 48

injection, dependency. See dependency injection

Integer class, 169–170

interaction, design guidelines for, 82

Interface Segregation Principle (ISP), 3, 197–198

interfaces

abstract, 41–42

abstract classes compared to, 133–135

characteristics of, 36

database reader example, 36–40

design guidelines, 41–42

extending, 79

IMammal, 197

interface/implementation paradigm, 34–35

model of, 22–23

overview of, 21

real-world example, 21–22

is-a relationships, 135–136

ISP (Interface Segregation Principle), 197–198

IWalkable, 183–184

Nameable, 132, 136, 137

overview of, 20–21, 131–132

prototypes, 97

public, 44–45

methods, 75

minimum public interface, 78–79

terminology, 131

testing, 86–88

UML diagrams, 132

internal customers, 79

interpreter design pattern, 171

Inversion of Control (IoC), 72

IOC (inversion of control), 182

IPS. See Interface Segregation Principle (ISP)

is-a relationships, 26–27, 107, 135–136

ISP (Interface Segregation Principle), 3, 197–198

iterate() method, 173

iterations, 86, 99

Iterator class, 172

iterator design pattern, 172–173

IWalkable interface, 183–184

J

Java. See OO (object-oriented) development

Java Design (Coad and Mayfield), 106

Java development. See OO (object-oriented) development

Java Primer Plus (Tyma, Torok, and Downing), 54

Johnson, Johnny, 173

Johnson, Ralph, 161–162

K

keywords. See also methods

catch, 55–57

class, 68

classes, 67–69

init, 47

new, 47, 53, 165, 169, 181

null, 71–72

private, 69–71, 76

public, 75–76

static, 61–62, 69–71, 74–75

this, 60

try, 55–57

Koenig, Andrew, 173

L

Larman, Craig, 1

leaks, memory, 81

legacy systems, OO (object-oriented) concepts with, 6–7

Liskov Substitution Principle (LSP), 3, 109, 194–197

local attributes, 58–59

LSP. See Liskov Substitution Principle (LSP)

M

MailTool class, 170

MainApplication class, 98

maintainability, 86

makeNoise() method, 133, 199

MakingNoise class, 200

Mammal class, 203

composition, 179–182

defining, 133

inheritance, 178–179

interfaces for, 197–198

makeNoise() method, 199

marshalling objects, 89

Martin, Robert, 7, 187

Math class, 85

Mayfield, Mark, 106, 115

McMarty, Bill, 115

mediator design pattern, 172

memento design pattern, 172

memory leaks, 81

messages, 19

methods, 13. See also keywords

abstract, 129

accessors, 13–14, 73–75

buyInventory(), 142

calcArea(), 188–189

CalculatePay(), 14

constructors

calling, 48

default, 48–49

design of, 53–54, 80–81

example of, 71–72

injection by, 184

lack of, 71

multiple, 49–50, 72

overview of, 47–48

purpose of, 48

return values, 47

destructors, 80–81

draw(), 119, 128–131

generate(), 167–168

generateHeat(), 133

getArea(), 29–30

getInventory(), 142

getMail(), 171

getSize(), 133

getSocialSecurityNumber(), 14

getters, 13–14, 73–74

giveDestination(), 75, 76

hasMoreElements(), 173

iterate(), 173

makeNoise(), 133, 199

mutators, 13–14

open(), 39–40

overloading, 50–51

overview of, 19

private implementation, 76

public interface, 75

retrieveMail(), 170

setSize(), 133

setters, 13–14, 73–74, 184

setWalker(), 184–185

signatures, 50–51

static, 74–75, 83

turnRight(), 76

virtual, 121–123

walk(), 183

Meyers, Scott, 63, 78, 109

middleware, 37–39

minimum public interface, 78–79

mobile web, 7

modeling tools, 15

Model/View/Controller (MVC) design pattern, 163–164

multiple constructors, 49–50, 72

multiple inheritance, 26, 63, 131–132

multiple object associations, 157–158

mutator methods, 13–14

MVC (Model/View/Controller) design pattern, 163–164

MyMailTool class, 170–171

N

Nameable interface, 132, 136, 137

naming conventions

classes, 67–69

design guidelines for, 83–84

patterns, 162

new keyword, 47, 53, 165, 169, 181

nonportable code, 84, 101

NoSQL databases, 89

null value, 71–72

Number class

class attributes, 61–62

local attributes, 58–59

object attributes, 59–61

O

object attributes, 59–61

The Object Primer (Ambler), 86

object reuse, 105–106, 204

composition, 30

advantages of, 175–177

aggregation, 112–113, 151–152

aggregations, 153

association, 112–113

associations, 152–153, 157–159

building in phases, 149–151

cardinality, 155–157

class diagrams, 113–114

definition of, 105

dependencies, avoiding, 154–155

example of, 112, 159–160, 179–182

object reuse, 105–106

relationships, 148–149

inheritance. See also composition

behavioral, 63

composition as alternative to, 175–177, 179–182

definition of, 105

design decisions, 110–112

example of, 159–160

generalization-specialization, 109–110

implementation, 63

is-a relationships, 26–27

multiple, 26, 63

object reuse, 105–106

overview of, 23–24

polymorphism, 27–30

relationships, 147

single, 26

object wrappers

definition of, 7

design guidelines, 97–98

for existing classes, 101–102

for nonportable code, 101

overview of, 97–98

for structured code, 98–100

Objective-C, 2

Object-Oriented Design in Java (Gilbert and McCarty), 44, 54, 64, 78, 155

object-oriented development. See OO (object-oriented) development

objects. See also classes; methods; object reuse

attributes, 12

class scope, 61–62

example of, 69–71

initialization of, 48

local, 58–59

object scope, 59–61

public versus private, 20

behaviors, 13–16, 44

comparing, 84

copies, 64–65

copying, 84

creating, 17–18

definition of, 8, 12

design, 12

Employee, 14

marshalling, 89

object-to-object communication, 10–11

operations, 63–65

Payroll, 14

persistence, 39, 88–89

properties, 13

responsibility, 118–119

scope

class attributes, 61–62

importance of, 57–58

local attributes, 58–59

object attributes, 59–61

serialization, 89

wrappers

definition of, 7

design guidelines, 97–98

observer design pattern, 172

OCP. See Open/Close Principle

OO (object-oriented) development, 11. See also abstraction; classes; code reuse; dependencies; objects

abstraction

abstract classes, 121–123, 128–131, 133–135

abstract factory design pattern, 165

abstract interfaces, 41–42

abstract methods, 129

nonportable code, 84

overview of, 25–26, 30–31

advantages of, 11–12

comments

design guidelines, 81–82

notation, 69

number of, 82

composition, 30

advantages of, 175–177

aggregations, 112–113, 151–152, 153

associations, 112–113, 152–153, 157–159

building in phases, 149–151

cardinality, 155–157

class diagrams, 113–114

definition of, 105

dependencies, avoiding, 154–155

example of, 112, 159–160, 179–182

object reuse, 105–106

relationships, 148–149

contracts

defining, 136–138

overview of, 128

as system plug-in points, 138–139

data hiding, 9

e-business case study

code reuse for, 141–142

non-reuse approach, 139–141

scenario, 139

UML object model, 142–146

encapsulation

definition of, 10

importance of, 113–114

inheritance weakened by, 115–117

environmental constraints, 44

error handling

aborting application, 54

design guidelines, 81

exceptions, catching, 56–57

exceptions, throwing, 55–57

ignoring problems, 54

overview of, 54

recovery, 54–55

evolution of, 5

frameworks, 126–127

implementations

characteristics of, 36

database reader example, 36–40

hiding, 79–80

identifying, 45–46

interface/implementation paradigm, 21–23

interfaces versus, 34–35

private implementation methods, 76

inheritance

advantages and limitations, 106–109

behavioral, 63

composition as alternative to, 175–177, 179–182

definition of, 105

design decisions, 110–112

example of, 159–160, 177–179

generalization-specialization, 109–110

implementation, 63

multiple, 26, 63, 131–132

object reuse, 105–106

overview of, 23–24

polymorphism, 27–30

relationships, 131, 135–136, 147

single, 26

subclasses, 24–25

superclasses, 24–25

weakened by encapsulation, 115–117

interface/implementation paradigm

model of, 22–23

overview of, 21

real-world example, 21–22

interfaces

abstract, 41–42

abstract classes compared to, 133–135

characteristics of, 36

database reader example, 36–40

design guidelines, 41–42

extending, 79

IMammal, 197

implementation versus, 34–35

interface/implementation paradigm, 21–23

is-a relationships, 135–136

ISP (Interface Segregation Principle), 197–198

IWalkable, 183–184

minimum public interface, 78–79

overview of, 20–21, 131–132

prototypes, 97

public, 44–45, 75

terminology, 131

testing, 86–88

UML diagrams, 132

iteration in, 86

legacy systems and, 6–7

object-to-object communication, 10–11

operators, overloading, 62–63

polymorphism

object responsibility, 118–119

overview of, 117

procedural programming compared to, 7–11

relationships

has-a, 31

is-a, 26–27, 107

scope

class attributes, 61–62

design guidelines, 84–85

importance of, 57–58

local attributes, 58–59

object attributes, 59–61

SOLID principles

DIP (Dependency Inversion Principle), 198–204

ISP (Interface Segregation Principle), 197–198

LSP (Liskov Substitution Principle), 194–197

OCP (Open/Close Principle), 192–194

overview of, 187–188

SRP (Single Responsibility Principle), 188–191

stacks, 29

users, determining, 43–44

open() method, 39–40

Open/Close Principle, 192–194

Open/Close Principle (OCP), 3, 192–194

OpenClosed class, 192, 194

operations, object, 63–65

operators, overloading, 62–63

optional associations, 158–159

overloading

methods, 50–51

operators, 62–63

P

parameters, injection by, 199

parent class, 24–25

passing references, 71

A Pattern Language (Alexander), 162

patterns, design

adapter, 169–171

advantages of, 162

antipatterns, 173–174

best practices, 161

categories of, 164–165

elements of, 162

factory method, 165–169

iterator, 172–173

MVC (Model/View/Controller), 163–164

overview of, 161–162

Payroll object, 14

persistence, 39, 88–89

Person class

attributes, 18

class diagram, 19–20

creating, 18

extensibility, 83

methods, 19

PizzaShop class, 144

Planet class, 136, 137

plus sign (+), 62

polymorphism

object responsibility, 118–119

overview of, 27–30, 117

private attributes, 20

private implementation methods, 76

private keyword, 69–71, 76

problems, 162

procedural programming

data model, 11

OO (object-oriented) programming compared to, 7–11

properties, object, 13

protocols, 121–123

prototype design pattern, 165

prototypes

system, 96

user interface, 97–98

public attributes, 20

public interfaces, 44–45, 75

public keyword, 75–76

Q-R

recovery, 54–55

Rectangle class, 117, 119, 130–131, 192, 194–197

references

classes and, 64

passing, 71

relational databases, 89

relationships

composition, 148–149

has-a, 31

inheritance, 131, 147

is-a, 26–27, 107, 135–136

requirements documents, 95

responsibility, SRP (Single Responsibility Principle), 187–188

retrieveMail() method, 170

return values, 47

reuse of code. See code reuse

“Reuse Patterns and Antipatterns” (Ambler), 173

Reuseless Artifact, 173

rigidity, 187

Robust Artifacts, 173

S

safety, economics versus, 94

scope

class attributes, 61–62

design guidelines, 84–85

importance of, 57–58

local attributes, 58–59

object attributes, 59–61

separating out behavior, 200–202

sequences, 98–99

serialization, 89

setSize() method, 133

setters, 13–14, 73–74, 184

setWalker() method, 184–185

shallow copies, 64

Shape class, 165

calcArea() method, 188

child classes, 167–168

class hierarchy, 128–131

factory method design pattern, 165–169

generate() method, 167

is-a relationships, 26–27

polymorphism, 27–30, 117–121

ShapeFactory class, 168–169

ShapeCalculator class, 192

ShapeFactory class, 168–169

ShapeType enum, 167

Shop class, 142

signatures, 21, 50–51

Simon, Herbert, 149

single inheritance, 26

Single Responsibility Principle (SRP), 3, 187–188

singleton design pattern, 165

slash (/), 69

Smalltalk

development of, 163

MVC (Model/View/Controller) design pattern, 164–165

SOLID principles, 2–3, 109

DIP (Dependency Inversion Principle)

dependency injection, 202–204

initial example, 199–200

overview of, 198–199

separating out behavior, 200–202

ISP (Interface Segregation Principle), 197–198

LSP (Liskov Substitution Principle), 194–197

OCP (Open/Close Principle), 192–194

overview of, 187–188

SRP (Single Responsibility Principle), 187–188

solutions, 162

SomeMath class, 100

Sound class, 101

SOW (statement of work), 95

specialization, 109–110

Square class, 22–23, 167–169

SRP. See Single Responsibility Principle (SRP)

stacks, 29

standalone applications, 39

Star class, 119

state design pattern, 172

statement of work (SOW), 95

static attributes, 83

static keyword, 61–62, 69–71, 74–75

static methods, 83

strategy design pattern, 172

strings, concatenation of, 62

structural patterns

adapter, 169–171

categories of, 169

structured code

conditions, 98–99

sequences, 98–99

wrapping, 99–100

stubs, 86–88

subclasses, 24–25

substitution, LSP (Liskov Substitution Principle), 194–197

superclasses, 24–25, 53

Swift

exceptions, 55–57

init keyword, 47

multiple inheritance, 63

scope, 58

Swimmable class, 181

system design

analysis, 95

building in phases, 149–151

class identification, 96

class model, 96–97

object wrappers, 97–98

for existing classes, 101–102

for nonportable code, 101

overview of, 97–98

for structured code, 98–100

OO design process, 91–94

requirements documents, 95

safety versus economics, 94

SOW (statement of work), 95

system prototypes, 96

user interface prototypes, 97

waterfall model, 92–93

system prototypes, 96

T

template method, 172

TestBeep class, 101

TestFactoryPattern class, 169

testing interfaces, 86–88

TestMammal class, 200, 201–202, 203–204

TestMath class, 100

TestShape class, 119–121, 190, 191

TestShop class, 145–146

this keyword, 60

throwing exceptions, 55–57

top-down design, 77

Triangle class, 120, 167–169

troubleshooting. See error handling

try keyword, 55–57

try/catch blocks, 55–57

turnRight() method, 76

U

UML (Unified Modeling Language)

class diagrams, 14–15, 19–20, 92

creating, 51–52

DataBaseReader, 37

interface diagrams, 132

user interface prototypes, 97

users

customers versus, 79

determining, 43–44

V

variables, global, 85

virtual methods, 121–123

visitor design pattern, 172

Visual Basic .NET, 2

exceptions, 55–57

multiple inheritance, 63

New keyword, 47

operator overloading, 63

Vlissides, John, 161–162

W-X-Y-Z

walk() method, 183

waterfall model, 92–93

Whale class, 181

Window class, 117

word processing framework, 126–127

wrappers

advantages of, 38

design guidelines, 97–98

for existing classes, 101–102

for nonportable code, 101

overview of, 7, 97–98

for structured code, 98–100

Xerox PARC, 163