java编程思想读书笔记 第九章 接口

1、抽象类和抽象方法

创建抽象类是希望通过这个通用接口操纵一系列类。如果一个类包含大于等于一个抽象方法，那么这个类就是抽象类，必须用abstract关键字来限定这个抽象类。
如果试图直接创建该抽象类的对象，编译器会报错。
如果抽象类的子类没有为基类的抽象方法提供定义，那么这个导出类依旧是抽象类。
抽象类也可以不包含任何抽象方法，单纯的用abstract限定类。（该类不能产生对象）

2、接口
interface这个关键字替代class关键字，产生了一个完全抽象的类。接口只提供形式，未提供任何具体实现。
接口被用了建立类与类之间的协议。接口也可以包含域，但是这些域隐式的是static和final的。因此，其中定义的成员变量，是static&final的。
implenments关键字可以跟一组接口，extends关键字只能跟一个基类。
接口中的方法必须是public的，隐式的被声明public的，如果要显示声明，它们也必须被声明为public的。否则在继承的过程中，可访问权限被降低，这是java编译器所不允许的。

3、完全解耦
策略设计模式：创建一个能够根据传递参数对象不同而具有不同行为的方法。比如：

class Processor {
public String name() {
return getClass().getSimpleName();
}
Object process(Object input) { return input; }
}
class Upcase extends Processor {
String process(Object input) { // Covariant return
return ((String)input).toUpperCase();
}
}
class Downcase extends Processor {
String process(Object input) {
return ((String)input).toLowerCase();
}
}
class Splitter extends Processor {
String process(Object input) {
// The split() argument divides a String into pieces:
return Arrays.toString(((String)input).split(” “));
}
}
public class Apply {
public static void process(Processor p, Object s) {
System.out.print(“Using Processor ” + p.name());
System.out.print(p.process(s));
}
public static String s =
“Disagreement with beliefs is by definition incorrect”;
public static void main(String[] args) {
process(new Upcase(), s);
process(new Downcase(), s);
process(new Splitter(), s);
}
}

4、java中的多重继承
java没有任何与接口相关的存储，因此可以继承任意多个接口。\
使用接口的核心原因：为了能够向上转型为多个基本类型。顺带可以防止客户端程序员创建该类的对象。

5、通过继承扩展接口
extends只能用于单一类，但是接口继承时却可以引用多个接口，用逗号分开。
interface Interface1 extends Interface2，Interface3{}
接口无法用implements来实现别的接口，必须用extends。
应该尽量避免组合的多个接口中包含相同方法名，这样会造成代码可读性的混乱。
第九章6-10小节的内容
6、适配接口
接口最吸引人的原因之一就是允许同一个接口具有多个不同的具体实现。在简单的情况中，它的提现形式通常是一个接受接口类型的方法，而该接口的实现和该方法的传递的对象则取决于方法的使用者。
7、接口中的域
因为你放入接口中的任何域都自动是static和final的，所以接口就成为了一种很便捷的用来创建常量组的工具。请注意，java中标识具有常量初始化值的static、final是，会使用大写字母的风格（在一个标识符中用下划线来分隔多个单词）。接口中的域自动是public的，所以显式地指明这点。
（1）在接口中定义的域不能是“空final”，但是可以被非常量表达式初始化。例如：在接口中这样定义int RANDOM_INT = RAND.nextInt(10);
域是static的，他妈就可以在类第一次初始化被加载时初始化，这发生在任何域首次被访问时。注意：这些域不是接口的一部分，它们的值被存储在该接口的静态存储域。

8、嵌套接口
接口可以嵌套在类或其他接口中。在类中嵌套接口的语法是相当显而遇见的，就像非嵌套接口一样，可以拥有public和“包访问”两种可视性。注意，当实现某个接口时，并不需要实现嵌套在其内部的任何接口。而且，private接口不能在定义它的类之外被实现。

9、接口与工厂
接口时实现多继承的途径，而生成遵循某个接口的对象的典型方式就是工厂方法设计模式。这与直接调用构造器不同，我们在工厂对象上调用的是创建方法，而该工厂对象将生产接口的某个实现的对象。理论上，通过这种方式，我们的代码将完全与接口的实现分离，这就使得我们可以透明地将某个实现替换为另一个实现。例子 如下：
public interface Service {
void method1();
void method2();
}

public interface ServiceFactory{
Service getService();
}
public class Implementionl implements Service{

@Override
public void method1() {
    System.out.println("Implementionl method1");
}
@Override
public void method2() {
    System.out.println("Implementionl method2");
}

}
public class Implemention1Factory implements ServiceFactory{

@Override
public Service getService() {
    // TODO Auto-generated method stub
    return new Implementionl();
}

}
public class Implemention2 implements Service{

@Override
public void method1() {
    System.out.println("Implemention2 method1");
}
@Override
public void method2() {
    System.out.println("Implemention2 method2");

}

}
public class Implemention2Factory implements ServiceFactory{

@Override
public Service getService() {
    return new Implemention2();
}

}
public class Factories {
public static void serviceConsumer(ServiceFactory factory) {
Service service = factory.getService();
service.method1();
service.method2();
}
public static void main(String[] args) {
serviceConsumer(new Implemention1Factory());
serviceConsumer(new Implemention2Factory());

}

}
在这个例子中，如果不是使用工厂方法，这些代码就必须在某处指定将要创建的Service的确切类型，以便调用合适的构造器。

10、总结
在做代码设计的时候，恰当的原则是优先选择类而不是接口。接口是一种重要的工具，但是我们在实际应用的过程中，不能滥用。