Java编程思想（七）

第9章 接口 (Interface)

9.1 抽象类和抽象方法

在 java 中，基类很多时候都只是为了给导出类提供一些公共的通用接口（方法），所以基类只表示一种基本形式。 这时候就有了抽象类的概念。
含有抽象方法的类叫做抽象类。是用 abstract 关键字定义的。抽象方法是说，只有定义，而没有具体实现的方法。

abstract chouxiangfangfa();  // 后面一般不写花括号。

所以这样来看，由于抽象类中含有无实现的方法，所以 抽象类并不能用来创建对象。

抽象类无法创建对象
所以，正如上面第一段所说，抽象类生来就是为了继承而存在的。
这里看一下抽象类和普通类的区别：

1. 抽象类不能创建对象；
2. 抽象方法必须为可以被继承类访问的（因为继承类需要来写抽象方法的具体实现），所以应该为 public/protected，默认的 pub
3. 抽象类的继承类必须给出父类中抽象方法的具体实现，否则，子类也必须 用 abstract 关键字定义成抽象类。

9.2 接口

这里的接口，特指 java 中的 Interface 关键字定义的接口（通常情况下，接口泛指别人调用的方法或者函数）。
接口实际上是对抽象类的进一步深化。抽象类中的抽象方法是没有任何实现的方法，而接口中所有的方法都是只有定义，而没有方法体的方法，是一个 极度抽象类。
接口除了方法外，也可以包含域，但是隐式地被定义为 static & final。
让一个类遵循某个（也可以多个）特定接口，用 implements 关键字，表示 “interface 只是其外貌，现在要说明其具体是如何工作的”。

抽象类和接口的区别：

1. 抽象类可以提供成员方法的实现细节，接口只能是 public abstract 方法；
2. 抽象类中成员变量可以是各种，接口中 只能是 static final
3. 一个类可以继承一个抽象类，而 一个类可以实现多个接口（extends 只能一个，implements 可以多个）

9.3 完全耦合

9.4 java 中的多重继承

这里说的意思就是，我们可以通过接口来实现多继承的形式。这里用 implements A,B,C 这样形式的关键字即可。看下面的代码：这里的接口就可以向上转型（和类的感觉是一样的），所以下面 main() 函数中，是有向上转型处理的。

package Interface;

interface CanFight{
    void fight();
}
interface CanSwim{
    void swim();
}
interface CanFly{
    void fly();
}

class ActionCharacter{
    public void fight(){}
}

class Hero extends ActionCharacter implements CanFight,
CanSwim, CanFly{
    public void swim(){}
    public void fly(){}
}

public class Adventure {
    public static void t(CanFight x){x.fight();}
    public static void u(CanSwim x){x.swim();}
    public static void v(CanFly x){x.fly();}
    public static void w(ActionCharacter x){x.fight();}

    public static void main(String args[]){
        Hero h = new Hero();
        t(h);   // 当做 CanFight 来处理
        u(h);   // 当做 CanSwim 来处理
        v(h);
        w(h);
    }
}

9.5 通过继承来扩展接口

意思是说这里的接口不仅可以 implements 实现，还可以 extends 来继承。和类的继承是一样的。

package Interface;

interface Monster{
    void menace();
}
interface DangerousMon extends Monster{  // 由于继承，DangMon 接口有 2 个方法。
    void destroy();
}
interface Lethal{
    void kill();
}

class DragonZilla implements DangerousMon{  // 这里就实现了 其 2 个方法。
    public void menace(){} //
    public void destroy(){}
}

interface Vampire extends DangerousMon, Lethal{
    void drinkBlood();
}

class VeryBadVampire implements Vampire{
    public void menace(){}
    public void destroy(){}
    public void kill(){}
    public void drinkBlood(){}
}

public class HorrowShow{
    static void u(Monster b){b.menace();}
    static void v(DangerousMon s){s.menace();
    s.destroy();}
    static void w(Lethal l){l.kill();}

    public static void main(String args[]){
        DangerousMon mike = new DragonZilla();
        u(mike);
        v(mike);
        Vampire shine = new VeryBadVampire();   // 向上转型
        u(shine);
        v(shine);
        w(shine);
    }
}

9.6 适配接口

9.7 接口中的域

前面我们说过，接口中的 域 自动声明为 static final。

9.8 嵌套接口

接口可以嵌套在其他的类或接口中。

9.9 接口和工厂 factory

生成遵循某个接口对象的典型方式就是 工厂方法 设计模式。
这里所谓的 “工厂方法” ，就是说用一个方法（这里是 getService()方法）来生成接口对象。如下面代码所示，Service接口有两个继承的接口 Imple1 和 Imple2，而 ServiceFactory 也有两个继承接口 分别可以生成 Imple1 接口对象和 Imple2 对象。

package Interface;

// 说的是接口和工厂

interface Service{
    void method1();
    void method2();
}
interface ServiceFactory{
    Service getService();
}

class Imple1 implements Service{
    Imple1(){}  // Package access
    public void method1(){System.out.println("实现1.方法1");}
    public void method2(){System.out.println("实现1.方法2");}
}
class Imple1Fact implements ServiceFactory{
    public Service getService(){
        return new Imple1();
    }
}

class Imple2 implements Service{
    Imple2(){}  // Package access
    public void method1(){System.out.println("实现2.方法1");}
    public void method2(){System.out.println("实现2.方法2");}
}
class Imple2Fact implements ServiceFactory{
    public Service getService(){
        return new Imple2();
    }
}

public class Factories {
    public static void serviceConsumer(ServiceFactory fact){
        Service s = fact.getService();
        s.method1();
        s.method2();
    }
    public static void main(String args[]){
        serviceConsumer(new Imple1Fact());  // upcast
        serviceConsumer(new Imple2Fact());
    }
}
/*output 
实现1.方法1
实现1.方法2
*/