Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(九)之Interfaces

Interfaces and abstract classes provide more structured way to separate interface from implementation.

　　the abstract class, which is a kind of midway step between an ordinary class and an interface.

Abstract classes and methods

　　abstract void f();

　　A class containing abstract methods is called an abstract class. If a class contains one or more abstract methods, the class itself must be qualified as abstract.

　　It's possible to make a class abstract without including any abstract methods. This is useful when you've got a class in which it doesn't make sense to have any abstract methods, and yet you want to prevent any instances of that class.

　　Abstract classes are also useful refactoring tools, since they allow you to easily move common methods up the inheritance hierarchy.

Interfaces

　　The interface keyword produces a completely abstract class, one that provides no implementation at all.

　　An interface says, "All classes that implement this particular interface will look like this."

　　The interface is used to establish a "protocol" between classes.

　　interface allowed multiple inheritance

　　An interface can also contain fields, but these are implicitly static and final.

　　You can choose to explicitly declare the methods in an interface as public, but they are public even if you don't say it. So wnen you implement an interface, the methods from the interface must be defined as public.

Complete decoupling

　　Creating a method that behaves differently depending on the argument object that you pass it is called the Strategy design pattern. The method contains the fixed part of the algorithm to be performed, and the Strategy contains the part that varies

　　The Strategy is the object that you pass in, and it contains code to be executed.

　　public static void process(Processor p, Object s) {

　　　　p.process(s);

　　}

　　public static void main (String[] args) {
　　　　process(new Upcase(),s);

　　　　process(new Downcase(),s);

　　}

　　However, you are often in the situation of not being able to modify the classes that you want to use. In these cases, you can use the Adapter design pattern.

　　class FilterAdapter implements Processor {

　　　　Filter filter;

　　　　public FilterAdapter (Filter filter) {

　　　　　　this.filter = filter;

　　　　}

　　　　public String name () { return filter.name();}

　　　　public Waveform process (Object input) {

　　　　　　return filter.process((Waveform)input);

　　　　}

"Multiple inheritance" in Java

　　A class can only extends one class, and can implements one or more interface

　　When you combine a concrets class with interfaces this way, the concrete class must come first, then the interfaces.

　　The resons for interfaces:

　　　　1. to upcast to more than one base type.

　　　　2. (the same as using an abstract base class) to prevent the client programmer from makig an object of this class and to establish that it is only an interface.

　　In fact, if you know somethins is going to be a base class, you can consider making it an interface.

Extending an interface with inheritance　　

　　You can easily add new method declarations to an interface by using inheritance, and you can also combine several interfaces into a new interface with inheritance.

　　Name collisions when combining interfaces

　　overloaded methods cannot differ only by return type.

　　Using the same method names in different interfaces that are intended to be combined generally causes confusion in the readability of the code, as well. Strive to avoid it.

Adapting to an interface

　　A common use for interfaces is the Strategy design pattern.

Fields in interfaces　　

　　Because any fields you put into an interface are automatically static and final, the interface is a convenient tool for creating groups of constant values. Before Java SE5, this was the only way to produce the same effect as an enum.

　　The fields in an interface are automatically public.

　　Initializing fields in interfaces

　　Fields defined in interfaces cannot be "blank finals", but they can be initialized with non-constant expressions.

　　the fields, of course, are not part of the interface. The values are stored in the static storage area for that interface.

Nesting interfaces

　　nesting an interface, these can have public 、package-access or private visibility.

　　Implementing a private interface is a way to force the definition of the methods in that interface without adding any type information.

　　

package interfaces.nesting;

class A {
　　interface B {
　　　　void f();
　　}

　　public class BImp implements B {
　　　　public void f() {
　　　　}
　　}

　　private class BImp2 implements B {
　　　　public void f() {
　　　　}
　　}

　　public interface C {
　　　　void f();
　　}

　　class CImp implements C {
　　　　public void f() {
　　　　}
　　}

　　private class CImp2 implements C {
　　　　public void f() {
　　　　}
　　}

　　private interface D {
　　　　void f();
　　}

　　private class DImp implements D {
　　　　public void f() {
　　　　}
　　}

　　public class DImp2 implements D {
　　　　public void f() {
　　　　}
　　}

　　public D getD() {
　　　　return new DImp2();
　　}

　　private D dRef;

　　public void receiveD(D d) {
　　　　dRef = d;
　　　　dRef.f();
　　}
}

interface E {
　　interface G {
　　　　void f();
　　}

　　// Redundant "public":
　　public interface H {
　　　　void f();
　　}

　　void g();
　　// Cannot be private within an interface:
　　// ! private interface I {}
}

public class NestingInterfaces {
　　public class BImp implements A.B {
　　　　public void f() {
　　　　}
　　}

　　class CImp implements A.C {
　　　　public void f() {
　　　　}
　　}

　　// Cannot implement a private interface except
　　// within that interface’s defining class:
　　// ! class DImp implements A.D {
　　// ! public void f() {}
　　// ! }
　　class EImp implements E {
　　　　public void g() {
　　　　}
　　}

　　class EGImp implements E.G {
　　　　public void f() {
　　　　}
　　}

　　class EImp2 implements E {
　　　　public void g() {
　　　　}

　　　　class EG implements E.G {
　　　　　　public void f() {
　　　　　　}
　　　　}
　　}

　　public static void main(String[] args) {
　　　　A a = new A();
　　　　// Can’t access A.D:
　　　　// ! A.D ad = a.getD();
　　　　// Doesn’t return anything but A.D:
　　　　// ! A.DImp2 di2 = a.getD();
　　　　// Cannot access a member of the interface:
　　　　// ! a.getD().f();
　　　　// Only another A can do anything with getD():
　　　　A a2 = new A();
　　　　a2.receiveD(a.getD());
　　}
}

　　The rules about interfaces-- that all interfaces elements must be public--are strictly enforces here, so an interface nested within another interface is automatically public and cannot be made private.

　　Notice that when you implement an interface, you are not required to implement any interfaces nested within. Also, private interfaces cannot be implemented outside of their defining classes.

Interfaces and factories

　　An interfaces is intended to be a gateway to multiple implementations, and a typical way to produce objects that fit the interface is the Factory Method design pattern.

　　You call a creation method on a factory object which produces an implementation of the interface--this way, in theory, your code is completely isolated from the implementation of the interface.

Summary

　　Almost anytime you create a class, you could instead create an interface and a factory.

　　Interfaces should be something you refactor to when necessary, rather than installing the extra level of indirection everywhere, along with the extra complexity.

　　An appropriate guideline is to prefer classes to interfaces. Start with classes, and if it becomes clear that interfaces are necessary, then refactor. Interfaces are a great tool, but they can easily be overused.