The Essence of Object-Oriented Programming with Java? and UML

by Wampler, Bruce E., Ph.D.

• ISBN13: 9780201734102
• ISBN10: 0201734109
• Edition: 1st
• Format: Paperback
• Copyright: 2001-12-26
• Publisher: Addison-Wesley Professional

Summary

This book can give any Java developer -- regardless of experience -- the firm foundation they need to achieve the full benefits of object-oriented programming. The book combines practical introductions to UML, object-oriented methodologies, design patterns, libraries, and frameworks -- giving developers all the skills they need to begin writing robust object-oriented programs -- and to tackle the entire field of object-oriented development. Leading developer Bruce Wampler begins with a brief introduction to objects and their benefits; then introduces the fundamental concepts of object orientation and shows how they can be implemented in Java -- starting with the basics, and moving on to advanced topics such as object lifetime and copies of objects. He moves on to Object-Oriented Analysis and Design, introducing the essential concepts at the heart of every methodology. Next, he presents the essence of today's leading techniques for building effective object-oriented Java systems -- including design patterns, refactoring, and more. Wampler concludes by drawing on his decades of development experience to share powerful personal guidelines for creating more effective software. For all application developers who know at least the basics of Java, and are seeking to strengthen their object-oriented programming skills.

Author Biography

Bruce E. Wampler, founder and CEO of Object Central, was a pioneer in developing spelling and grammar checking software for personal computers, and the co-founder of Reference Software International, which was later acquired by WordPerfect. During his extensive career, he has worked at Sandia National Laboratory and taught at the University of New Mexico. He has also developed and delivered many successful, real-world applications, and several widely used open source object-oriented programming tools.

0201734109AB10122001

Table of Contents

Preface	xv
Acknowledgments	xix
Objects, UML, and Java	1	(6)
Object Orientation	2	(1)
Object-Oriented Languages	3	(1)
Object-Oriented Design and the UML	4	(1)
The Payoff of Objects	5	(1)
Chapter Summary	5	(2)
The Essence of Objects	7	(32)
What Is an Object-Oriented System?	9	(9)
Fundamental Properties of an Object-Oriented System	10	(3)
Abstraction with Objects	13	(1)
Encapsulated Classes	13	(1)
Communication via Messages	14	(1)
Object Lifetime	15	(3)
Class Hierarchies	18	(9)
Polymorphism	25	(2)
An Example: Putting It All Together	27	(2)
Other OO Concepts	29	(7)
Abstract Classes	29	(1)
Visibility of Methods	30	(2)
Class Versus Instance	32	(1)
Accessing Objects	33	(1)
A Low-Level View of Objects	34	(2)
Chapter Summary	36	(1)
Resources	37	(2)
Objects in Java	39	(34)
Defining Classes in Java	40	(4)
Visibility	44	(4)
Inheritance	48	(6)
Association, Aggregation, and Composition	54	(3)
Java Interfaces	57	(3)
Object Lifetime in Java	60	(2)
Constructors	60	(1)
Garbage Collection	61	(1)
Memory Leaks	61	(1)
Class Versus Instance Methods and Attributes	62	(1)
Copies of Objects	63	(7)
Messages	70	(1)
Chapter Summary	71	(1)
Resources	71	(2)
Object-Oriented Analysis and Design	73	(32)
Software Methodologies	76	(1)
The Elements of a Software Project	77	(4)
The Essence of Object-Oriented Analysis	81	(11)
Object Discovery	82	(2)
Evaluate Candidate Objects	84	(3)
Determine Object Hierarchies	87	(1)
Discover Object Attributes	88	(1)
Discover Object Operations	89	(3)
The Essence of Object-Oriented Design	92	(2)
Some Design Guidelines	94	(4)
Get the Big Picture	94	(1)
Encapsulation	95	(1)
Designing Classes	95	(1)
Inheritance	96	(1)
General Guidelines	97	(1)
The Build and Release Phases	98	(3)
Building the Software	98	(2)
Releasing the Software	100	(1)
More on the UML	101	(2)
Chapter Summary	103	(1)
Resources	104	(1)
Object-Oriented Graphical User Interfaces with Swing	105	(40)
Graphical User Interfaces	106	(3)
A Typical Application	106	(1)
Dialog Boxes	107	(1)
Events	108	(1)
A Brief Introduction to Swing	109	(13)
Handling Swing Command Events	112	(9)
A Bunch of Options	121	(1)
MVC: Model/View/Controller	122	(22)
MVC with Java	123	(2)
A Small Swing MVC GUI Framework	125	(12)
A Simple Application Based on Wmvc	137	(5)
UML Sequence Diagram for Thermometer	142	(2)
Chapter Summary	144	(1)
Resources	144	(1)
A Case Study in Java	145	(44)
Analysis of MovieCat	146	(5)
Use Cases	146	(2)
Object, Attribute, and Operation Discovery	148	(3)
Evaluation	151	(1)
Design of MovieCat	151	(8)
Movie Class	152	(1)
MovieModel Class	153	(2)
View Classes	155	(3)
Putting It All Together	158	(1)
Implementation of MovieCat	159	(26)
MovieCat Class	159	(1)
Movie Class	160	(3)
MovieModel Class	163	(5)
Main View Class	168	(5)
MovieListView Class	173	(2)
MovieItemView Class	175	(4)
MovieEditor Class	179	(4)
Movie Helper Classes	183	(2)
Review	185	(2)
Chapter Summary	187	(2)
Design Patterns	189	(14)
What Are Design Patterns?	189	(2)
Using Design Patterns	190	(1)
Design Pattern Description Template	190	(1)
The Gang of Four Patterns	191	(4)
Creational Patterns	192	(1)
Structural Patterns	192	(1)
Behavioral Patterns	193	(2)
Example Design Patterns Used by Wmvc and MovieCat	195	(6)
MVC	195	(1)
Observer Pattern	195	(3)
Observer Pattern in Wmvc	198	(1)
Command Pattern in Wmvc	199	(2)
Other Patterns Used in Wmvc and MovieCat	201	(1)
Chapter Summary	201	(1)
Resources	201	(2)
Refactoring	203	(10)
What Is Refactoring?	204	(2)
The Basic Refactoring Process	204	(2)
When Do You Refactor?	206	(2)
Code Smells	206	(1)
When Not to Refactor	207	(1)
Some Refactorings	208	(3)
Refactoring Categories	208	(1)
Some Specific Refactorings	209	(2)
Chapter Summary	211	(1)
Resources	211	(2)
Software Development Methodologies Today	213	(16)
Methodologies for Large-Scale Projects	214	(3)
Overview of the Unified Process	215	(1)
Basic Concepts	215	(2)
Agile Methodologies for Small Projects	217	(6)
The Agile Alliance	217	(2)
Extreme Programming	219	(3)
DSDM	222	(1)
Crystal/Adaptive Software Development	223	(1)
Open Source Development	223	(3)
Open Source Is Distributed Development	224	(2)
Chapter Summary	226	(1)
Resources	226	(3)
Software Tools for Object-Oriented Development	229	(16)
GUIs Versus Consoles	230	(1)
Editors and IDEs	231	(9)
Characteristics of a Good Editor	231	(1)
Three Types of Editors	232	(1)
Emacs	233	(2)
Integrated Development Environments	235	(1)
VIDE	236	(1)
Borland JBuilder	237	(2)
Sun Forte	239	(1)
Another IDE	240	(1)
Source-Code Control	240	(1)
CASE, Modeling, and UML Tools	241	(3)
ArgoUML	241	(1)
MagicDraw	242	(1)
Rational Software	242	(1)
TogetherSoft	243	(1)
Other UML Tools	243	(1)
Other Java Tools	244	(1)
Programming: A Personal Perspective	245	(16)
Programming	246	(7)
Your Code Never Dies	246	(1)
Program with Style	247	(1)
Know What You Are Doing	248	(1)
Write Practice Programs	249	(1)
Practice Incremental Programming	249	(1)
The Tools Matter	249	(1)
Objects Really Help	250	(1)
Testing	250	(1)
Debugging	250	(1)
Don't Reinvent the Wheel	251	(1)
Sometimes It Is Better to Do It Yourself	251	(1)
You Can Get Ideas Any Time	251	(1)
Get a Life	252	(1)
A Plan Matters	252	(1)
The Tools	253	(1)
Your Editor Really Matters	253	(1)
Know About the Time-Tested Tools	253	(1)
Know About the Latest Tools	253	(1)
Tools Go Away	254	(1)
The Work Environment	254	(4)
A Happy Programmer Is a Productive Programmer	254	(1)
Physical Environment	254	(1)
Flexibility	255	(1)
40 Hours	256	(1)
The Team	256	(1)
Marketing Matters	256	(1)
Keep Up-to-Date	257	(1)
Share the Struggle	257	(1)
Let Programmers Help Make Policy	257	(1)
Let Your Boss Know What You Need	258	(1)
The Reference Software Story	258	(1)
Programming Resources	258	(3)
Use the Web	259	(1)
Watch Out for the Web	259	(1)
Use Open Source if You Can	259	(1)
Other Programmers	259	(1)
Web Sites	259	(2)
What Next?	261	(6)
Object Orientation	261	(1)
Java	262	(1)
More Terms You Need to Know	262	(5)
Distributed Computing Terms	263	(1)
Java-Related Terms from Sun	264	(1)
Other Terms	265	(2)
Glossary	267	(12)
Index	279

Excerpts

Why This Book? The goal of this book is to cover what you need to know to develop object-oriented (OO) software using Java and the Unified Modeling Language (UML). When you are through with this book, you should understand object-oriented software development well enough to answer the following questions. What is object orientation? What is the UML? What is object-oriented analysis and design (OOAD)? How do you do OOAD? What are object-oriented development methodologies? How do you use Java to write truly object-oriented programs? What is Swing, and how can you use it to write object-oriented graphical user interfaces? What are design patterns? What is refactoring? What tools do you use to write object-oriented programs? What are some guidelines for writing good code? What do you need to read next to learn even more about object orientation? Who Is This Book For? This book is intended for programmers who know the basics of programming with Java and now want to understand the fundamentals of object-oriented software development. If you're fairly new to programming and have had a class or two in Java, you're probably starting to feel comfortable with Java. Now you're ready to reap the benefits of true object-oriented programming in Java, and this book will help you. If you're an experienced programmer who wants to move from using an old-style procedural programming language to developing object-oriented systems in Java, this book is also for you. This book will take you well down the path to real object-oriented software development. If you have a Java manual available for quick reference, you will likely be able to learn the most important aspects of Java from the examples included in this book. However, this book should not be the last one you read on object orientation, the UML, or Java. Instead, it should give you an essential understanding of objects so that you can read additional advanced and detailed books on the topic with greater purpose. Overview of Chapters Chapter 1 is a brief introduction to objects and the benefits of object-oriented software development. Chapter 2 covers the fundamental concepts of object orientation. Object orientation has many important concepts, and of course, its own vocabulary. It is important for you to understand the main concepts and to be familiar with the specialized vocabulary. Even if you are familiar with some object-oriented concepts, you should review them in this chapter. Basic UML is also introduced. Chapter 3 covers how to use Java to write object-oriented programs. It is not really a Java tutorial, but rather concentrates on using Java to implement object-oriented concepts. The first part of the chapter covers basic Java concepts. The later parts of the chapter cover more-advanced topics, such as object lifetime, copies of objects, and other concepts that are crucial when working with classes and objects. Chapter 4 covers object-oriented analysis and design (OOAD). Rather than focus on any specific OOAD methodology, this chapter covers basics that are important for any methodology. The first four chapters cover the essence of object orientation. Chapter 5 takes a look at graphical user interfaces (GUIs) and the Java Swing library, using the object-oriented perspective developed in the previous chapters. This object-oriented introduction to Swing is a somewhat different approach than is typically found in Swing tutorials. Chapter 6 ties everything together with a case study of a small Java application. The fundamental OOAD concepts covered in Chapter 4 are used to design the application, and the Java and Swing concepts covered in Chapters 3 and 5 are used for the implementation. The goal of the remainder of the book is to give you a good overview of the practical aspects of object-oriented