Effective Java - Chapter 4: Classes and Interfaces

Effective Java – Chapter 4
Joshua Bloch
BY ABBREVIATION OF İBRAHIM KÜRCE

Classes and Interfaces
 Classes and interfaces lie at the heart of the Java programming language. They are
its basic units of abstraction.
 This chapter contains guidelines to help you make the best use of these elements
so that your classes and interfaces are usable, robust, and flexible.

Item 13: Minimize the accessibility of classes and members
 The single most important factor that distinguishes a well-designed module from a
poorly designed one is the degree to which the module hides its internal data and
other implementation details from other modules.
 A well-designed module hides all of its implementation details, cleanly separating its
API from its implementation. Modules then communicate only through their APIs and
are oblivious to each others’ inner workings. This concept, known as information hiding
or encapsulation, is one of the fundamental tenets of software design.
 Information hiding is important for many reasons, most of which stem from the fact
that it decouples the modules that comprise a system, allowing them to be developed,
tested, optimized, used, understood, and modified in isolation. This speeds up system
development because modules can be developed in parallel.

 Information hiding increases software reuse because modules that aren’t tightly
coupled often prove useful in other contexts besides the ones for which they were
developed.
 Finally, information hiding decreases the risk in building large systems, because
individual modules may prove successful even if the system does not.
 The access control mechanism specifies the accessibility of classes, interfaces, and
members. The accessibility of an entity is determined by the location of its declaration
and by which, if any, of the access modifiers (private, protected, and public) is present
on the declaration. Proper use of these modifiers is essential to information hiding.
 The rule of thumb is simple: make each class or member as inaccessible as possible.

 For top-level (non-nested) classes and interfaces, there are only two possible access levels:
package-private and public. If you make it public, you are obligated to support it forever to
maintain compatibility.
 For members (fields, methods, nested classes, and nested interfaces), there are four possible
access levels,
 private—The member is accessible only from the top-level class where it is declared.
 package-private(default)—The member is accessible from any class in the package where it is
declared. Technically known as default access, this is the access level you get if no access modifier
is specified.
 protected—The member is accessible from subclasses of the class where it is declared (subject to a
few restrictions [JLS, 6.6.2]) and from any class in the package where it is declared.
 public—The member is accessible from anywhere.

 After carefully designing your class’s public API, your reflex should be to make all
other members private.
 For members of public classes, a huge increase in accessibility occurs when the
access level goes from package-private to protected. A protected member is part
of the class’s exported API and must be supported forever.
 There is one rule that restricts your ability to reduce the accessibility of methods. If
a method overrides a superclass method, it is not permitted to have a lower
access level in the subclass than it does in the superclass. This is necessary to
ensure that an instance of the subclass is usable anywhere that an instance of the
superclass is usable.

 To facilitate testing, you may be tempted to make a class, interface, or member
more accessible. This is fine up to a point. It is acceptable to make a private
member of a public class package-private in order to test it, but it is not
acceptable to raise the accessibility any higher than that.
 Instance fields should never be public. Classes with public mutable fields are not
thread-safe. Even if a field is final and refers to an immutable object, by making
the field public you give up the flexibility to switch to a new internal data
representation in which the field does not exist.
 A final field containing a reference to a mutable object has all the disadvantages
of a nonfinal field. While the reference cannot be modified, the referenced object
can be modified—with disastrous results.

 Note that a nonzero-length array is always mutable, so it is wrong for a class to have a
public static final array field, or an accessor that returns such a field. This is a frequent
source of security holes:
 There are two ways to fix the problem. You can make the public array private and add a
public immutable list:
 Alternatively, you can make the array private and add a public method that returns a
copy of a private array:

 To summarize, you should always reduce accessibility as much as possible. After
carefully designing a minimal public API, you should prevent any stray classes,
interfaces, or members from becoming a part of the API. With the exception of
public static final fields, public classes should have no public fields. Ensure that
objects referenced by public static final fields are immutable.

Item 14: In public classes, use accessor methods, not public
fields
 Occasionally, you may be tempted to write degenerate classes that serve no purpose
other than to group instance fields:
 Because the data fields of such classes are accessed directly, these classes do not offer
the benefits of encapsulation. You can’t change the representation without changing
the API, you can’t enforce invariants, and you can’t take auxiliary action when a field is
accessed. Hard-line object-oriented programmers feel that such classes are anathema
and should always be replaced by classes with private fields and public accessor
methods (getters) and, for mutable classes, mutators (setters):

fields
 Certainly, the hard-liners are correct when it comes to public classes: if a class is
accessible outside its package, provide accessor methods, to preserve the flexibility
to change the class’s internal representation.

fields
 However, if a class is package-private or is a private nested class, there is nothing
inherently wrong with exposing its data fields. If a change in representation
becomes desirable, you can make the change without touching any code outside
the package.
 Several classes in the Java platform libraries violate the advice that public classes
should not expose fields directly. Prominent examples include the Point and
Dimension classes in the java.awt package.
 While it’s never a good idea for a public class to expose fields directly, it is less
harmful if the fields are immutable. You can’t change the representation of such a
class without changing its API, and you can’t take auxiliary actions when a field is
read, but you can enforce invariants.

fields
 For example, this class guarantees that each instance represents a valid time:

Item 15: Minimize mutability
 An immutable class is simply a class whose instances cannot be modified. All of
the information contained in each instance is provided when it is created and is
fixed for the lifetime of the object. The Java platform libraries contain many
immutable classes, including String, the boxed primitive classes, and BigInteger
and BigDecimal. There are many good reasons for this: Immutable classes are
easier to design, implement, and use than mutable classes. They are less prone to
error and are more secure.
 To make a class immutable, follow these five rules:
1. Don’t provide any methods that modify the object’s state (known as mutators).

2. Ensure that the class can’t be extended.
3. Make all fields final.
4. Make all fields private. This prevents clients from obtaining access to mutable
objects referred to by fields and modifying these objects directly.
5. Ensure exclusive access to any mutable components.

 This class represents a complex number (a number with both real and imaginary parts).
This pattern is used in most nontrivial immutable classes. It is known as the functional
approach because methods return the result of applying a function to their operand
without modifying it.
 Immutable objects are simple. An immutable object can be in exactly one state, the
state in which it was created.
 Immutable objects are inherently thread-safe; they require no synchronization.
Therefore, immutable objects can be shared freely.
 An immutable class can provide static factories that cache frequently requested
instances to avoid creating new instances when existing ones would do. Opting for
static factories in place of public constructors when designing a new class gives you
the flexibility to add caching later, without modifying clients.

 A consequence of the fact that immutable objects can be shared freely is that you
never have to make defensive copies. You need not and should not provide a
clone method or copy constructor on an immutable class.
 Not only can you share immutable objects, but you can share their internals. For
example, the BigInteger class uses a sign-magnitude representation internally. The
sign is represented by an int, and the magnitude is represented by an int array.
The negate method produces a new BigInteger of like magnitude and opposite
sign. It does not need to copy the array; the newly created BigInteger points to the
same internal array as the original.
 Immutable objects make great building blocks for other objects, whether mutable
or immutable.

 The only real disadvantage of immutable classes is that they require a separate
object for each distinct value. Creating these objects can be costly, especially if
they are large.
 The alternative to making an immutable class final is to make all of its constructors
private or package-private, and to add public static factories in place of the public
constructors.

 Static factories have many other advantages over constructors, as discussed in Item 1.
For example, suppose that you want to provide a means of creating a complex number
based on its polar coordinates. This would be very messy using constructors because
the natural constructor would have the same signature that we already used:
Complex(double, double). With static factories it’s easy.
 To summarize, resist the urge to write a set method for every get method. Classes
should be immutable unless there’s a very good reason to make them mutable.

 If a class cannot be made immutable, limit its mutability as much as possible.
Therefore, make every field final unless there is a compelling reason to make it
nonfinal.
 Don’t provide a “reinitialize” method that enables an object to be reused as if it
had been constructed with a different initial state.
 The TimerTask class exemplifies these principles. It is mutable, but its state space is
kept intentionally small. You create an instance, schedule it for execution, and
optionally cancel it. Once a timer task has run to completion or has been canceled,
you may not reschedule it.

Item 16: Favor composition over inheritance
 Inheritance is a powerful way to achieve code reuse, but it is not always the best
tool for the job. Used inappropriately, it leads to fragile software. The problems
discussed in this item do not apply to interface inheritance (when a class
implements an interface or where one interface extends another).
 Unlike method invocation, inheritance violates encapsulation. To make this
concrete, let’s suppose we have a program that uses a HashSet. To tune the
performance of our program, we need to query the HashSet as to how many
elements have been added since it was created.

 This class looks reasonable, but it doesn’t work.
 We would expect the getAddCount method to return three at this point, but it
returns six. Internally, HashSet’s addAll method invokes the add method for each
element.
 We could “fix” the subclass by eliminating its override of the addAll method. This
“self-use” is an implementation detail, not guaranteed to hold in all
implementations of the Java platform and subject to change from release to
release. Therefore, the resulting InstrumentedHashSet class would be fragile.

 Instead of extending an existing class, give your new class a private field that
references an instance of the existing class. This design is called composition
because the existing class becomes a component of the new one. Each instance
method in the new class invokes the corresponding method on the contained
instance of the existing class and returns the results. This is known as forwarding,
and the methods in the new class are known as forwarding methods.
 Here’s a replacement for InstrumentedHashSet,

 Unlike the inheritance-based approach, which works only for a single concrete
class and requires a separate constructor for each supported constructor in the
superclass, the wrapper class can be used to instrument any Set implementation
and will work in conjunction with any preexisting constructor:
 The InstrumentedSet class is known as a wrapper class because each
InstrumentedSet instance contains (“wraps”) another Set instance. This is also
known as the Decorator pattern, because the Instrumented-Set class “decorates” a
set by adding instrumentation.

 The disadvantages of wrapper classes are few. One caveat is that wrapper classes are not suited
for use in callback frameworks, wherein objects pass self-references to other objects for
subsequent invocations (“callbacks”). It’s tedious to write forwarding methods, but you have to
write the forwarding class for each interface only once, and forwarding classes may be provided
for you by the package containing the interface.
 Inheritance is appropriate only in circumstances where the subclass really is a subtype of the
superclass. There are a number of obvious violations of this principle in the Java platform libraries.
For example, a stack is not a vector, so Stack should not extend Vector.
 To summarize, inheritance is powerful, but it is problematic because it violates encapsulation. It is
appropriate only when a genuine subtype relationship exists between the subclass and the
superclass. To avoid this, use composition and forwarding instead of inheritance, especially if an
appropriate interface to implement a wrapper class exists. Not only are wrapper classes more
robust than subclasses, they are also more powerful.

Item 17: Design and document for inheritance or else prohibit it
 Item 16 alerted to the dangers of subclassing a “foreign” class that was not
designed and documented for inheritance.
 First, the class must document precisely the effects of overriding any method. In
other words, the class must document its self-use of overridable methods. A class
must document any circumstances under which it might invoke an overridable
method.
 By convention, a method that invokes overridable methods contains a description
of these invocations at the end of its documentation comment.
 Here’s an example, copied from the specification for java.util.AbstractCollection:

 This documentation leaves no doubt that overriding the iterator method will affect
the behavior of the remove method.

 Design for inheritance involves more than just documenting patterns of selfuse. To
allow programmers to write efficient subclasses without undue pain, a class may
have to provide hooks into its internal workings in the form of judiciously chosen
protected methods or protected fields.
 For example, consider the removeRange method from java.util.AbstractList:

 So how do you decide what protected members to expose when you design a class for
inheritance? Unfortunately, there is no magic bullet. The best you can do is to think
hard, take your best guess, and then test it by writing subclasses.
 The only way to test a class designed for inheritance is to write subclasses. Experience
shows that three subclasses are usually sufficient to test an extendable class.
 When you design for inheritance a class that is likely to achieve wide use, realize that
you are committing forever to the self-use patterns that you document and to the
implementation decisions implicit in its protected methods and fields. These
commitments can make it difficult or impossible to improve the performance or
functionality of the class in a subsequent release. Therefore, you must test your class by
writing subclasses before you release it.

 Constructors must not invoke overridable methods, directly or indirectly. If you
violate this rule, program failure will result.
 Here’s a subclass that overrides the overrideMe, method which is erroneously
invoked by Super’s sole constructor:

 You might expect this program to print out the date twice, but it prints out null
the first time, because the overrideMe method is invoked by the Super constructor
before the Sub constructor has a chance to initialize the date field.
 The Cloneable and Serializable interfaces present special difficulties when
designing for inheritance. It is generally not a good idea for a class designed for
inheritance to implement either of these interfaces.
 If you do decide to implement Cloneable or Serializable in a class designed for
inheritance, you should be aware that because the clone and readObject methods
behave a lot like constructors, a similar restriction applies: neither clone nor
readObject may invoke an overridable method, directly or indirectly.

 If you decide to implement Serializable in a class designed for inheritance and the class
has a readResolve or writeReplace method, you must make the readResolve or
writeReplace method protected rather than private. If these methods are private, they
will be silently ignored by subclasses.
 Designing a class for inheritance places substantial limitations on the class. There are
some situations where it is clearly the right thing to do, such as abstract classes,
including skeletal implementations of interfaces.
 The best solution to this problem is to prohibit subclassing in classes that are not
designed and documented to be safely subclassed. There are two ways to prohibit
subclassing. The easier of the two is to declare the class final. The alternative is to make
all the constructors private or package-private and to add public static factories in
place of the constructors.

Item 18: Prefer interfaces to abstract classes
 The Java programming language provides two mechanisms for defining a type
that permits multiple implementations: interfaces and abstract classes. The most
obvious difference between the two mechanisms is that abstract classes are
permitted to contain implementations for some methods while interfaces are not.
 Existing classes can be easily retrofitted to implement a new interface. All you have
to do is add the required methods if they don’t yet exist and add an implements
clause to the class declaration.
 Interfaces are ideal for defining mixins. Loosely speaking, a mixin is a type that a
class can implement in addition to its “primary type” to declare that it provides
some optional behavior. For example, Comparable is a mixin interface.

 Interfaces allow the construction of nonhierarchical type frameworks. For example,
 In real life, some singers are also songwriters. It is perfectly permissible for a single
class to implement both Singer and Songwriter. In fact, we can define a third
interface that extends both Singer and Songwriter and adds new methods that are
appropriate to the combination:

 You don’t always need this level of flexibility, but when you do, interfaces are a
lifesaver. The alternative is a bloated class hierarchy containing a separate class for
every supported combination of attributes.
 Interfaces enable safe, powerful functionality enhancements via the wrapper class idiom.
If you use abstract classes to define types, you leave the programmer who wants to
add functionality with no alternative but to use inheritance. The resulting classes are
less powerful and more fragile than wrapper classes.
 While interfaces are not permitted to contain method implementations, using
interfaces to define types does not prevent you from providing implementation
assistance to programmers. You can combine the virtues of interfaces and abstract
classes by providing an abstract skeletal implementation class to go with each nontrivial
interface that you export.

 By convention, skeletal implementations are called AbstractInterface, where
Interface is the name of the interface they implement. For example, the Collections
Framework provides a skeletal implementation to go along with each main
collection interface: AbstractCollection, AbstractSet …
 When properly designed, skeletal implementations can make it very easy for
programmers to provide their own implementations of your interfaces.
 For example, here’s a static factory method containing a complete, fully functional
List implementation:

 Note that a static factory is provided and that the class is an inaccessible
anonymous class hidden inside the static factory.
 Using abstract classes to define types that permit multiple implementations has
one great advantage over using interfaces: It is far easier to evolve an abstract class
than an interface. If, in a subsequent release, you want to add a new method to an
abstract class, you can always add a concrete method containing a reasonable
default implementation.
 It is, generally speaking, impossible to add a method to a public interface without
breaking all existing classes that implement the interface.
 Public interfaces, therefore, must be designed carefully. Once an interface is
released and widely implemented, it is almost impossible to change.

Item 19: Use interfaces only to define types
 When a class implements an interface, the interface serves as a type that can be
used to refer to instances of the class.
 One kind of interface that fails this test is the so-called constant interface. The
constant interface pattern is a poor use of interfaces.

Item 19: Use interfaces only to define types
 There are several constant interfaces in the Java platform libraries, such as
java.io.ObjectStreamConstants. These interfaces should be regarded as anomalies and should not
be emulated.
 If you want to export constants, there are several reasonable choices. If the constants are strongly
tied to an existing class or interface, you should add them to the class or interface. If the constants
are best viewed as members of an enumerated type, you should export them with an enum type.
Otherwise, you should export the constants with a noninstantiable utility class. Here is example.
 In summary, interfaces should be used only to define types. They should not be used to export
constants.
 .
 .
 .

Item 20: Prefer class hierarchies to tagged classes
 Occasionally you may run across a class whose instances come in two or more
flavors and contain a tag field indicating the flavor of the instance. For example,

 Such tagged classes have numerous shortcomings. They are cluttered with
boilerplate, including enum declarations, tag fields, and switch statements.
Readability is further harmed because multiple implementations are jumbled
together in a single class. Tagged classes are verbose, error-prone, and inefficient.
 Java offer a far better alternative for defining a single data type capable of
representing objects of multiple flavors: subtyping. A tagged class is just a pallid
imitation of a class hierarchy.
 To transform a tagged class into a class hierarchy, first define an abstract class
containing an abstract method or field for each method in the tagged class whose
behavior depends on the tag value.

 Next, define a concrete subclass of the root class for each flavor of the original
tagged class. Here is the class hierarchy corresponding to the original Figure class:

 This class hierarchy corrects every shortcoming of tagged classes. The code is simple
and clear, containing none of the boilerplate found in the original. All fields are final.
 Another advantage of class hierarchies is that they can be made to reflect natural
hierarchical relationships among types, allowing for increased flexibility and better
compile-time type checking.
 If you’re tempted to write a class with an explicit tag field, think about whether the tag
could be eliminated and the class replaced by a hierarchy.

Item 21: Use function objects to represent strategies
 Some languages support function pointers, delegates, lambda expressions, or
similar facilities that allow programs to store and transmit the ability to invoke a
particular function. Such facilities are typically used to allow the caller of a function
to specialize its behavior by passing in a second function.
 Java does not provide function pointers, but object references can be used to
achieve a similar effect. Invoking a method on an object typically performs some
operation on that object. However, it is possible to define an object whose
methods perform operations on other objects, passed explicitly to the methods.
An instance of a class that exports exactly one such method is effectively a pointer
to that method. Such instances are known as function objects. For example,

 This method is a comparator that orders strings based on their length instead of
the more typical lexicographic ordering. A reference to a StringLengthComparator
object serves as a “function pointer” to this comparator, allowing it to be invoked
on arbitrary pairs of strings. In other words, a StringLengthComparator instance is
a concrete strategy for string comparison.
 As is typical for concrete strategy classes, the StringLengthComparator class is
stateless: it has no fields, hence all instances of the class are functionally
equivalent. Thus it should be a singleton to save on unnecessary object creation
costs,

 To pass a StringLengthComparator instance to a method, we need an appropriate type
for the parameter. It would do no good to use StringLengthComparator because
clients would be unable to pass any other comparison strategy. Instead, we need to
define a Comparator interface and modify StringLengthComparator to implement this
interface. In other words, we need to define a strategy interface to go with the concrete
strategy class.
 The Comparator interface is generic so that it is applicable to comparators for objects
other than strings.

 Concrete strategy classes are often declared using anonymous classes.
 But note that using an anonymous class in this way will create a new instance each
time the call is executed.
 Because the strategy interface serves as a type for all of its concrete strategy
instances, a concrete strategy class needn’t be made public to export a concrete
strategy.

 The String class uses this pattern to export a case-independent string comparator
via its CASE_INSENSITIVE_ORDER field.

 To summarize, a primary use of function pointers is to implement the Strategy
pattern. To implement this pattern in Java, declare an interface to represent the
strategy, and a class that implements this interface for each concrete strategy.
When a concrete strategy is used only once, it is typically declared and
instantiated as an anonymous class. When a concrete strategy is designed for
repeated use, it is generally implemented as a private static member class and
exported in a public static final field whose type is the strategy interface.

Item 22: Favor static member classes over nonstatic
 A nested class is a class defined within another class. A nested class should exist
only to serve its enclosing class. If a nested class would be useful in some other
context, then it should be a top-level class. There are four kinds of nested classes:
static member classes, nonstatic member classes, anonymous classes, and local
classes. All but the first kind are known as inner classes.
 A static member class is a static member of its enclosing class and obeys the same
accessibility rules as other static members. If it is declared private, it is accessible
only within the enclosing class, and so forth.
 One common use of a static member class is as a public helper class, useful only in
conjunction with its outer class.

 Syntactically, the only difference between static and nonstatic member classes is that
static member classes have the modifier static in their declarations. Despite the
syntactic similarity, these two kinds of nested classes are very different. Each instance
of a nonstatic member class is implicitly associated with an enclosing instance of its
containing class.
 If an instance of a nested class can exist in isolation from an instance of its enclosing
class, then the nested class must be a static member class: it is impossible to create an
instance of a nonstatic member class without an enclosing instance.
 One common use of a nonstatic member class is to define an Adapter that allows an
instance of the outer class to be viewed as an instance of some unrelated class. For
example, implementations of the Map interface typically use nonstatic member classes
to implement their collection views, which are returned by Map’s keySet, entrySet, and
values methods.

 If you declare a member class that does not require access to an enclosing instance,
always put the static modifier in its declaration.
 It is doubly important to choose correctly between a static and a nonstatic
member class if the class in question is a public or protected member of an
exported class. In this case, the member class is an exported API element and
cannot be changed from a nonstatic to a static member class in a subsequent
release without violating binary compatibility.
 Anonymous classes are unlike anything else in the Java programming language.
As you would expect, an anonymous class has no name. It is not a member of its
enclosing class. Anonymous classes are permitted at any point in the code where
an expression is legal.

 There are many limitations on the applicability of anonymous classes. You can’t
instantiate them except at the point they’re declared.
 You can’t perform instanceof tests or do anything else that requires you to name
the class. You can’t declare an anonymous class to implement multiple interfaces,
or to extend a class and implement an interface at the same time. Clients of an
anonymous class can’t invoke any members except those it inherits from its
supertype.
 One common use of anonymous classes is to create function objects on the fly.
For example, the sort method invocation, sorts an array of strings according to
their length using an anonymous Comparator instance.

 Local classes are the least frequently used of the four kinds of nested classes. A local class can be
declared anywhere a local variable can be declared and obeys the same scoping rules. Local
classes have attributes in common with each of the other kinds of nested classes. Like member
classes, they have names and can be used repeatedly. Like anonymous classes, they have enclosing
instances only if they are defined in a nonstatic context, and they cannot contain static members.
And like anonymous classes, they should be kept short so as not to harm readability.
 To recap, there are four different kinds of nested classes, and each has its place. If a nested class
needs to be visible outside of a single method or is too long to fit comfortably inside a method,
use a member class. If each instance of the member class needs a reference to its enclosing
instance, make it nonstatic; otherwise, make it static. Assuming the class belongs inside a method,
if you need to create instances from only one location and there is a preexisting type that
characterizes the class, make it an anonymous class; otherwise, make it a local class.

Effective Java - Chapter 4: Classes and Interfaces

More Related Content

Viewers also liked (7)

Similar to Effective Java - Chapter 4: Classes and Interfaces (20)

More from İbrahim Kürce (10)

Recently uploaded (20)

Effective Java - Chapter 4: Classes and Interfaces