Java基础——接口

接口

1. 接口是一种抽象类型，关键字interface，是抽象方法的集合。
2. 接口不能实例化，可以被实现。
3. 接口中的方法都是抽象方法(默认public abstract )，没有构造方法。没有成员变量，默认都是静态常量(默认public static final)。
4. 一个类通过关键字implements实现接口，接口中定义的所有抽象方法必须实现。但是，抽象类就不强制要求必须实现接口的抽象方法。
5. 接口可以继承接口，而且不同于类的是可以多继承，格式：A extends B,C…

示例代码体会：
代码通过标记接口分类，并通过不同的继承和实现效果，按照优先级展示结果。

@1. 主要定义了6个接口，其中包含标记接口、接口多继承、定义抽象方法、定义静态常量效果。
@1.1 Animal.java、Humans.java、Others.java可以作为顶层标记接口，分别标记了动物、人类、未知三个种类。

什么是标记接口？我们在编程时可以通过定义没有方法和变量的空接口，作为一个抽象类型标记，为继承它的接口或实现它的类标记一个类型，思考下这有什么意义呢？

/**
 * @Description : 标记接口（没有定义函数或变量）
 */
public interface Animal {
}

public interface Humans {
}

public interface Others {
}

@1.2 Beneficial.java、Pests.java作为二级接口，继承了Animail.java接口（意味着它们被标记为Animail），并分别定义了各自的抽象方法和静态常量。

为什么接口中的方法必须是公开抽象的？变量必须是公开静态常量？
public当然是为了它的实现类能够调用。
抽象方法是接口的特性，接口只能定义抽象方法，不能具体实现，只能由实现类来完成。
static final，因为接口不能实例化，所以必须静态加载，而final自然是为了保证值不变。

/**
 * @Description : 接口可以继承接口，定义抽象方法和静态常量。
 */
public interface Beneficial extends Animal {

    public static final String BENE_PRO_VALUE = "useful";

    public abstract String getBeneProValue();

}

/**
 * @Description : 接口可以继承接口，定义抽象方法和静态常量。
 */
public interface Pests extends Animal {

    public static final String PESTS_PRO_VALUE = "harm";

    public abstract String getPestsProValue();

}

@1.3 Godzilla.java展示了多继承效果。GodzillaImpl.java是实现类，可以发现实现类必须实现自身及父接口的所有抽象方法。

/**
 * @Description : 接口可以继承一个或多个接口。
 */
public interface Godzilla extends Beneficial,Pests {
}

/**
 * @Description : 一个类实现接口时，如果接口继承了其它一个或多个接口时，应实现所有接口的抽象方法。
 */
public class GodzillaImpl implements Godzilla {

    private static final String GODZILLAIMPL_VALUE = "godzilla";

    @Override
    public String getBeneProValue() {
        return BENE_PRO_VALUE;
    }

    @Override
    public String getPestsProValue() {
        return PESTS_PRO_VALUE;
    }

    private String getGodzillaimplValue(){
        return GODZILLAIMPL_VALUE+"&"+BENE_PRO_VALUE+"&"+PESTS_PRO_VALUE;
    }
}

@2. 实现类
@2.1 Droy.java 实现了Humans.java接口。

/**
 * @Description :
 */
public class Droy implements Humans {

    private static final String DROY_NAME = "Droy Zhou";

    private String getDroyName(){
        return DROY_NAME;
    }
}

@2.2 Et.java实现了Others.java接口。

/**
 * @Description :
 */
public class Et implements Others {

    private static final String ET_VALUE = "et";

    private String getEtValue(){
        return ET_VALUE;
    }
}

@2.3 Frog.java 实现了Beneficial.java接口。

/**
 * @Description :
 */
public class Frog implements Beneficial {

    private static final String FROG_VALUE = "frog";

    @Override
    public String getBeneProValue() {
        return BENE_PRO_VALUE;
    }

    private String getFrogValue(){
        return FROG_VALUE+"&"+BENE_PRO_VALUE;
    }
}

@2.4 Locust.java 实现了Pests.java接口。

/**
 * @Description :
 */
public class Locust implements Pests {

    private static final String LOCUST_VALUE = "locust";

    @Override
    public String getPestsProValue() {
        return PESTS_PRO_VALUE;
    }

    private String getLocustValue(){
        return LOCUST_VALUE+PESTS_PRO_VALUE;
    }
}

@2.5 Sparrow.java直接实现了标记接口Animal.java。

/**
 * @Description :
 */
public class Sparrow implements Animal {

    private static final String SPARROW_VALUE = "sparrow";

    private String getSparrowValue(){
        return SPARROW_VALUE;
    }
}

@2.6 Monster.java实现了多个接口效果，这样它必须实现所有接口的抽象方法。

/**
 * @Description : 一个类可以同时实现多个接口，而且必须实现每一个接口的抽象方法。
 */
public class Monster implements Animal,Beneficial,Pests,Humans,Others {

    private static final String MONSTER_VALUE = "monster";

    @Override
    public String getBeneProValue() {
        return BENE_PRO_VALUE;
    }

    @Override
    public String getPestsProValue() {
        return PESTS_PRO_VALUE;
    }

    private String getMonsterValue(){
        return MONSTER_VALUE+"&"+BENE_PRO_VALUE+"&"+PESTS_PRO_VALUE;
    }
}

@3. 最后通过main体会接口的用法及效果。

/**
 * @Description :
 */
public class InterFacesMain {
    public static void main(String[] args) {
        Object[] objects = new Object[]{new Droy(), new Frog(), new Locust(), new Sparrow(), new Et(), new GodzillaImpl()};
        System.out.println("开始分析样本:");
        for (int i = 0; i < objects.length; i++) {
            if (objects[i] instanceof Animal) {
                if (objects[i] instanceof Godzilla) {
                    System.out.println(i + 1 + "    这是哥斯拉！");
                } else if (objects[i] instanceof Beneficial) {
                    System.out.println(i + 1 + "    这是一只益虫！");
                } else if (objects[i] instanceof Pests) {
                    System.out.println(i + 1 + "    这是一只害虫！");
                } else {
                    System.out.println(i + 1 + "    这是一只不好不坏的动物！");
                }
            } else if (objects[i] instanceof Humans) {
                System.out.println(i + 1 + "    这是一个人类！");
            } else {
                System.out.println(i + 1 + "    这是一种未知物！");
            }
        }
    }
}

输入出结果：

开始分析样本:
1    这是一个人类！
2    这是一只益虫！
3    这是一只害虫！
4    这是一只不好不坏的动物！
5    这是一种未知物！
6    这是哥斯拉！

可以更改代码体验更多效果帮助我们直观的理解接口效果，体会它的意义。
点击下载>>>示例源代码