Java编程思想 -- 接口

抽象类和抽象方法

Java提供一种抽象方法的机制，这种方法是不完整的，仅有声明而没有方法体。包含有抽象方法的类叫做抽象类，该类必须被限定为抽象的

也可以创建一个没有任何抽象方法的抽象类：如果有一个类我们想要阻止产生这个类的任何对象，那么这样做就很有用

抽象类是很有用的重构工具，因为它们可以很容易地将公共方法沿着继承层次结构向上移动

接口

接口产生一个完全抽象的类，它根本没有提供任何具体实现。

接口可以包含域，但这些域隐式地是static和final的，这里的域是指变量这些

接口中方法隐式为public

完全解耦

接口+策略设计模式+设配器模式

这里简单描述一下，比如有一个方法App.exe(OneInterface o);，在使用的时候只需要继承该接口的类就可调用，这是策略模式的一种表现；但是现在已经有一个类，不管其中继承关系多复杂，如果先要调用App.exe(OneInterface o);方法，就只需继承并实现OneInterface接口就可以。

Java中的多重继承

interface CanFight{ void fight(); }

interface CanSwim{ void swim(); }

interface CanFly{ void fly(); }

class Action {
    public void fight(){ }
}

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

这里需要注意的是，CanFight接口与Action类中fight()方法的特征签名是一样的，而且Hero没有提供fight()的定义

再由于上述的App.exe(OneInterface o)的方便，所以我们应该使用接口还是抽象类？？
- 如果要创建不带任何方法定义和成员的基类，那么就应该选择接口而不是抽象类。（方法定义：大概的意思就是方法没有具体实现过程，只是声明）

通过接口继承来扩展接口

interface Monster{
    void menace();
}

interface DangerousMonster extends Monster{
    void destroy();
}

interface Lethal{
    void kill();
}

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

从上面的例子可以看出接口继承扩展接口的实例，这种情况有比较了解一下，一些Android开源框架就涉及到这个。以及接口中嵌套接口的情况，下面分析

一般情况下，只可以将extends用于单一类，但是可以引用多个基类接口。但是像上面所看到的，只需用逗号将接口名一一分隔开即可。

组合接口时的名字冲突

比如前面的CanFIght和Action都有一个相同的void fight()，这种情况没有什么问题。

例子：

interface I1 { void f(); }
interface I2 { int f(int i); }
interface I3 { int f(); }

class C { public int f() { return 1; } }

class C2 implements I1, I2{
    public void f(){ }
    public int f(int i) { return 1; }  // I2
}

class C3 extends C implements I2{
    public int f(int i) { return 1; }  // I2
}

class C4 extends C implements I3{
    public int f() { return 1; }  // C && I3
}

// 下面两种情况有问题
class C5 extends C implements I1{ }  // C: int f()  I1:void f()
interface I4 extends I1, I3{ }  // I1:void f()  I3: int f()

可以看出重载方法仅通过返回类型是区分不开的
所以应尽量避免这种情况发生

接口的适配

这里类似前面的完全解耦的策略设计模式，所以不做多讲

接口中的域

如前面所述，接口中的任何域都是自动static和final和public，所以就成为了Java SE5之前一种很便捷的用来创建常量组的工具。因此，在标识常量的时候，要注意使用大写字母及下划线风格标识。

初始化接口中的域

域是static的，它们就可以在类第一次被加载时初始化，这发生在任何域首次被访问时，而且不能是“空final”，但是可以被非常量表达式初始化。

这些域不是接口的一部分，它们的值被存储在该接口的静态存储区域内

嵌套接口

下面例子分别是在接口内嵌套接口和在类中嵌套接口的情况：

interface E{
    // 接口内的接口
    interface G{
        void f();
    }

    public interface H{
        void f();
    }

    void g();

    // 接口E内的域默认为public
    // private interface I { }
}

class A{
    // 类A内部接口B
    interface B{
        void f();
    }
    public class BImp implements B{
        public void f() { }
    }
    private class BImp2 implements B{
        public void f() { }
    }

    // 类A内部public接口C
    public interface C{
        void f();   
    }
    class CImp implements C{
        public void f() { }
    }
    private class CImp2 implements C{
        public void f() { }
    }

    // 类A内部private接口D
    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();
    }
}

public class TestInterface{
    // B为类A内接口
    public class BImp implements A.B{
        public void f();
    }

    // C为类A内public接口
    class CImp implements A.C{
        public void f();
    }

    // D为类A内private接口
    // class DImp implements A.D{ }

    class EImp implements E{
        public void g();
    }

    // E接口内的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();

        // A.D:不能获取A内部private接口D    
        // A.D ad = a.getD();

        // 
        // A.DImp2 di2 = a.getD();

        // 
        // a.getD().f();

        A a2 = new A();
        a2.reciveD(a.getD());
    }
}

从中可以看出，嵌套接口跟非嵌套接口差不多。

但是private的嵌套接口的情况有点不一样，A.DImp2内部类被实现为public类。但是A.DImp2只能被其自身所使用。你无法说它实现了一个private接口D，因此实现一个private接口只是一种方式，它可以强制该接口中的方法定义不要添加任何类型信息（也就是说，允许向上转型）

getD()方法使我们陷入困境，这个问题与private接口相关：它是一个返回private接口的引用的public方法。对这个方法返回值能做些什么呢？在main()中，可以看到数次尝试使用返回值的行为都失败了。只有一个方式成功，就是将返回值交给有权使用它的对象。就是另一个A通过receiveD()方法来实现的

需要特别注意的是，但实现某个接口时，并不需要实现嵌套在其内部的任何接口

接口与工厂

工厂模式

直接上代码：

//具体编程技能模块
interface ICode {
    void coding();
}

class CodeImplAndroid implements ICode {
    @Override
    public void coding() {
        System.out.println("Coding Android!");
    }
}

class CodeImplPHP implements ICode {
    @Override
    public void coding() {
        System.out.println("Coding PHP!");
    }
}
//创建技能工厂模块
interface IFactory {
    ICode getCodingSkill();
}

class FactoryImplAndroid implements IFactory {
    @Override
    public ICode getCodingSkill() {
        return new CodeImplAndroid();
    }
}

class FactoryImplPHP implements IFactory {
    @Override
    public ICode getCodingSkill() {
        return new CodeImplPHP();
    }
}

public class Main {
    public static void coding(IFactory ifactory){
        ICode code = factory.getCodingSkill();
        code.coding();
    }
}