Effective Java

// Concrete implementation built atop skeletal implementation
static List intArrayAsList(int[] a) {
Objects.requireNonNull(a);
// The diamond operator is only legal here in Java 9 and later
// If you're using an earlier release, specify
return new AbstractList
<>
() {
@Override public Integer get(int i) {
return a[i];
// Autoboxing (Item 6)
}
@Override public Integer set(int i, Integer val) {
int oldVal = a[i];
a[i] = val;
// Auto-unboxing
return oldVal;
// Autoboxing
}
@Override public int size() {
return a.length;
}
};
}
When you consider all that a 
List
implementation does for you, this example
is an impressive demonstration of the power of skeletal implementations. Inciden-
tally, this example is an 
Adapter
[Gamma95] that allows an 
int
array to be viewed
as a list of 
Integer
instances. Because of all the translation back and forth
between 
int
values and 
Integer
instances (boxing and unboxing), its perfor-
mance is not terribly good. Note that the implementation takes the form of an
anonymous class
(Item 24).

---

CHAPTER 4
CLASSES AND INTERFACES
102
The beauty of skeletal implementation classes is that they provide all of the
implementation assistance of abstract classes without imposing the severe con-
straints that abstract classes impose when they serve as type definitions. For most
implementors of an interface with a skeletal implementation class, extending this
class is the obvious choice, but it is strictly optional. If a class cannot be made to
extend the skeletal implementation, the class can always implement the interface
directly. The class still benefits from any default methods present on the interface
itself. Furthermore, the skeletal implementation can still aid the implementor’s
task. The class implementing the interface can forward invocations of interface
methods to a contained instance of a private inner class that extends the skeletal
implementation. This technique, known as
 simulated multiple inheritance
, is
closely related to the wrapper class idiom discussed in Item 18. It provides many
of the benefits of multiple inheritance, while avoiding the pitfalls.
Writing a skeletal implementation is a relatively simple, if somewhat tedious,
process. First, study the interface and decide which methods are the primitives in
terms of which the others can be implemented. These primitives will be the
abstract methods in your skeletal implementation. Next, provide default methods
in the interface for all of the methods that can be implemented directly atop the
primitives, but recall that you may not provide default methods for 
Object
methods such as 
equals
and 
hashCode
. If the primitives and default methods
cover the interface, you’re done, and have no need for a skeletal implementation
class. Otherwise, write a class declared to implement the interface, with
implementations of all of the remaining interface methods. The class may contain
any nonpublic fields ands methods appropriate to the task.
As a simple example, consider the 
Map.Entry
interface. The obvious primi-
tives are 
getKey
, 
getValue
, and (optionally) 
setValue
. The interface specifies the
behavior of 
equals
and 
hashCode
, and there is an obvious implementation of
toString
in terms of the primitives. Since you are not allowed to provide default
implementations for the 
Object
methods, all implementations are placed in the
skeletal implementation class: