Java学习之接口

接口讲解内容：

1. 接口的概念。

2. Java8和Java9中接口的区别。

3. 接口的继承。

4. 接口和抽象类。

5. 面向接口编程。

1，接口的概念

接口相当于定义了一种规范，接下来的某一批类都要遵守这种规范，接口体现的是规范和实例分离的设计哲学。

让规范和实现分离正是接口的好处，让系统的各部分之间面向接口进行耦合，是一种松耦合的设计。

所以接口就是一组公用的方法。

2，Java8和Java9中接口的区别

因为接口是一种规范，所以接口中不含有构造器和初始化的部分。

接口中可以包含成员变量，方法，类方法，内部类定义。

Java9和Java8的区别在于多了一个私有方法，这个方法作为工具方法，为接口中的默认方法和类方法提供支持，并且私有方法可以出现方法体。

在接口中定义成员变量的时候，如果不加修饰词，系统会自动匹配public static final 修饰符

重点：接口中的普通方法不能具有方法体，但是类方法，默认方法，私有方法必须有。

看下面的代码：

public interface Output {
    int MAX_CACHE_LINE=50;
    void out();
    //普通方法
    void getData(String msg);
    //默认方法用default修饰
    default void print(String...msgs){
        for(String msg:msgs){
            System.out.println(msg);
        }
    }
    default void test(){
        System.out.println("默认的test（）方法");
    }
    static String staticTest(){
        return "接口中的类方法";
    }
    //java9可以实现
//    private void foo(){
//        System.out.println("foo私有方法");
//    }
}
// interface Product{
//    int getProductTime();
//}

上面就是Java8中的接口中方法的实现。

3，接口的继承

接口的继承和类的继承不一样，接口支持多继承，多个父接口之间通过英文逗号隔开。

看下面的代码：

 interface  InterfaceA {
    int A=5;
    void testA();
}
interface InterfaceB{
    int B=6;
    void testB();
}
interface InterfaceC extends InterfaceA,InterfaceB{
    int C=7;
}

public class InterfaceExtendsTest {
    public static void main(String[] args) {
        System.out.println(InterfaceC.A);
        System.out.println(InterfaceC.B);
        System.out.println(InterfaceC.C);
    }
}

输出结果：

5

6

7

上面的接口c继承了a，b，所以通过c可以访问a,b中的常量。

4，使用接口

接口不能用于创建实例，但是接口中可以声明引用类型变量，归纳接口的用途如下所示：

1. 定义变量，也可用于进行强制类型转换。
2. 调用接口中定义的常量
3. 被其他类实现

重点：一个类实现多个或者一个接口的之后，这个类必须完全实现接口中定义的抽象方法，否则该类继承抽象方法就变成了抽象类了。

看一个实现接口的类：

public interface Output {
    int MAX_CACHE_LINE=50;
    void out();
    //普通方法
    void getData(String msg);
    //默认方法用default修饰
    default void print(String...msgs){
        for(String msg:msgs){
            System.out.println(msg);
        }
    }
    default void test(){
        System.out.println("默认的test（）方法");
    }
    static String staticTest(){
        return "接口中的类方法";
    }
    //java9可以实现
//    private void foo(){
//        System.out.println("foo私有方法");
//    }
}
// interface Product{
//    int getProductTime();
//}
public interface  Product {
    int getProduceTime();
}

public class Printer implements Output,Product{
    private String[] printData= new String[MAX_CACHE_LINE];
    private int dataNum = 0;
    public void out(){
        while (dataNum>0){
            System.out.println("打印机打印："+printData[0]);
            System.arraycopy(printData,1,printData,0,--dataNum);
        }
    }
    public void getData(String msg){
        if(dataNum>=MAX_CACHE_LINE) {
            System.out.println("添加失败");
        }
        else {
            printData[dataNum++]=msg;
        }
    }
    public int getProduceTime(){
        return 45;
    }

    public static void main(String[] args) {
        Output o= new Printer();
        o.getData("大佬大佬");
        o.getData("等等我");
        o.out();
        o.print("大佬","大佬","等等我");
        o.test();
        Product p=new Printer();
        System.out.println(((Printer) p).getProduceTime());
    }
}

从上面的程序可以看出，Printer类实现了Outout接口和Product接口，因此Printer类就好像是这两个“类”的子类，这就是Java模拟的多继承。

5，接口和抽象类

1，相似之处

1. 接口和抽象类都不能被实例化。
2. 接口和抽象类都包含抽象方法，实现接口或继承抽象类都必须实现这些抽象方法

2，区别之处：

1. 抽象类中可以包含普通方法，而接口则不行。
2. 抽象类中既可以定义静态常量，也可以定义普通成员变量，但是接口只能是静态变量。
3. 接口中不含构造器和初始化块，但是抽象类都具有

6，面向接口进行编程

接口体现的是一种规范和实现分离的设计哲学，充分利用接口可以极好的降低程序各板块之间的耦合，从何提高程序的可扩展性和可维护性。下面介绍两种模式。

1. 简单工厂模式

假设程序中有个Computer类需要组合一个输出设备，假设让Computer类组合一个Printer对象，如果有一天系统需要进行重构，使用BetterPrinter来代替，这就需要打开Computer类进行修改，如果有类似很多个Computer类，那么就会造成很大麻烦。

为了避免这个问题，工厂模式建议让Computer类组合一个Output类型的对象，将Computer类与Printer类完全分离，但是实际还是进行了组合，当系统改变为BetterPrinter对象时，系统不受影响。

看下面的代码：

public class Computer {
    private Output out;
    public Computer(Output out){
        this.out=out;
    }
    public void keyIn(String msg){
        out.getData(msg);
    }
    public void print(){
        out.out();
    }
}

上面的代码实现与Printer类完全分离，只是与Output接口耦合，创建Output对象由下面的代码产生

public class OutputFactory {
    public Output getOutput(){
        //return new Printer();
        return new BetterPrinter();
    }

    public static void main(String[] args) {
        OutputFactory of=new OutputFactory();
        Computer c= new Computer(of.getOutput());
        c.keyIn("dalao");
        c.keyIn("dengwo");
        c.print();
    }
}

系统需要做出改变，只需要在getOutput中进行改变

public class BetterPrinter implements Output {
    private String[] printData = new String[MAX_CACHE_LINE];
    private int dataNum = 0;

    public void out() {
        while (dataNum > 0) {
            System.out.println("打印机打印：" + printData[0]);
            System.arraycopy(printData, 1, printData, 0, --dataNum);
        }
    }

    public void getData(String msg) {
        if (dataNum >= MAX_CACHE_LINE) {
            System.out.println("添加失败");
        } else {
            printData[dataNum++] = msg;
        }
    }
}

运行结果：

dalao

dengwo

2，命令模式

假设这样一个场景，某个方法需要实现某个行为，但是这个方法具体的实现无法确定，必须等到执行该方法时才可以确定。

对于这样的需求，必须把”处理行为“作为参数传入该方法，这就可以考虑使用接口来实现。

看下面的代码：

package lee;

public interface Command {
    //定义方法用于封装”处理方法“
    void process(int[]target);
}

上面的方法没有方法体，因为还没有确定方法的实现。

下面确定一个处理类，包含process方法，但是该方法无法确定处理方式，所以定义一个Command参数，用来负责处理行为。

代码如下：

package lee;

public class ProcessArray {
    public void process(int[]target,Command cmd){
        cmd.process(target);
    }
}

通过一个接口就可以实现ProcessArray类和处理行为的分离，只有调用方法时才可以真正传入一个Command对象，确定处理行为。

import lee.AddCommand;
import lee.PrintCommand;
import lee.ProcessArray;

public class CommandTest {
    public static void main(String[] args) {
        ProcessArray pa=new ProcessArray();
        int []target={3,-4,6,4};
        pa.process(target,new PrintCommand());
        pa.process(target,new AddCommand());
    }
}

输出展示

输出目标数组：3
输出目标数组：-4
输出目标数组：6
输出目标数组：4
计数总和：9

接口实现代码：

package lee;

public class AddCommand implements Command{
    public void process(int[] target){
        int sum=0;
        for(int tmp: target){
            sum+=tmp;
        }
        System.out.println("计数总和："+sum);
    }
}
package lee;

public class PrintCommand implements Command{
    public void process(int[] target){
        for(int tmp:target){
            System.out.println("输出目标数组："+tmp);
        }
    }
}

以上就实现了处理行为的分离，但是面向接口编程在小的程序块中不建议使用，会加大代码量，但是对于大型程序的围护就可以用这个，可以减少很多后期的工作量。