Java（二十一）interface接口

接口在JAVA中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。

一个类通过继承接口的方式，来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

简单讲，比抽象类更加抽象的表现形式，就是接口。

一：定义接口

1：我们定义一个接口，然后用一个类来实现他：

csharp 复制代码

public class T01 {
    public static void main(String[] args) {
        student stu = new student();
        stu.eat();
        stu.drink();
    }
}
 
/**
 * 人 接口
 */
interface person
{
    /**
     * 吃 抽象方法
     */
    public abstract void eat();
    /**
     * 喝 抽象方法
     */
    public abstract void drink();
}
 
class student implements person
{
    /**
     * 实现接口 吃方法
     */
    public void eat()
    {
        System.out.println("学生吃！");
    }
    /**
     * 实现接口 喝方法
     */
    public void drink()
    {
        System.out.println("学生喝！");
    }
}

控制台输出：

学生吃！

学生喝！

2：定义一个抽象类，来实现接口，再定义一个普通类来继承抽象类

csharp 复制代码

public class T01 {
    public static void main(String[] args) {
        teacherOne tea = new teacherOne();
        tea.eat();
        tea.drink();
    }
}
 
/**
 * 人 接口
 */
interface person
{
    /**
     * 吃 抽象方法
     */
    public abstract void eat();
    /**
     * 喝 抽象方法
     */
    public abstract void drink();
}
 
/**
 * 抽象类 实现 接口
 */
abstract class teacher implements person {
 
}
 
class teacherOne extends teacher
{
    /**
     * 实现接口 吃方法
     */
    public void eat()
    {
        System.out.println("教师一吃！");
    }
    /**
     * 实现接口 喝方法
     */
    public void drink()
    {
        System.out.println("教师一喝！");
    }
}

控制台输出：

教师一吃！

教师一喝！

二：接口特点

1：接口不能创建对象。

2：除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

三：接口成员特点

1：成员变量

接口中的所有变量都是自定义静态常量

csharp 复制代码

public class T01 {
    public static void main(String[] args) {
        // 调用接口person中的成员变量a
        System.out.println(person.a);
    }
}
 
/**
 * 人 接口
 */
interface person
{
    // 第一种写法
    public static final int a = 1;
    // 第二种写法
    static final int b = 2;
    // 第三种写法
    final int c = 3;
    // 第四种写法
    int d = 4;
    /**
     * 吃 抽象方法
     */
    public abstract void eat();
    /**
     * 喝 抽象方法
     */
    public abstract void drink();
}

控制台输出：

2：成员方法

接口中的所有方法都是抽象方法（这句话对初学者来说，是没有问题的，但是这句话是不严谨的）

默认修饰符：public abstract

csharp 复制代码

/**
 * 人 接口
 */
interface person
{
    /**
     * 吃 抽象方法
     */
    void eats();
    /**
     * 吃 抽象方法
     */
    abstract void eat();
    /**
     * 喝 抽象方法
     */
    public void drinks();
    /**
     * 喝 抽象方法
     */
    public abstract void drink();
}

以上四种写法都可以，但是，推荐还是写全了吧。

3：构造方法

接口中没有构造方法

四：接口与接口，类与类，接口与类之间的关系

1：类与类：继承关系，单继承，不可多继承。

csharp 复制代码

/**
 * 父类
 */
class fu
{
    public void aaa()
    {
        System.out.println("父类重写！");
    }
}
/**
 * 子类
 */
class zi extends fu
{
    /**
     * 重写父类方法
     */
    @Override
    public void aaa()
    {
        System.out.println("子类重写！");
    }
}

2：类与接口，实现关系：支持单实现，也支持多实现。

csharp 复制代码

public class T01 {
    public static void main(String[] args) {
        teacher tea = new teacher();
        tea.drink();
        tea.eat();
        tea.run();
        tea.zou();
    }
}
 
/**
 * 人 接口
 */
interface person
{
    /**
     * 吃 抽象方法
     */
    public abstract void eat();
    /**
     * 喝 抽象方法
     */
    public abstract void drink();
}
 
/**
 * 男人 接口
 */
interface personMen extends person
{
    /**
     * 跑 抽象方法
     */
    public abstract void run();
}
 
/**
 * 女人 接口
 */
interface personWomen extends person
{
    /**
     * 走 抽象方法
     */
    public abstract void zou();
}
 
/**
 * 教师类  同时实现  男人接口，女人接口
 */
class teacher implements personMen,personWomen
{
    /**
     * 吃 抽象方法
     */
    public void eat()
    {
        System.out.println("教师类实现吃方法！");
    }
    /**
     * 喝 抽象方法
     */
    public void drink()
    {
        System.out.println("教师类实现喝方法！");
    }
    /**
     * 跑 抽象方法
     */
    public void run()
    {
        System.out.println("教师类实现跑方法！");
    }
    /**
     * 走 抽象方法
     */
    public void zou()
    {
        System.out.println("教师类实现走方法！");
    }
}

控制台输出：

教师类实现喝方法！

教师类实现吃方法！

教师类实现跑方法！

教师类实现走方法！

3：接口与接口：继承关系，支持单继承，也支持多继承

csharp 复制代码

public class T01 {
    public static void main(String[] args) {
        student stu = new student();
        stu.drink();
        stu.eat();
        stu.run();
        stu.zou();
        stu.study();    }
}
 
/**
 * 人 接口
 */
interface person
{
    /**
     * 吃 抽象方法
     */
    public abstract void eat();
    /**
     * 喝 抽象方法
     */
    public abstract void drink();
}
 
/**
 * 男人 接口
 */
interface personMen extends person
{
    /**
     * 跑 抽象方法
     */
    public abstract void run();
}
 
/**
 * 女人 接口
 */
interface personWomen extends person
{
    /**
     * 走 抽象方法
     */
    public abstract void zou();
}
 
/**
 * 学生接口，继承男人接口，女人接口
 */
interface studentInterface extends personMen,personWomen
{
    /**
     * 学习 抽象方法
     */
    public abstract void study();
}
 
class student implements studentInterface
{
    /**
     * 吃 抽象方法
     */
    public void eat()
    {
        System.out.println("学生类实现吃方法！");
    }
    /**
     * 喝 抽象方法
     */
    public void drink()
    {
        System.out.println("学生类实现喝方法！");
    }
    /**
     * 跑 抽象方法
     */
    public void run()
    {
        System.out.println("学生类实现跑方法！");
    }
    /**
     * 走 抽象方法
     */
    public void zou()
    {
        System.out.println("学生类实现走方法！");
    }
    /**
     * 学习 抽象方法
     */
    public void study()
    {
        System.out.println("学生类实现走方法！");
    }
}

控制台输出：

学生类实现喝方法！

学生类实现吃方法！

学生类实现跑方法！

学生类实现走方法！

五：我们什么时候使用接口，什么时候使用类（包含抽象类）

当两个类之间存在必须是的关系的时候，就必须要使用类（抽象类）。

接口是额外扩展的功能，本身该类不具备这个功能，而且是不必须是的关系，就需要去实现这样的接口了。

csharp 复制代码

/**
 * 人 抽象类
 */
abstract class person
{
    /**
     * 喝 抽象方法
     */
    public abstract void drink();
}
/**
 * 司机接口
 */
interface siji
{
    /**
     * 开车 抽象方法
     */
    public abstract void kaiche();
}
 
/**
 * 工人 是 人，所以需要喝水
 */
class worker extends person
{
    public void drink()
    {
        System.out.println("喝水");
    }
}
 
/**
 * 司机工人 是 人，所以需要喝水，也需要具备司机的能力，但是，司机的能力不是所有的工人都需要具备
 */
class workerSiJi extends worker implements siji
{
    public void drink()
    {
        System.out.println("喝水");
    }
    public void kaiche()
    {
        System.out.println("开车！");
    }
}

解释一下上方的代码：

定义一个抽象类person，其中有一个抽象方法drink，人必须要喝水。

定义一个司机接口，其中有一个抽象方法kaiche，司机需要会开车。

定义一个工人类，工人是人，必须要喝水，因此需要继承抽象类person。

定义一个司机工人类，司机工人也是人，必须要喝水，需要继承抽象类person，但是司机也需要会开车，因此需要实现siji接口。

以上大概就是java中接口的使用。

有好的建议，请在下方输入你的评论。