Design Patterns Explained: A New Perspective on Object-Oriented Design (Software Patterns) 2nd Edition, Kindle Edition
Use the Amazon App to scan ISBNs and compare prices.
- Highlight, take notes, and search in the book
- Create digital flashcards instantly
The Amazon Book Review
Book recommendations, author interviews, editors' picks, and more. Read it now
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
From the Inside Flap
December, 2000updated May, 2004From Artificial Intelligence to Patterns to True Object OrientationMy journey into design patterns had a different startingpoint than Alan’s but we have reached the same conclusions: · Pattern-based analyses make you a more effective and efficientanalyst because they let you deal with your models more abstractly and becausethey represent the collected experiences of many other analysts. · Patterns help people to learn principles of object orientation.The patterns help to explain why we do what we do with objects. I started my career in artificial intelligence (AI) creatingrule-based expert systems. This involves listening to experts and creatingmodels of their decision-making processes and then coding these models intorules in a knowledge-based system. As I built these systems, I began to seerepeating themes: in common types of problems, experts tended to work in similarways. For example, experts who diagnose problems with equipment tend to lookfor simple, quick fixes first, then they get more systematic, breaking theproblem into component parts; but in their systematic diagnosis, they tend totry first inexpensive tests or tests that will eliminate broad classes ofproblems before other kinds of tests. This was true whether we were diagnosingproblems in a computer or a piece of oil field equipment. Today, I would call these recurring themes patterns. Intuitively, I began to look for these recurring themes as I was designing newexpert systems. My mind was open and friendly to the idea of patterns, eventhough I did not know what they were. Then, in 1994, I discovered that researchers in Europe hadcodified these patterns of expert behavior and put them into a package thatthey called Knowledge Analysis and Design Support, or KADS. Dr. KarenGardner, a most gifted analyst, modeler, mentor, and human being, began toapply KADS to her work in the United States. She extended the European’s work to apply KADS to object-orientedsystems. She opened my eyes to an entire world of pattern-based analysis anddesign that was forming in the software world, in large part due to ChristopherAlexander’s work. Her book, Cognitive Patterns (CambridgeUniversity Press, 1998), describes this work. Suddenly, I had a structure for modeling expert behaviors withoutgetting trapped by the complexities and exceptions too early. I was able tocomplete my next three projects in less time, with less rework, and withgreater end-user satisfaction, because: · I could design modelsmore quickly because the patterns predicted for me what ought to be there. Theytold me what the essential objects were and what to pay special attention to.· I was able to communicatemuch more effectively with experts because we had a more structured way to dealwith the details and exceptions. · The patterns allowed meto develop better end-user training for my system because the patternspredicted the most important features of the system. This last point is significant. Patterns help end-usersunderstand systems because they provide the context for the system, why we aredoing things in a certain way. We can use patterns to describe the guidingprinciples and strategies of the system. And we can use patterns to develop thebest examples to help end-users understand the system. I was hooked.So, when a design patterns study group started at my place ofemployment, I was eager to go. This is where I met Alan who had reached asimilar point in his work as an object-oriented designer and mentor. The resultis this book. Since writing the first edition, I have learned just how deeplythis approach to analysis can get into your head. I have been involved in manydifferent sorts of projects, many outside of software development. I look at systemsof people working together, exchanging knowledge, exchanging ideas, living inremote places. The principles of patterns and object-orientation have stood mewell here, too. Just as in computer systems, there is much efficiency to begained by reducing the dependencies between work systems. I hope that the principles in this book help you in your ownjourney to become a more effective and efficient analyst.James R. Trott
December, 2000updated May, 2004A Note About Conventions Used in This BookIn the writing of this book, we had to make severalchoices about style and convention. Some of our choices have surprised ourreaders. So, it is worth a few comments about why we have chosen to do what wehave done. Approach Rationale First person voice This book is a collaborative effort between two authors. We debated and refined our ideas to find the best ways to explain these concepts. Alan tried them out in his courses and we refined some more. We chose to use the first person singular in the body of this book because it allows us to tell the story in what we hope is a more engaging and natural style. Scanning text We have tried to make this book easy to scan so that you can get the main points even if you do not read the body, or so that you can quickly find the information you need. We make significant use of tables and bulleted lists. We provide text in the outside margin that summarizes paragraphs. With the discussion of each pattern, we provide a summary table of the key features of the pattern. Our hope is that these will make the book that much more accessible. Code examples This book is about analysis and design more than implementation. Our intent is to help you think about crafting good designs based on the insights and best practices of the object-oriented community, as expressed in design patterns. One of the challenges for all of us programmers is to avoid going to the implementation too early, doing before thinking. Knowing this, we have purposefully tried to stay away from too much discussion on implementation. Our code examples may seem a bit lightweight and fragmentary. Specifically, we never provide error checking in the code. This is because we are trying to use the code to illustrate concepts.Examples in C++ and C# are also present at this site. Strategies and
principles Ours is an introductory book. It will help you be able to get up to speed quickly with design patterns. You will understand the principles and strategies that motivate design patterns. After reading this book, you can go on to a more scholarly or a reference book. The last chapter will point you to many of the references that we have found useful. Show breadth and give a taste We are trying to give you a taste for design patterns, to expose you to the breadth of the pattern world but not go into depth in any of them (see the previous point). Our thought was this: If you brought someone to the USA for a two-week visit, what would you show them? Maybe a few sites to help them get familiar with architectures, communities, the feel of cities and the vast spaces that separate them, freeways, and coffee shops. But you would not be able to show them everything. To fill in their knowledge, you might choose to show them slide shows of many other sites and cities to give them a taste of the country. Then, they could make plans for future visits. We are showing you the major sites in design patterns and then giving you tastes of other areas so that you can plan your own journey into
patterns. How to read Java code if you are a C# developer All of the code examples in this book are written in Java. If you do not have experience with Java but can read C#, here is what you need to know: Java uses the words extends and implements to denote a class that extends another class or one that implements an interface, rather than the colon (":"). which is used for both purposes in C#.. Hence, in Java, you would see: public class NewClass extends BaseClass or public class NewClass implements AnInterface while in C# you would see: public class NewClass : BaseClass or public class NewClass : AnInterface All methods are virtual in Java and therefore you don’t specify whether they are new or overridden. There are no such keywords in Java, all subclass methods override any methods they reimplement from a base class. Although there are other differences, they won’t show up in our code examples. How to read Java code if you are a C++ developer This is a little more difficult, but not much more. The most obvious difference is the lack of header files. But how to read the combined header-code file is self-evident. In addition to the C# differences, Java never stores objects on the stack. Java stores objects in heap storage and stores variables that hold references (pointers) to objects on the stack. Every object must be created with a “new”. Hence, in Java you would see: MyClass anObject= new MyClass(); anObject.someMethod(); while in C++ you’d see: MyClass *anObject= new MyClass(); anObject->someMethod(); Thus, Java code looks like C++ code if you add a ‘*’ in the declaration of every variable name that references an object and convert the ‘.’ to a ‘->’. FeedbackDesign patterns are a work in progress, a conversationamong practitioners who discover best practices, who discover fundamentalprinciples in object orientation.We value your feedback on this book:· What did we do well or poorly?· Are there errors that need to be corrected?·New in the Second EditionThis second edition represents several changes andimprovements over the first edition. It reflects what we have learned fromusing and teaching design patterns over the last several years as well as thegenerous and valuable feedback we have received from our readers. Here is a highlight of changes: · Reorders chapters, moving the Strategy pattern earlier· Expands the discussion about Commonality and Variability Analysis(CVA)· Adds a synthesis of eXtreme Programming and design patterns· Makes all code examples complete rather than notional orfragments. All code is in Java. The website also has C# and C++ examples· Explains why the use of factories as objectinstantiators/managers is extremely useful.· Added one design pattern not in the Gang of Four: the Object Poolpattern.· Added a discussion of the pitfalls of patterns and the caution totreat patterns as guides to help you think. Patterns are not truth! We also made numerous small corrections in grammar andstyle. --This text refers to the paperback edition.
Excerpt. © Reprinted by permission. All rights reserved.
Should You Buy the Second Edition If You Already Own the First?
The answer, of course, is yes! Here's why.
Since the first edition was written, we have learned so much more about design patterns, including the following:
How to use commonality and variability analysis to design application architectures
How design patterns relate to and actually facilitate eXtreme programming (XP) and agile development.
How testing is a first principle of quality coding.
Why the use of factories to instantiate and manage objects is critical
Which set of patterns are essential for students to help them learn how to think in patterns
This book covers all of these topics. We have deepened and clarified what we had before and have added some new content that you will find very helpful, including the following:
Chapter 15: Commonality and Variability Analysis
Chapter 20: Lessons from Design Patterns: Factories
Chapter 21: The Object-Pool Pattern (a pattern not covered by the Gang of Four)
Chapter 22: Factories Summarized
We have changed the order in which we present some of the patterns. This sequence is more helpful for the students in our courses as they learn the ideas behind patterns.
We have touched every chapter, incorporating the feedback we have received from our many readers over these past three years.
And, to help students, we have created study questions for each chapter (with answers on the book's companion Web site).
We can honestly say this is one of the few second editions that is definitely worth buying even if you have the first one.
We would love to hear what you think.
Alan and Jim
Design patterns and object-oriented programming. They hold such promise to make your life as a software designer and developer easier. Their terminology is bandied about every day in the technical and even the popular press. It can be hard to learn them, however, to become proficient with them, to understand what is really going on.
Perhaps you have been using an object-oriented or object-based language for years. Have you learned that the true power of objects is not inheritance, but is in "encapsulating behaviors"? Perhaps you are curious about design patterns and have found the literature a bit too esoteric and high-falutin. If so, this book is for you.
It is based on years of teaching this material to software developers, both experienced and new to object orientation. It is based upon the beliefand our experiencethat when you understand the basic principles and motivations that underlie these concepts, why they are doing what they do, your learning curve will be incredibly shorter. And in our discussion of design patterns, you will understand the true mindset of object orientation, which is a necessity before you can become proficient.
As you read this book, you will gain a solid understanding of 12 core design patterns and a pattern used in analysis. You will learn that design patterns do not exist in isolation, but work in concert with other design patterns to help you create more robust applications. You will gain enough of a foundation that you will be able to read the design pattern literature, if you want to, and possibly discover patterns on your own. Most importantly, you will be better equipped to create flexible and complete software that is easier to maintain.
Although the 12 patterns we teach here are not all of the patterns you should learn, an understanding of these will enable you to learn the others on your own more easily. Instead of giving you more patterns than you need to get started, we have included pattern-related issues that will be more useful.
From Object Orientation to Patterns to True Object Orientation
In many ways, this book is a retelling of my personal experience learning design patterns. This started with learning the patterns themselves and then learning the principles behind them. I expanded this understanding into the realms of analysis and testing as well as learning how patterns relate to agile coding methods. This second edition of this book includes many additional insights I have had since publication of the first edition. Prior to studying design patterns, I considered myself to be reasonably expert in object-oriented analysis and design. My track record had included several fairly impressive designs and implementations in many industries. I knew C++ and was beginning to learn Java. The objects in my code were well-formed and tightly encapsulated. I could design excellent data abstractions for inheritance hierarchies. I thought I knew object orientation.
Now, looking back, I see that I really did not understand the full capabilities of object-oriented design, even though I was doing things the way most experts advised. It wasn't until I began to learn design patterns that my object-oriented design abilities expanded and deepened. Knowing design patterns has made me a better designer, even when I don't use these patterns directly.
I began studying design patterns in 1996. I was a C++/object-oriented design mentor at a large aerospace company in the Northwest. Several people asked me to lead a design pattern study group. That's where I met my coauthor, Jim Trott. In the study group, several interesting things happened. First, I grew fascinated with design patterns. I loved being able to compare my designs with the designs of others who had more experience than I. And second, I discovered that I was not taking full advantage of designing to interfaces and that I didn't always concern myself with seeing whether I could have an object use another object without knowing the used object's type. I also noticed that beginners in object-oriented designthose who would normally be deemed as learning design patterns too earlywere benefiting as much from the study group as the experts were. The patterns presented examples of excellent object-oriented designs and illustrated basic object-oriented principles, which helped to mature their designs more quickly. By the end of the study sessions, I was convinced that design patterns were the greatest thing to happen to software design since the invention of object-oriented design.
When I looked at my work at the time, however, I saw that I was not incorporating any design patterns into my code. Or, at least, not consciously. Later, after learning patterns, I realized I had incorporated many design patterns into my code just out of being a good coder. However, now that I understand patterns better, I am able to use them better.
I just figured I didn't know enough design patterns yet and needed to learn more. At the time, I only knew about six of them. Then I had an epiphany. I was working as a mentor in object-oriented design for a project and was asked to create the project's high-level design. The leader of the project was extremely sharp, but was fairly new to object-oriented design.
The problem itself wasn't that difficult, but it required a great deal of attention to make sure the code was going to be easy to maintain. Literally, after about two minutes of looking at the problem, I had developed a design based on my normal approach of data abstraction. Unfortunately, it was also clear to me this was not going to be a good design. Data abstraction alone had failed me. I had to find something better.
Two hours later, after applying every design technique I knew, I was no better off. My design was essentially the same. What was most frustrating was that I knew there was a better design. I just couldn't see it. Ironically, I also knew of four design patterns that "lived" in my problem, but I couldn't see how to use them. Here I wasa supposed expert in object-oriented designbaffled by a simple problem!
Feeling very frustrated, I took a break and started walking down the hall to clear my head, telling myself I would not think of the problem for at least 10 minutes. Well, 30 seconds later, I was thinking about it again! But I had gotten an insight that changed my view of design patterns: rather than using patterns as individual items, I should use the design patterns together.
Patterns are supposed to be sewn together to solve a problem.
I had heard this before, but hadn't really understood it. Because patterns in software have been introduced as design patterns, I had always labored under the assumption that they had mostly to do with design. My thoughts were that in the design world, the patterns came as pretty much well-formed relationships between classes. Then I read Christopher Alexander's amazing book, The Timeless Way of Building (Oxford University Press, 1979). I learned that patterns existed at all levelsanalysis, design, and implementation. Alexander discusses using patterns to help in the understanding of the problem domain (even in describing it), not just using them to create the design after the problem domain is understood.
My mistake had been in trying to create the classes in my problem domain and then stitch them together to make a final system, a process that Alexander calls a particularly bad idea. I had never asked whether I had the right classes because they just seemed so right, so obvious; they were the classes that immediately came to mind as I started my analysis, the "nouns" in the description of the system that we had been taught to look for. But I had struggled trying to piece them together.
When I stepped back and used design patterns and Alexander's approach to guide me in the creation of my classes, a far superior solution unfolded in only a matter of minutes. It was a good design, and we put it into production. I was excitedexcited to have designed a good solution and excited about the power of design patterns. It was then that I started incorporating design patterns into my development work and my teaching.
I began to discover that programmers who were new to object-oriented design could learn design patterns, and in doing so, develop a basic set of object-oriented design skills. It was true for me, and it was true for the students whom I was teaching.
Imagine my surprise! The design pattern books I had been reading and the design pattern experts I had been talking to were saying that you really needed to have a good grounding in object-oriented design before embarking on a study of design patterns. Nevertheless, I saw, with my own eyes, students who learned object-oriented design concurrently with design patterns learned object-oriented design faster than those just studying object-oriented design. They even seemed to learn design patterns at almost the same rate as experienced object-oriented practitioners.
I began to use design patterns as a basis for my teaching. I began to call my classesPattern-Oriented Design: Design Patterns from Analysis to Implementation.
I wanted my students to understand these patterns and began to discover that using an exploratory approach was the best way to foster this understanding. For instance, I found that it was better to present the Bridge pattern by presenting a problem and then have my students try to design a solution to the problem using a few guiding principles and strategies that I had found were present in most of the patterns. In their exploration, the students discovered the solutionessentially the Bridge patternand remembered it.
Design Patterns and Agile/XP
The guiding principles and strategies underlying design patterns seem very clear to me now. Certainly, they are stated in the "Gang of Four's" design patterns book, but too succinctly to be of value to me when I first read it. I believe the Gang of Four were writing for the Smalltalk community, which was very grounded in these principles and therefore needed little background. It took me a long time to understand them because of limitations in my own understanding of the object-oriented paradigm. It was only after integrating in my own mind the work of the Gang of Four with Alexander's work, Jim Coplien's work on commonality and variability analysis, and Martin Fowler's work in methodologies and analysis patterns that these principles became clear enough to me so that I was able to talk about them to others. It helped that I was making my livelihood explaining things to othersso I couldn't get away with making assumptions as easily as I could when I was just doing things for myself.
Since the first edition of this book appeared, I have been doing a considerable amount of agile development and have become very grounded in eXtreme Programming (XP) coding practices, test-driven development (TDD), and Scrum. Initially, I had a difficult time reconciling design patterns with XP and TDD. However, I quickly realized that both have great value and both are grounded in the same principles (although they take different design approaches). In fact, in our agile software development boot camps, we make it clear that design patterns, used properly, are strong enablers of agile development.
Throughout this book, I discuss many of the ways design patterns relate to agile management and coding practices. If you are unfamiliar with XP, TDD, or Scrum, do not be too concerned about these comments. However, if this is the case, I suggest the next book you read be about one of these topics.
In any event, I found that these guiding principles and strategies could be used to "derive" several of the design patterns. By "derive a design pattern," I mean that if I looked at a problem that might be solved by a design pattern, I could use the guiding principles and strategies that I learned from patterns to come up with the solution expressed in a pattern. I made it clear to my students that we weren't really coming up with design patterns this way. Instead, I was just illustrating one possible thought process that the people who came up with the original solutions, those that were eventually classified as design patterns, might have used.
My abilities to explain these few, but powerful, principles and strategies improved. As they did, I found that it became more useful to explain an increasing number of the Gang of Four patterns. In fact, I use these principles and strategies to explain virtually all the patterns I discuss in my design patterns course.
I found that I was using these principles in my own designs both with and without patterns. This didn't surprise me. If using these strategies resulted in a design equivalent to a design pattern when I knew the pattern was present, that meant they were giving me a way to derive excellent designs (because patterns are excellent designs by definition). Why would I get any poorer designs from these techniques just because I didn't know the name of the pattern that might or might not be present anyway?
These insights helped hone my training process (and now my writing process). I had already been teaching my courses on several levels. I was teaching the fundamentals of object-oriented analysis and design. I did that by teaching design patterns and using them to illustrate good examples of object-oriented analysis and design. In addition, by using the patterns to teach the concepts of object orientation, my students were also better able to understand the principles of object orientation. And by teaching the guiding principles and strategies, my students were able to create designs of comparable quality to the patterns themselves.
I relate this story because this book follows much the same pattern as my course (pun intended). Virtually all the material in this book now is covered in one of our courses on design patterns, test-driven-development or agile development best practices.1
As you read this book, you will learn the patterns. Even more importantly, you will learn why they work and how they can work together, and the principles and strategies upon which they rely. It will be useful to draw on your own experiences. When I present a problem in the text, it is helpful if you imagine a similar problem that you have come across. This book isn't about new bits of information or new patterns to apply, but rather a new way of looking at object-oriented software development. I hope that your own experiences, connected with the principles of design patterns, will prove to be a powerful ally in your learning.
Updated October 2004
From Artificial Intelligence to Patterns to True Object Orientation
My journey into design patterns had a different starting point than Alan's, but we have reached the same conclusions:
Pattern-based analyses make you a more effective and efficient analyst because they enable you to deal with your models more abstractly and because they represent the collected experiences of many other analysts.
Patterns help people to learn principles of object orientation. The patterns help to explain why we do what we do with objects.
I started my career in artificial intelligence (AI) creating rule-based expert systems. This involves listening to experts and creating models of their decision-making processes and then coding these models into rules in a knowledge-based system. As I built these systems, I began to see repeating themes: In common types of problems, experts tended to work in similar ways. For example, experts who diagnose problems with equipment tend to look for simple, quick fixes first, and then they get more systematic, breaking the problem into component parts; in their systematic diagnosis, however, they tend to try first inexpensive tests or tests that will eliminate broad classes of problems before other kinds of tests. This was true whether we were diagnosing problems in a computer or a piece of oil field equipment.
Today I would call these recurring themes patterns. Intuitively I began to look for these recurring themes as I was designing new expert systems. My mind was open and friendly to the idea of patterns, even though I did not know what they were.
Then, in 1994, I discovered that researchers in Europe had codified these patterns of expert behavior and put them into a package that they calledKnowledge Analysis and Design Support(KADS). Dr. Karen Gardner, a most gifted analyst, modeler, mentor, and human being, began to apply KADS to her work in the United States. She extended the European's work to apply KADS to object-oriented systems. She opened my eyes to an entire world of pattern-based analysis and design that was forming in the software world, in large part due to Christopher Alexander's work. Her book Cognitive Patterns (Cambridge University Press, 1998) describes this work.
Suddenly I had a structure for modeling expert behaviors without getting trapped by the complexities and exceptions too early. I was able to complete my next three projects in less time, with less rework, and with greater end-user satisfaction, because
I could design models more quickly because the patterns predicted for me what ought to be there. They told me what the essential objects were and what to pay special attention to.
I was able to communicate much more effectively with experts because we had a more structured way to deal with the details and exceptions.
The patterns allowed me to develop better end-user training for my system because the patterns predicted the most important features of the system.
This last point is significant. Patterns help end users understand systems because they provide the context for the system, why we are doing things in a certain way. We can use patterns to describe the guiding principles and strategies of the system. And we can use patterns to develop the best examples to help end users understand the system.
I was hooked.
So, when a design patterns study group started at my place of employment, I was eager to go. This is where I met Alan, who had reached a similar point in his work as an object-oriented designer and mentor. The result is this book.
Since writing the first edition, I have learned just how deeply this approach to analysis can get into your head. I have been involved in many different sorts of projects, many outside of software development. I look at systems of people working together, exchanging knowledge, exchanging ideas, living in remote places. The principles of patterns and object orientation have stood me well here, too. Just as in computer systems, much efficiency is to be gained by reducing the dependencies among work systems.
I hope that the principles in this book help you in your own journey to become a more effective and efficient analyst.
James R. Trott
Updated October 2004
A Note About Conventions Used in This Book
In the writing of this book, we had to make several choices about style and convention. Some of our choices have surprised our readers. So it is worth a few comments about why we have chosen to do what we have done.
First person voice
This book is a collaborative effort between two authors. We debated and refined our ideas to find the best ways to explain these concepts. Alan tried them out in his courses, and we refined some more. We chose to use the first person singular in the body of this book because it enables us to tell the story in what we hope is a more engaging and natural style.
We have tried to make this book easy to scan so that you can get the main points even if you do not read the full body of text, or so that you can quickly find the information you need. We make significant use of tables and bulleted lists. We provide text in the outside margin that summarizes paragraphs. With the discussion of each pattern, we provide a summary table of the key features of the pattern. Our hope is that these will make the book that much more accessible.
This book is about analysis and design more than implementation. Our intent is to help you think about crafting good designs based on the insights and best practices of the object-oriented community, as expressed in design patterns. One of the challenges for all of us programmers is to avoid going to the implementation too early, doing before thinking. Knowing this, we have purposefully tried to stay away from too much discussion on implementation. Our code examples may seem a bit lightweight and fragmentary. Specifically, we never provide error checking in the code. This is because we are trying to use the code to illustrate concepts. However, the book's companion Web site, athttp://www.netobjectives.com/dpexplained, contains more complete code examples from which the fragments were extracted. Examples in C++ and C# are also present at this site.
Strategies and principles
Ours is an introductory book. It will help you be able to get up to speed quickly with design patterns. You will understand the principles and strategies that motivate design patterns. After reading this book, you can go on to a more scholarly book or a reference book. The last chapter points you to many of the references that we have found useful.
Show breadth and give a taste
We are trying give you a taste for design patterns, to expose you to the breadth of the pattern world but not go into depth in any of them (see the previous point).
Show breadth and give a taste (cont.)
We are trying give you a taste for design patterns, Our thought was this: If you brought someone to the United States for a two-week visit, what would you show that person? Maybe a few sites to help him get familiar with architectures, communities, the feel of cities and the vast spaces that separate them, freeways, and coffee shops. But you would not be able to show him everything. To fill in his knowledge, you might choose to show him slide shows of many other sites and cities to give him a taste of the country. Then he could make plans for future visits. Likewise, we are showing you the major sites in design patterns, and then giving you tastes of other areas, so that you can plan your own journey into patterns.
How to Read Java Code If You Are a C# Developer
All the code examples in this book are written in Java. If you do not have experience with Java but can read C#, here is what you need to know:
Java uses the wordsextendsandimplementsto denote a class that extends another class or one that implements an interface, rather than the colon (:), which is used for both purposes in C#.
Hence, in Java, you would seepublic class NewClass extends BaseClass
orpublic class NewClass implements AnInterface
whereas in C#, you would seepublic class NewClass : BaseClass
orpublic class NewClass : AnInterface
All methods are virtual in Java, and therefore you don't specify whether they areneworoverridden. There are no such keywords in Java; all subclass methods override any methods they reimplement from a base class. Although there are other differences, they won't show up in our code examples.
How to Read Java Code If You Are a C++ Developer
This is a little more difficult, but not much more. The most obvious difference is the lack of header files. But how to read the combined header-code file is self-evident. In addition to the C# differences, Java never stores objects on the stack. Java stores objects in heap storage and stores variables that hold references (pointers) to objects on the stack. Every object must be created with anew.
Hence, in Java you would seeMyClass anObject= new MyClass();anObject.someMethod();
whereas in C++, you would seeMyClass *anObject= new MyClass();anObject->someMethod();
Thus Java code looks like C++ code if you add an asterisk (*) in the declaration of every variable name that references an object and convert the period (.) to a hyphen followed by a right-angle bracket (->).
Design patterns are a work in progress, a conversation among practitioners who discover best practices, who discover fundamental principles in object orientation.
We value your feedback on this book:
What did we do well or poorly?
Are there errors that need to be corrected?
Was there something that was confusingly written?
Please visit us at the Net Objectives companion Web site for this book; the URL ishttp://www.netobjectives.com/dpexplained. At this site, you will find our latest research as well as a discussion group related to this book and to software development in general. Please post corrections, comments, insights, and "aha" moments to this discussion group.
New in the Second Edition
This second edition represents several changes and improvements over the first edition. It reflects what we have learned from using and teaching design patterns over the past several years as well as the generous and valuable feedback we have received from our readers.
Here is a highlight of changes:
Chapter reordering (for instance, the Strategy pattern is described earlier in the book).
Expanded discussion about commonality and variability analysis (CVA).
A synthesis of eXtreme Programming (XP) and design patterns.
All code examples complete rather than notional or fragments. All code is in Java. The Web site also has C# and C++ examples.
Why the use of factories as object instantiators/managers proves extremely helpful.
A design pattern not in the Gang of Four: the Object Pool pattern.
A discussion of the pitfalls of patterns, including a caution to treat patterns as guides to help you think. Patterns are not truth!
We also made numerous small corrections in grammar and style.
Almost every preface ends with a list of acknowledgments of those who helped in the development of the book. We never fully appreciated how true this was until doing a book of our own. Such an effort is truly a work of a community. The list of people to whom we are in debt is long.
The following people are especially significant to us:
Debbie Lafferty and John Neidhart from Addison-Wesley, who never grew tired of encouraging us and keeping us on track.
Scott Bain, our colleague who patiently reviewed this work and gave us insights. His collaboration with Alan at Net Objectives also led to many of the new insights in the second edition of this book.
Our team of reviewers: James Huddleston, Steve Metsker, and Clifton Nock.
And especially Leigh and Jill, our patient wives, who put up with us and encouraged us in our dream of this book.
We received fantastic comments from so many people who reviewed the first edition and the drafts of this present edition. We especially want to recognize Brian Henderson, Bruce Trask, Greg Frank, and Sudharsan Varadharajan, who shared freely and patiently their insights, suggestions, and questions.
Special thanks from Alan:
Several of my students early on had an impact they probably never knew. Many times during my courses, I hesitated to project new ideas, thinking I should stick with the tried and true. However, their enthusiasm in my new concepts when I first started my courses encouraged me to project more and more of my own ideas into the curriculum I was putting together. Thanks to Lance Young, Peter Shirley, John Terrell, and Karen Allen. They serve as a constant reminder to me how encouragement can go a long way.
Thanks to John Vlissides for his thoughtful comments and tough questions.
For the second edition, I want to add thanks to Dr. Dan Rawsthorne, another colleague at Net Objectives. His approach to agile development has contributed to mine. Jeff McKenna's (another colleague) support and affirmation is also greatly appreciated. I also want to thank Kim Aue, our "director of everything" at Net Objectives. Her support in general has been extremely helpful.
Although not --This text refers to the paperback edition.
- ASIN : B001U5VJW2
- Publisher : Addison-Wesley Professional; 2nd edition (October 12, 2004)
- Publication date : October 12, 2004
- Language: : English
- File size : 5446 KB
- Simultaneous device usage : Up to 5 simultaneous devices, per publisher limits
- Text-to-Speech : Enabled
- Enhanced typesetting : Enabled
- X-Ray for textbooks : Enabled
- Word Wise : Not Enabled
- Print length : 480 pages
- Lending : Not Enabled
- Best Sellers Rank: #529,518 in Kindle Store (See Top 100 in Kindle Store)
- Customer Reviews:
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
Other reviews have complained about the lack for code in this book. If you are looking for a book to show you how to write code that implements a specific pattern in a specific language this book is not for you. This book is a higher level book that focuses on the concepts of good design that are true for all object oriented languages. There are other books that go into the specifics of various languages.
I found this book a true pleasure to read, and recommend it above the original GOF book. It really makes patterns incredibly easy to understand and apply in the right context, instead of just blindly using them because they are the next cool thing in Software Engineering.
Whilst the 'GoF book' is still a vital book, it is more of reference than something that should be read cover-to-cover. Buy this book first, and then get the 'GoF Book', once you have read this book.
-less dense than GoF
-in-depth real-world case studies showing how patterns provided solutions
-writing style is in the vein of "inspirational" or "self-help" books - to me it's unsuitable for a technical subject (author talks about how patterns have "changed his life", like a religion or something).
-the author comes across as an evangelist, treating the GoF text as dogma. Patterns, like any other technique, are not magic and have their own set of pros/cons; the author presents them as the be-all end-all solution for all software engineering problems.
-There is a *lot* of superfluous space in this book - huge margins, big font, before-and-after chapter summaries ("here's a two-page list of what I'm going to tell you", followed by the chapter contents, followed by "here's a two-page list of what I just told you.")
The pros outweigh the nitpicks listed above, but I highly suggest following this up with the original GoF text - you may find it more digestible after this appetizer.
Top reviews from other countries
What I didn't realise is that the bulk of this book, ie the parts that describe the patterns themselves, does nothing more than rehash what the GoF did, but not as well. The depth (or lack of) that this book covers was in the first few pages of the GoF's description of each pattern, and the heavy stuff that the GoF added was missed out from this book altogether. What's worse is that the GoF had far better examples that made the patterns easier to understand. With the descriptions here, you just started to get the idea of what the pattern was about when the chapter ended. You were left with a feeling of being dropped right at the crucial moment.
To make matters worse, the "dozens of code examples" promised on the back of the book turned out to be very short and unhelpful. Whilst it's important to concentrate on only those bits of code that are relevant to the issue being discussed, you need enough code to see what's going on. This book has very little. In fairness, the web site has a lot more code to download, but the book should have had more code shown, instead of forcing you to wade through the downloaded files.
If you just want to learn the patterns, then you're WAY better off with the GoF book, and just skip anything you find too heavy.
This book spends far too much time on irrelevant points (like discussing things he's not going to cover). For example, it spends a whole chapter describing an example situation, making out that it's going to be a major part of the book, but then you find that it is then not used very much in the rest of the book. The bits that re used could have been described in one paragraph. What a waste of time!
The one thing that the GoF book doesn't do, that this one attempts to do is explain how to decide which pattern to use. This is a very important issue, as learning the patterns is really only the beginning. You need to know how and when to apply them. This books spends some time describing how to analyse your problem domain, and how to decide which patterns might be appropriate.
Unfortunately, this is all done in a fairly vague manner, and so it far less useful than it could have been. Had this part been done well, the book would have been worthwhile, even with my other complaints. However, as this part was fairly unclear, I don't think the book warrants more than three stars. The authors keep dropping hints about their courses, but if this is the way they teach, I can't see the courses being much good. I certainly wouldn't pay money to have them teach me!
It could be that repeated reading of the analysis section of the book might eventually help, but I don't have the time or interest to bash through it over and over again in the hope that it make become clearer. I'm sure there are better ways to learn this stuff.
A great disappointment.
A pattern is a solution that comes up enough times that it might as well have a name. By their very nature patterns are obvious solutions if you understand the fundamental principles of software engineering and think about the problem for long enough. The problem almost always defines the solution. Unfortunately this book tries to describe a new perspective on Object Oriented design that frankly just isn't actually new. As with any technology, how it is actually used in practise evolves over time and changes from how it was first envisaged. Whilst reading this book a colloquial expression often came to mind that Dr Watson could have said to Sherlock Holmes if he had just stated the blindingly obvious.
This is most definitely not a reference book. You have to wade through bumpf about design and the personal experiences of the authors to find the sections describing specific patterns. Concise is not a word that I would use to describe this book. It's useful to know the names of patterns because it aids communication with other engineers, but if you want to find out what someone else is referring to then it will be faster to use wikipedia.
The only thing that I really learnt from this book was about the pitfall of implementing double checked locking in Java. Unfortunately Wikipedia gave a much more useful explanation.
The authors essentially teach the reader how to design software better. They walk the reader through various approaches to a systems design example throughout the book, finally culminating with the approach of combining software patterns with CVA (Commonality and Variability Analysis). It is just so obvious but no-one ever seemed to think of it before.
From reading this book I now have a lot more clarity in thinking through the analysis and design of software and am producing implementations that are far more maintainable. For that I cannot thank the authors enough.
In summary : GET THIS BOOK!