Are you ready for a concise book packed with insight and wisdom not found elsewhere? Do
you want to gain a deeper understanding of the Java programming language? Do you want to
write code that is clear, correct, robust, and reusable? Look no further! This book will provide
you with these and many other benefits you may not even know you were looking for.

Featuring fifty-seven valuable rules of thumb, Effective Java Programming Language Guide
contains working solutions to the programming challenges most developers encounter each
day. Offering comprehensive descriptions of techniques used by the experts who developed
the Java platform, this book reveals what to do – and what not to do – in order to produce
clear, robust and efficient code.

This book is designed to help you make the most effective use of the Java™ programming
language and its fundamental libraries, java.lang, java.util, and, to a lesser extent,
java.io. The book discusses other libraries from time to time, but it does not cover graphical
user interface programming or enterprise APIs.
This book consists of fifty-seven items, each of which conveys one rule. The rules capture
practices generally held to be beneficial by the best and most experienced programmers.
The items are loosely grouped into nine chapters, each concerning one broad aspect of
software design. The book is not intended to be read from cover to cover: Each item stands on
its own, more or less. The items are heavily cross-referenced so you can easily plot your own
course through the book.
Most items are illustrated with program examples. A key feature of this book is that it
contains code examples illustrating many design patterns and idioms. Some are old, like
Singleton (Item 2), and others are new, like Finalizer Guardian (Item 6) and Defensive
readResolve (Item 57). A separate index is provided for easy access to these patterns and
idioms (page 239). Where appropriate, they are cross-referenced to the standard reference
work in this area [Gamma95].
Many items contain one or more program examples illustrating some practice to be avoided.
Such examples, sometimes known as antipatterns, are clearly labeled with a comment such as
“// Never do this!” In each case, the item explains why the example is bad and suggests an
alternative approach.
This book is not for beginners: it assumes that you are already comfortable with the Java
programming language. If you are not, consider one of the many fine introductory texts
[Arnold00, Campione00]. While the book is designed to be accessible to anyone with
a working knowledge of the language, it should provide food for thought even for advanced
programmers.
Most of the rules in this book derive from a few fundamental principles. Clarity and
simplicity are of paramount importance. The user of a module should never be surprised by its
behavior. Modules should be as small as possible but no smaller. (As used in this book,
the term module refers to any reusable software component, from an individual method to
a complex system consisting of multiple packages.) Code should be reused rather than copied.
The dependencies between modules should be kept to a minimum. Errors should be detected
as soon as possible after they are made, ideally at compile time.

download link :

http://www.filefactory.com/file/ahg2186/n/Addison_Wesley_-_Effective_Java_Programming_Language_Guide_pdf

With this book you will build expertise in important areas such as:
Adapting domain data to Swing components
Creating a FACADE for Swing
Handling recursion in composites
Understanding the role of BRIDGE in Java database connectivity
Making the connection between Model/View/Controller and OBSERVER
Maintaining relational integrity with a mediator
Using proxies to communicate between computers
Letting a service provider decide which class to instantiate
Supporting undo operations with MEMENTO
Prototyping with clones
Using COMMAND to supply a service
Developing thread-safe iterators
Extending classes with DECORATOR and VISITOR

Table of Contents

Foreword…………………………………………………………………………………………………………………………………………. 1
Preface…………………………………………………………………………………………………………………………………………….. 2
Chapter 1. Introduction To Patterns……………………………………………………………………………………………… 4
Why Patterns?……………………………………………………………………………………………………………………………… 4
Why Design Patterns?………………………………………………………………………………………………………………….. 4
Why Java?……………………………………………………………………………………………………………………………………. 6
Why UML?……………………………………………………………………………………………………………………………………. 7
Why a Workbook?………………………………………………………………………………………………………………………… 7
The Organization of This Book…………………………………………………………………………………………………….. 8
Welcome to Oozinoz!…………………………………………………………………………………………………………………… 9
Source Code Disclaimer……………………………………………………………………………………………………………….9
Summary………………………………………………………………………………………………………………………………………. 9

Part I: Interface Patterns……………………………………………………………………………… 10

Chapter 2. Introducing Interfaces……………………………………………………………………………………………….. 11
Ordinary Interfaces…………………………………………………………………………………………………………………….. 11
Interfaces and Obligations………………………………………………………………………………………………………….. 12
Placing Constants in Interfaces………………………………………………………………………………………………….. 13
Summary…………………………………………………………………………………………………………………………………….. 16
Beyond Ordinary Interfaces……………………………………………………………………………………………………….. 16
Chapter 3. Adapter……………………………………………………………………………………………………………………….. 17
Adapting in the Presence of Foresight……………………………………………………………………………………….. 17
Class and Object Adapters…………………………………………………………………………………………………………. 21
Unforeseen Adaptation……………………………………………………………………………………………………………….27
Recognizing Adapter………………………………………………………………………………………………………………….. 28
Summary…………………………………………………………………………………………………………………………………….. 29
Chapter 4. Facade…………………………………………………………………………………………………………………………. 31
Refactoring to Facade………………………………………………………………………………………………………………… 31
Facades, Utilities, and Demos……………………………………………………………………………………………………. 41
Summary…………………………………………………………………………………………………………………………………….. 43
Chapter 5. Composite…………………………………………………………………………………………………………………… 44
An Ordinary Composite……………………………………………………………………………………………………………….44
Recursive Behavior in Composites…………………………………………………………………………………………….. 45
Trees in Graph Theory……………………………………………………………………………………………………………….. 46
Composites with Cycles……………………………………………………………………………………………………………… 50
Consequences of Cycles……………………………………………………………………………………………………………. 55
Summary…………………………………………………………………………………………………………………………………….. 55
Chapter 6. Bridge………………………………………………………………………………………………………………………….. 56
A Classic Example of Bridge: Drivers…………………………………………………………………………………………. 56
Refactoring to Bridge………………………………………………………………………………………………………………….. 60
A Bridge Using the List Interface………………………………………………………………………………………………… 63
Summary…………………………………………………………………………………………………………………………………….. 64

Part II: Responsibility Patterns……………………………………………………………………. 65

Chapter 7. Introducing Responsibility………………………………………………………………………………………… 66
Ordinary Responsibility……………………………………………………………………………………………………………….66
Controlling Responsibility with Visibility……………………………………………………………………………………… 68
Summary…………………………………………………………………………………………………………………………………….. 70
Beyond Ordinary Responsibility…………………………………………………………………………………………………. 70
Chapter 8. Singleton…………………………………………………………………………………………………………………….. 72
Singleton Mechanics………………………………………………………………………………………………………………….. 72
Singletons and Threads……………………………………………………………………………………………………………… 73
Recognizing Singleton……………………………………………………………………………………………………………….. 74
Summary…………………………………………………………………………………………………………………………………….. 75

download link :

http://www.filefactory.com/file/ahg2090/n/Addison_Wesley_-_Design_Patterns_Java_Workbook_2002_pdf

		Copyright
		Acknowledgements
		Chapter 1.  Concurrent Object-Oriented Programming
			Section 1.1.  Using Concurrency Constructs
			Section 1.2.  Objects and Concurrency
			Section 1.3.  Design Forces
			Section 1.4.  Before/After Patterns
		Chapter 2.  Exclusion
			Section 2.1.  Immutability
			Section 2.2.  Synchronization
			Section 2.3.  Confinement
			Section 2.4.  Structuring and Refactoring Classes
			Section 2.5.  Using Lock Utilities
		Chapter 3.  State Dependence
			Section 3.1.  Dealing with Failure
			Section 3.2.  Guarded Methods
			Section 3.3.  Structuring and Refactoring Classes
			Section 3.4.  Using Concurrency Control Utilities
			Section 3.5.  Joint Actions
			Section 3.6.  Transactions
			Section 3.7.  Implementing Utilities
		Chapter 4.  Creating Threads
			Section 4.1.  Oneway Messages
			Section 4.2.  Composing Oneway Messages
			Section 4.3.  Services in Threads
			Section 4.4.  Parallel Decomposition
			Section 4.5.  Active Objects

Download link

here : http://www.filefactory.com/file/ahg2ha1/n/Addison_Wesley_-_Concurrent_Programming_In_Java_Design_Princ_chm