【Core Java】【Volume I ~Fundamentals】Chapter 6 INTERFACES AND INNER CLASSES

Chapter  6

INTERFACES AND  INNER CLASSES

▼ INTERFACES
▼ OBJECT CLONING
▼ INTERFACES AND CALLBACKS
▼ INNER CLASSES
▼ PROXIES

You have now seen all the basic tools for object-oriented programming in Java.
This chapter shows you several advanced techniques that are commonly used. Despite
their less obvious nature, you will need to master them to complete your Java tool chest.
The first, called an interface, is a way of describing what classes should do, without specifying
how they should do it. A class can implement one or more interfaces. You can then
use objects of these implementing classes anytime that conformance to the interface is
required. After we cover interfaces, we take up cloning an object (or deep copying, as it
is sometimes called). A clone of an object is a new object that has the same state as the
original. In particular, you can modify the clone without affecting the original.
Next, we move on to the mechanism of inner classes. Inner classes are technically somewhat
complex—they are defined inside other classes, and their methods can access the
fields of the surrounding class. Inner classes are useful when you design collections of
cooperating classes. In particular, inner classes enable you to write concise, professional-looking
code to handle GUI events.
This chapter concludes with a discussion of proxies, objects that implement arbitrary
interfaces. A proxy is a very specialized construct that is useful for building systemlevel
tools. You can safely skip that section on first reading.

Interfaces

  In the Java programming language, an interface is not a class but a set of requirements for
classes that want to conform to the interface.
Typically, the supplier of some service states: “If your class conforms to a particular
interface, then I’ll perform the service.” Let’s look at a concrete example. The sort
method of the Arrays class promises to sort an array of objects, but under one condition:
The objects must belong to classes that implement the Comparable interface.
Here is what the Comparable interface looks like:
public interface Comparable
{
　　int compareTo(Object other);
}
This means that any class that implements the Comparable interface is required to have a
compareTo method, and the method must take an Object parameter and return an integer.

转载于:https://www.cnblogs.com/yqskj/articles/2053754.html