读Java编程思想随笔の接口

　　接口和抽象类为我们提供了一种将接口和实现分离的更加结构化的方法。

　　这种机制在编程语言中并不通用。例如，C++对这些概念只有间接的支持。在Java中存在语言关键字这个事实表明人们认为这些思想是很重要的，以至于要提供对它们的直接支持。

　　首先，我们来学习抽象类，它是普通的类与接口之间的中庸之道。尽管在构建具有某些未实现的方法的类时，你的第一想法可能是创建接口，但是抽象类仍旧是用于此目的重要而必须的工具。因为你不可能总是使用纯接口。

　　抽象类，如果一个类包含一个或多个抽象方法，该类必须被限定为抽象的（否则编译通不过）。但是在抽象类中，并不是要求所有方法都是抽象方法。

　　例如下面结构图：

　　

　　在Instrument抽象类中，有play()和adjust()的两个抽象方法，也有what()的普通方法。

/**
 * @author yxm
 * @date 2015/11/4.
 * @company 中国奇奇科技有限公司
 * @description abstract示例
 */
public class Music4 {
    static void tune(Instrument i){
        i.play(Note.MIDDLE_C);
    }
    static void tuneAll(Instrument[] e){
        for (Instrument i :e){
            tune(i);
        }
    }
    public static void main(String[] args) {
       Instrument[] orchestra = {new Wind(),new Percussion(),new Stringed(),new Brass(),new Woodwind()};
        tuneAll(orchestra);
    }
}
abstract class Instrument{
    private int i;
    public abstract void play(Note e);
    public String what(){
        return "Instrument";
    }
    public abstract void adjust();
}
class Wind extends Instrument {
    public void play(Note n){
        System.out.println("Wind.play()"+n);
    }
    public String what(){
        return "Wind";
    }
    public void adjust(){

    }
}
class Percussion extends Instrument {
    public void play(Note n){
        System.out.println("Percussion.play()"+n);
    }
    public String what(){
        return "Percussion";
    }
    public void adjust(){

    }
}
class Stringed extends Instrument {
    public void play(Note n){
        System.out.println("Stringed.play()"+n);
    }
    public String what(){
        return "Stringed";
    }
    public void adjust(){

    }
}
class Brass extends Wind{
    public void play(Note n){
        System.out.println("Brass.play()"+n);
    }
    public void adjust(){
        System.out.println("Brass.adjust()");
    }
}
class Woodwind extends Wind{
    public void play(Note n){
        System.out.println("Woodwind.play()"+n);
    }
    public String what(){
        return "Woodwind";
    }
}
//Wind.play()MIDDLE_C
//Percussion.play()MIDDLE_C
//Stringed.play()MIDDLE_C
//Brass.play()MIDDLE_C
//Woodwind.play()MIDDLE_C

　　接口

　　interface关键字使抽象的概念更向前迈进了一步。abstract关键字使人们类中创建一个或多个没有任何定义的方法--提供了接口部分，但是没有提供任何相应的具体实现，这些实现是由此类的继承者创建的。interface关键字创建了一个完全抽象的类，它根本没有提供任何具体实现。它允许创建者创建方法名、参数列表和返回类型，但是没有方法体。接口只提供了形式，而未提供任何具体实现。

　　但是，interface并不仅仅是一个极度抽象的类，因为它允许人们通过创建一个能够被向上转型为多种基类的类型，来实现某种类似多重继变种的特性。

　　接口中也包含域，但是这些域隐式地被声明为public static final类型。

　　

　　这张图非常直白的讲明了抽象和接口在被继承或实现的使用时的差别。而且，我们也可以从Woodwind和Brass类中看到，一旦实现了某个接口，其实现就变成了一个普通的类，就可以按照常规方式扩展它。

/**
 * @author yxm
 * @date 2015/11/4.
 * @company 中国奇奇科技有限公司
 * @description 接口使用
 */
public class Music5 {
    static void tune(com.qiqi.interfaces.interfaces.Instrument i){
        i.play(Note.MIDDLE_C);
    }
    static void tuneAll(com.qiqi.interfaces.interfaces.Instrument[] e){
        for (com.qiqi.interfaces.interfaces.Instrument i :e){
            tune(i);
        }
    }
    public static void main(String[] args) {
        //upcasting during addition to array
        Instrument[] orchestra = {new Wind(),new Percussion(),new Stringed(),new Brass(),new Woodwind()};
        tuneAll(orchestra);
    }
}
interface Instrument{
    int VALUE = 5;
    void play(Note e);//Automatically public
    void adjust();
}
class Wind implements Instrument{

    @Override
    public void play(Note e) {
        System.out.println(this+".play()"+e);
    }

    @Override
    public void adjust() {
        System.out.println(this+".adjust()");
    }

    @Override
    public String toString() {
        return "Wind";
    }
}
class Percussion implements Instrument{

    @Override
    public void play(Note e) {
        System.out.println(this+".play()"+e);
    }

    @Override
    public void adjust() {
        System.out.println(this+".adjust()");
    }

    @Override
    public String toString() {
        return "Precussion";
    }
}
class Stringed implements Instrument{

    @Override
    public void play(Note e) {
        System.out.println(this+".play()"+e);
    }

    @Override
    public void adjust() {
        System.out.println(this+".adjust()");
    }

    @Override
    public String toString() {
        return "Stringed";
    }
}
class Brass extends Wind{
    @Override
    public String toString() {
        return "Brass";
    }
}
class Woodwind extends Wind{
    @Override
    public String toString() {
        return "Woodwind";
    }
}

　　完全解耦

　　只要一个方法操作的是类而非接口，那么你就只能使用这个类及其子类。如果你想要将这个方法应用于不在此继承结构中的某个类，那么你就会触霉头了。接口可以在很大程度上放宽这种限制，因此，它可以使得我们编写可复用性更好的代码。

　　基类作为参数列表

/**
 * @author yxm
 * @date 2015/11/5 20:17
 * @company 中国奇奇科技有限公司
 * @description 完全解耦 基类作为参数列表
 */
public class Apply {
    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);
    }
    public static void process(Processor p,Object s){
        System.out.println("Using Processor "+p.name());
        System.out.println(p.process(s));
    }
}
class Processor{
    public String name(){
        return getClass().getSimpleName();
    }
    Object process(Object input){
        return input;
    }
}
class Upcase extends Processor{
    String process(Object input){
        return ((String)input).toUpperCase();
    }
}
class Downcase extends Processor{
    String process(Object input){
        return ((String)input).toLowerCase();
    }
}
class Splitter extends Processor{
    String process(Object input){
        return Arrays.toString(((String)input).split(" "));
    }
}
//Using Processor Upcase
//DISAGREEMENT WITH BELIEFS IS BY DEFINITION INCORRECT
//Using Processor Downcase
//disagreement with beliefs is by definition incorrect
//Using Processor Splitter
//[Disagreement, with, beliefs, is, by, definition, incorrect]

　　接口作为参数列表

public interface Processor {
    String name();
    Object process(Object input);

}

public class Apply {
    public static void process(Processor p,Object s){
        System.out.println("Using Processor "+p.name());
        System.out.println(p.process(s));
    }
}

public abstract class StringProcessor implements Processor {
    @Override
    public String name() {
        return getClass().getSimpleName();
    }
    public abstract String process(Object input);
    public static String s = "";
    public static void main(String[] args) {
        Apply.process(new Upcase(),s);
        Apply.process(new Downcase(),s);
        Apply.process(new Splitter(),s);
    }
}
class Upcase extends StringProcessor{
    public String process(Object input){
        return ((String)input).toUpperCase();
    }
}
class Downcase extends StringProcessor{
    public String process(Object input){
        return ((String)input).toLowerCase();
    }
}
class Splitter extends StringProcessor{
    public String process(Object input){
        return Arrays.toString(((String) input).split(" "));
    }
}

　　多重继承

　　接口不仅仅是一种更纯粹形式的抽象类，它的目标比这要高。因为接口是根本没有任何具体实现的---也就是说，没有任何与接口相关的存储；因此，也就无法阻止多个接口的组合。这一点很有价值，因为你有时需要去表示"一个x是一个a和一个b或者一个c"。我们可以去继承任意多个接口，并可以向上转型为每个接口，因为每个接口都是一个独立类型。

/**
 * @author yxm
 * @date 2015/11/7 12:27
 * @company 中国奇奇科技有限公司
 * @description 多重继承
 */
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();
    }

}
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(){}
}

　　上面的例子展示了使用接口的核心原因：为了能够向上转型为多个基类型（以及由此而带来的灵活性）。然而，使用接口的第二个原因却是与使用抽象基类相同：防止客户端程序员创建该类的对象，并确保这仅仅是建立了一个接口。这就带来了一个问题：我们应该使用接口还是抽象类？如果要创建不带任何方法定义和成员变量的基类，那么就应该选择接口而不是抽象类。事实上，如果知道某事物应该成为一个基类，那么第一选择应该是使他成为一个接口。

　　通过继承来扩展接口

　　通过继承，可以很容易的在接口中添加新的方法声明，还可以通过继承在新接口中组合数个接口。这两种情况都可以获得新的接口。

/**
 * @author yxm
 * @date 2015/11/7 12:33
 * @company 中国奇奇科技有限公司
 * @description 通过继承来扩展接口
 */
public class HorrorShow {
    static void u(Monster b){
        b.menace();
    }
    static void v(DangerousMonster d){
        d.menace();
        d.destroy();
    }
    static void w(Lethal l){
        l.kill();
    }
    public static void main(String[] args) {
        DangerousMonster dang = new DragonZilla();// 接口 = new 实现类（）
        u(dang);
        v(dang);
        Vampire vlad = new VeryBadVampire();
        u(vlad);
        v(vlad);
        w(vlad);
    }
}
interface Monster{
    void menace();
}
interface  DangerousMonster extends Monster{
    void destroy();
}
interface Lethal{
    void kill();
}
class DragonZilla implements DangerousMonster{
    public void menace(){}
    public void destroy(){}
}
interface Vampire extends DangerousMonster,Lethal{//接口继承可以继承两个接口，三观尽毁
    void drinkBlood();
}
class VeryBadVampire implements Vampire{//如果要实现，就必须实现Vampire接口和Vampire继承结构中基类
    public void menace(){}
    public void destroy(){}
    public void kill(){}
    public void drinkBlood(){}
}

 　  适配接口

　   接口最吸引人的原因之一就是允许同一个接口具有多个不同的具体实现。在简单的情况中，它的体现形式通常是接受接口类型的方法，而该接口的实现和向该方法传递的对象则取决于方法的使用者。

　　因此，接口一种常见的用法就是上面提到的策略设计模式，此时你编写一个执行某些操作的方法，而该方法接受一个同样是你指定的接口。你主要就是要声明：“你可以用任何你想要的对象来调用我的方法，只要你的对象遵循我的接口。”这使得你的方法更加灵活、通用，并更具有复用性。

　　例如，在Java SE5中的Scanner类的构造器接受的就是一个Readable接口。你会发现Readable没有用作Java标准类库其他任何方法的参数，它是单独为Scanner创建的，以使得Scanner不必将参数限定为某个特定类。通过这种方式，Scanner可以作用于更多的类型。如果你创建了一个新的类，并且想让Scanner作用于它，那么你就应该实现Readable接口。

public class RandomWords implements Readable{
    private static Random rand = new Random(47);
    private static final char [] capitals = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
    private static final char [] lowers = "abcdefghijklmnopqrstuvwxyz".toCharArray();
    private static final char [] vowels = "ieaou".toCharArray();
    private int count;
    public RandomWords(int count){
        this.count = count;
    }
    @Override
    public int read(CharBuffer cb) throws IOException {
        if(count--==0)
            return -1;
        cb.append(capitals[rand.nextInt(capitals.length)]);
        for (int i = 0;i < 4; i++){
            cb.append(vowels[rand.nextInt(vowels.length)]);
            cb.append(lowers[rand.nextInt(lowers.length)]);
        }
        cb.append(" ");
        return 10;
    }

    public static void main(String[] args) {
        Scanner s = new Scanner(new RandomWords(10));
        while (s.hasNext())
            System.out.println(s.next());
    }
}
//Yizeruyic
//Fowenucor
//Goeizamom
//Rieuuicao
//Nuoidesaw
//Higeaakux
//Ruqacabui
//Numisetah
//Kuuuuozog
//Wiqazeyoy

　　初始化接口中的域

　　接口中的域自动默认为public static final。

　　在接口中定义的域不能是空final，但是可以被非常量表达式初始化。

　　既然域是static的，它们就可以在类第一次加载时被初始化，这发生在任何域首次被访问时。

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

public interface RandVals {
    Random RAND = new Random(47);
    int RANDOM_INT = RAND.nextInt(10);
    long RANDOM_LONG = RAND.nextLong()*10;
    float RANDOM_FLOAT = RAND.nextFloat()*10;
    double RANDOM_DOUBLE = RAND.nextDouble()*10;
}

public class TestRandVals {
    public static void main(String[] args) {
        System.out.println(RandVals.RANDOM_INT);
        System.out.println(RandVals.RANDOM_LONG);
        System.out.println(RandVals.RANDOM_DOUBLE);
        System.out.println(RandVals.RANDOM_FLOAT);
    }
}
//        8
//        -32032247016559954
//        1.6020656493302599
//        0.534122