第一步我们首先需要知道java中的接口指的是抽象方法的集合，一个抽象类型，一般以interface来声明，需要注意的是接口不是类

第二步我们可以看一下接口声明的格式，接口中的抽象方法都是隐式的，所以声明不需要abstract关键字，接口中的变量只能是 public static final 类型的

第三步下面通过实例来介绍实现接口，打开eclipse，创建一个Animal接口，里面含有两个抽象方法

第四步创建一个实体类MammalInt，通过implements关键字实现接口，并实现了接口中的抽象方法，通过main方法进行调用

第五步运行项目，在控制台可以看到结果，成功实现了接口

一般以interface来声明，接口中的变量只能是 public static final 类型的

创建一个Animal接口，里面含有两个抽象方法

创建一个实体类MammalInt，通过implements关键字实现接口，并实现了接口中的抽象方法

//定义student接口
interface student
{
    public static final String COUNTRY = "China";
    public abstract void study();
    public abstract void work();
}
//实现接口部分抽象方法的类，为抽象类
abstract class goodStudent implements student
{
    public void study()
    {
        System.out.println("实现接口的抽象了");
    }
}
//将接口中的所有方法都实现了，可以创建对象
class badStudent implements student
{
    public void study()
    {
        System.out.println("努力学习");
    }
    public void work()
    {
        System.out.println("努力工作");
    }
}
public class test
{
    public static void main(String[] args)
    {
        badStudent bs = new badStudent();
        bs.study();
        bs.work();
    }
}

接口是一种规范

软件开发大多是一个协作性的工作：电器和插座分别是不同人完成的，有了接口大家就能分头开干，都按照接口来办事，各自做完就能轻松地整合到一起。各部分的测试也更加方便。

***软件需要不断演化：***今天你用了公牛的插座，过了一年你可能换个西门子的插座，要做没有这套国家接口标准，各自为政，那估计你是换不了插座了。你想想，咱们每次去美国出差，都得带个转接头，否则就跪了，多不方便啊，因为接口规范不同啊！（这些个转接头你是不是闻道一种浓浓的Adapter模式的味道）。

而你所说的，直接写实现的方式在确定性的场景下当然也可以，不涉及到分工协作、变化性、测试方便等因素时，当然用不着接口了。比如一般情况下你犯不着为一个Pojo的getter和setter也弄个接口和实现分离。

接口在开发过程中可以快速分离工作内容。

比如调用者在写业务逻辑的时候需要一个功能，可能是数据库访问，或者复杂计算，但是他的工作专注于实现业务逻辑，不想分开精力去做底层实现，那么他只需要先实现一个接口，定义了规范，然后就可以继续他的业务逻辑代码了。而实现者可以根据这个接口规范，做具体的实现。

这样通过使用接口就可以快速的分离工作内容，达到团队并行工作的目的。

此外，如果规范是通过接口定义的，那么当你这个功能有多个实现时，你只要实现了这个接口，那么可以快速的替换具体实现，做到代码层面的完全可以分离。

*总结起来就一句话：*接口或者规范可以在开发过程中做到分离。

接口（英语：Interface），在JAVA编程语言中是一个抽象类型（Abstract Type），它被用来要求类(Class)必须实现指定的方法，使不同类的对象可以利用相同的界面进行沟通。接口通常以interface来宣告，它仅能包含方法签名（Method Signature）以及常数宣告（变量宣告包含了 static 及 final），一个接口不会包含方法的实现（仅有定义）。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须宣告为抽象类（Abstract Class）。另外，在Java中，接口类型可用来宣告一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口就是个招牌。

比如说你今年放假出去杭州旅游，玩了一上午，你也有点饿了，突然看到前面有个店子，上面挂着KFC，然后你就知道今天中饭有着落了。

KFC就是接口，我们看到了这个接口，就知道这个店会卖炸鸡腿（实现接口）。

那么为神马我们要去定义一个接口涅，这个店可以直接卖炸鸡腿啊（直接写实现方法），是的，这个店可以直接卖炸鸡腿，但没有挂KFC的招牌，我们就不能直接简单粗暴的冲进去叫服务员给两个炸鸡腿了。

要么，我们就要进去问，你这里卖不卖炸鸡腿啊，卖不卖汉堡啊，卖不卖圣代啊（这就是反射）。很显然，这样一家家的问实在是非常麻烦（反射性能很差）。

要么，我们就要记住，中山路108号卖炸鸡，黄山路45号卖炸鸡（硬编码），很显然这样我们要记住的很多很多东西（代码量剧增），而且，如果有新的店卖炸鸡腿，我们也不可能知道（不利于扩展）。

修饰符 interface 接口名称 [extends 其他的接口名] {        // 声明常量        // 抽象方法

}

• 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。

• 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。

• 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

思维导图

一、什么是接口

接口代表一种能力或约束

Java为单继承，当父类的方法种类无法满足子类需求时，可实现接口扩充子类能力。

interface MyInterface {
    void method();}123

• 接口没有构造方法

• 只能定义公开静态常量、公开抽象方法

• 使用 interface 关键字定义接口

接口的好处

• 程序耦合度降低

• 更自然的使用多态

• 设计与实现完全分离

• 更容易搭建程序框架

• 更容易更换具体实现

二、接口与类

2.1 类实现单个接口

定义一个接口

/**
 * 接口。
 * @author 张宝旭
 */public interface MyInterface {
    // 定义公开静态常量
    public static final String NAME = "zbx";
    Integer AGE = 21; // 前面的 public static final 可以省略，默认存在
    
    // 定义公开静态方法
    public abstract void show();
    void run(); // 前面的 public abstract 可以省略，默认存在}12345678910111213

实现接口

使用 implements 实现接口，必须重写接口中的所有方法

/**
 * 接口实现类。
 *
 * @author 张宝旭
 */public class MyInterfaceImpl implements MyInterface{
    @Override
    public void show() {
        System.out.println("show");
    }

    @Override
    public void run() {
        System.out.println("run");
    }}12345678910111213141516

测试

使用接口去创建一个实例：同父类一样，接口也可声明为引用，并指向实现类对象。

• 仅可调用接口中所声明的方法，不可调用实现类中独有的方法

• 可强转回实现类本身类型，进行独有方法调用

/**
 * 接口测试。
 *
 * @author 张宝旭
 */public class MyInterfaceTest {
    public static void main(String[] args) {
        MyInterface myInterface = new MyInterfaceImpl();
        myInterface.show();
        myInterface.run();
    }}123456789101112

2.2 类实现多个接口

实现多继承接口：中间用逗号隔开

/**
 * 接口实现类。
 *
 * @author 张宝旭
 */public class MyInterfaceImpl implements MyInterface, Flyable{
    @Override
    public void show() {
        System.out.println("show");
    }

    @Override
    public void run() {
        System.out.println("run");
    }

    @Override
    public void fly() {
        System.out.println("fly");
    }}123456789101112131415161718192021

2.3 接口继承接口

/**
 * 接口。
 * @author 张宝旭
 */public interface MyInterface extends Flyable, Swimable{}123456

2.4 接口的多态

使用不同引用创建的对象，访问权限也不同

/**
 * 接口测试。
 *
 * @author 张宝旭
 */public class MyInterfaceTest {
    public static void main(String[] args) {
        MyInterface myInterface = new MyInterfaceImpl();
        myInterface.run(); // 只能调用run()方法

        Flyable flyable = new MyInterfaceImpl();
        flyable.fly(); // 只能调用fly()方法

        Swimable swimable = new MyInterfaceImpl();
        swimable.swim(); // 只能调用swim()方法

        MyInterfaceImpl myInterface1 = new MyInterfaceImpl();
        myInterface1.run(); // 可以调用全部方法，包括自己特有的方法
        myInterface1.fly();
        myInterface1.swim();
        myInterface1.eat();
    }}1234567891011121314151617181920212223

2.5 常量接口

将多个常用于表示状态或固定值的变量，以静态常量的形式定义在接口中统 一管理，提高代码可读性

public interface ConstInterface {
    String NAME = "zbx";
    Integer AGE = 21;}1234

2.6 标记接口

不实现任何内容，仅作为标记

public interface LabelInterface {}12

三、接口与抽象类的区别

相同

• 可编译成字节码文件

• 不能创建对象

• 可以作为引用类型

• 具备Object类中所定义的方法

不同

• 接口中的变量只能定义成 public static final 类型的，抽象类中的变量与普通类相同

• 接口中的方法都为抽象方法，抽象类中可以有非抽象方法

• 接口中没有构造方法、动态代码块、静态代码块

• 接口中JDK1.8之后可以定义static方法和default方法

详细讲解：实例分析Java接口和抽象类的区别，以及如何去使用它们（JDK1.8 新版本）

四、接口的规范

ᕙ༼ຈلﻝ͜ ຈ༽ᕗI’m the power

当定义的接口表示一种能力时，应定义成以 able 结尾的名字

/**
 * @author 张宝旭
 */public interface Flyable {
    void fly();}123456

• 任何类在实现接口时，必须实现接口中所有的抽象方法

• 实现接口中的抽象方法，访问修饰符必须是 public