Java | 接口

为什么使用接口

接口就是制定统一的标准，让各方使用这个接口，从而让所有现实接口的类统一操作，比如说手机的充电器接口，这就是现实生活中的一个例子，国际上面制定一个标准，然后所有的手机厂商现实，如果不现实，就不能让大多数的人用。

接口的概念

接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。我们可以直接把接口理解为100%的抽象类，既接口中的方法必须全部是抽象方法。（JDK1.8之前）
  在1.8之后，接口中增加了一和默认方法，如果感兴趣的可以去我之前的博客看看 Java8默认方 法。

接口和抽象类的区别

接口是比抽象类不要抽象的抽象类，可以更加规范的对子类进行约束，全面专业的实现规范和具体实现的分离。
  接口就是一种规范，定义的是一组规则，而这一种规则是谁用谁必须实现。
  抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
  抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
  接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
  一个类只能继承一个抽象类，而一个类却可以实现多个接口。

接口的特点(1.8之前)

• 接口中只能有存在静态常量和抽象方法。（都是不用自己指定，接口默认如此）
• 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
• 实现接口的类必须要实现类中的方法，如果不需要现实，那么这个类一这是抽象类。
• 接口就是把同一类型的东西，定义一个统一的标准，让所有现实的类都必须要继承。

接口的使用原则

1、 接口是用（interface）来定义的，是用（implements）来实现的。
2、接口可以利用对象多态性，利用子类实现对象的实例化。
3、接口中也有数据成员和方法，但常量一定要初始赋值，并且此值不能再有修改，定义的方法可以有抽象方法和默认方法，抽象方法abstact关键字可以省略，默认方法需要带上default关键字，默认方法可以带有方法体。

接口的定义和实现

接口的作用——制定标准

//定义一个车的接口
public interface Vehicle {
    //车有一个最高速度
    int SPEED = 100;

    //跑
    public void run();
}

//如果是抽象类现实接口不用现实他的方法
abstract class  absA implements Vehicle{

}

//汽车
class Car implements Vehicle{

    //实现接口里面的方法
    @Override
    public void run() {
        //可以使用接口里面定义的常量
        System.out.println("汽车跑，速度："+Vehicle.SPEED);
    }
}

//玩具车跑
class TcyCar implements Vehicle{

    //实现接口里面的方法
    @Override
    public void run() {
        System.out.println("手推着跑");
    }
}

//测试类
class Func{
    public void function(Vehicle vehicle) {
        //调用接口里面的方法
        vehicle.run();
    }
}

class run{
    public static void main(String[] args) {
        //调用的类
        Func func = new Func();

        //车的实现类
        Car car = new Car();

        //车的实现类
        TcyCar tcyCar = new TcyCar();

        //玩具车运行
        func.function(tcyCar);
        //运行结果：手推着跑

        func.function(car);
        //运行结果：汽车跑，速度：100
    }
}

  在Func里面，可以看到，function的参数为Vehicle，方法里面运行的是Vehicle的run() 方法，但是下面运行的时候还可以运行成功，说明接口可心做类型，在用接口做类型的时候，它的实现类都是自动向上转型的。
  在上面的例子中，我们就用到了制定标准，比如在现实在Func，就是一个Usb接口，但是用的地方不一样，出来的功能就不一样。这就是接口的主要作用之一 ——制定标准。

接口的作用——多现实

//定义第一个接口
public interface IntOne {
    public void one();
}

//定义第二个接口
interface IntTwo {
    public void two();
}

//定义第三个接口，接口是可以多继承的，类不可以
interface IntThree extends IntOne,IntTwo{
    public void three();
}

//定义一个测试的类,类也可以多实现
class Test implements IntThree,IntTwo{
    //类里面必须实现以上三个接口的所有的抽象方法
    @Override
    public void one() {

    }

    @Override
    public void two() {

    }

    @Override
    public void three() {

    }
}

  上面的这个例说明了，接口可以多继承，多实现，但是接口的多继承是在java8以后才可以的，多实现是一直都可以的，多实现是为了弥补java类不可以多继承才出来的。
  但是类依然不可以多继承。因为类不可以多继承是因为类有实现方法，而接口没有实现方法，接口里面都是抽象方法，所以说接口谁继承谁都没有问题。而类里面的多继承，是因为有具体的方法的，如果继承之后会出现不知道使用谁的方法的问题。所以在Java中类是单继承的，而接口是多继承的。

模版方法

模版方法，还有所有的设计模式，都是面向对象的使用，简单的一个模版方法用是，有几个因定的流程，但是中间的一步，两步是不同实现，没有子类实现的时候，可以用基础的方法，有子类的时候，可以用子类的实现。
下面是一个简单的模版方法：

public class TemplateMethod {
    //定义一个模版方法
    public void Method(Order order) {
        System.out.println("准备请课吃饭！");
        System.out.println("喊人！");
        System.out.println("选饭店！");
        //这个地方是动态的方法，不同的实现类，会出来不同的结果
        order.foodSelection();
        System.out.println("结账！");
    }
}

//父类
class Order {
    //父类方法，定义一个基本方法
    public void foodSelection() {
        System.out.println("随便吃点！");
    }
}

class OrderOne extends Order{
    //第一个继承类
    @Override
    public void foodSelection() {
        System.out.println("吃大龙虾！");
    }
}

class OrderTwo extends Order{
    //第二个继承类
    @Override
    public void foodSelection() {
        System.out.println("吃面条！");
    }
}

class TestTemplate{
    //调用实现方法，使用同一个方法的模版，但是现实是不一样的。
    public static void main(String[] args) {
        TemplateMethod method = new TemplateMethod();

        Order order = new Order();
        method.Method(order);
        System.out.println("************");
        //准备请课吃饭！
        //喊人！
        //选饭店！
        //随便吃点！
        //结账！
        method.Method(new OrderOne());
        System.out.println("*************");
        //准备请课吃饭！
        //喊人！
        //选饭店！
        //吃大龙虾！
        //结账！
        method.Method(new OrderTwo());
        //准备请课吃饭！
        //喊人！
        //选饭店！
        //吃面条！
        //结账！
    }
}

  模版方法也可以使用接口来定义，也可以用抽象类来定义。Java是一个面向对象语言，不管是什么设计模式，什么框架，都是使用面向对象的！

---

关注公众号，随时获取最新资讯

细节决定成败!
个人愚见，如有不对，恳请斧正!