接口概述

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用

Java中的接口更多的体现在对行为的抽象

接口的特点

• 接口用关键字interface修饰

  ​ public interface 接口名 {}

• 类实现接口用implements表示

  ​ public class implements 接口名{}

• 接口不能实例化

  ​ 接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态

  ​ 多态的形式：具体类多态，抽象类多态，接口多态。

  ​ 多态的前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象

• 接口的实现类

  ​ 要么重写接口中的所有抽象方法

  ​ 要么是抽象类

例：

Jummpping.java

package com.test;

/**
 * 定义了一个接口
 */
public interface Jumpping {

    public abstract void jump();
}

Dog.java

package com.test;

public class Dog implements Jumpping {

    @Override
    public void jump() {
        System.out.println("狗可以跳高了！");
    }
}

JumppingDemo.java

package com.test;

/**
 * 测试类
 */
public class JumppingDemo {

    public static void main(String[] args) {
        Jumpping j = new Dog();
        j.jump();
    }
}

接口的成员特点

• 成员变量

  ​ 只能是常量

  ​ 默认修饰符：public static final

• 构造方法

  ​ 接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在

  ​ 一个类如果没有父类，默认继承Object类

• 成员方法

  ​ 只能是抽象方法

  ​ 默认修饰符：public abstract

例：

Inter.java

package com.test;

public interface Inter {
//    public static final int n = 3;
//    等价
    int n = 3;

//    public abstract void method();
//    等价
    void method();
}

InterImpl.java

package com.test;

//public class InterImpl extends Object implements Inter{
//等价
public class InterImpl implements Inter {

    public InterImpl() {
//        接口类中无构造方法，super使用的是Object的构造方法
        super();
    }

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

猫和狗（接口版）

需求：对猫和狗进行训练，他们就可以调高了，这里加入了跳高功能。采用抽象类何接口来实现猫狗案例，并在测试类中测试

1. 定义接口（Jumpping）

   ​ 成员方法：跳高（）；

2. 定义抽象动物类（Animal）

   ​ 成员变量：姓名，年龄；构造方法：无参，带参；成员方法：get/set方法，吃饭（）；

3. 定义具体猫类（Cat），继承动物类，实现跳高接口

   ​ 构造方法：无参，带参；成员方法：重写吃饭（）{...}；重写跳高方法（）{...}

4. 定义测试类（AnimalDemo），写代码测试

Jumpping.java

package com.test;

public interface Jumpping {

    void jump();
}

Animal.java

package com.test;

public abstract class Animal {

    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

//    抽象方法
    public abstract void eat();
}

Cat.java

package com.test;

public class Cat extends Animal implements Jumpping {

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void jump() {
        System.out.println("猫可以跳高了！");
    }
}

Animal.java

package com.test;

/**
 * 测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {

//        使用接口多态
        Jumpping j = new Cat();
        j.jump();

//        使用抽象类多态
        Animal a = new Cat();
        a.setName("cat");
        a.setAge(5);
        a.eat();
//        a.jump(); Animal中并没有jump()方法

//        正常使用,在这里有最多的方法
        Cat c = new Cat();
        c.setName("cat");
        c.setAge(5);
        c.eat();
        c.jump();
    }
}

类和接口的关系

• 类和类的关系

  ​ 继承关系，只能单继承，但是可以多层继承

• 类和接口的关系

  ​ 实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

• 接口和接口的关系

  ​ 继承关系，可以单继承，也可以多继承

Inter1.java
Inter2.java
Inter3.java

package com.test;

public interface Inter1 {
}

package com.test;

public interface Inter2 {
}

package com.test;

public interface Inter3 extends Inter1, Inter2 {
//    接口与接口之间可多继承
}

InterImpl.java

package com.test;

public class InterImpl extends Object implements Inter1, Inter2, Inter3 {
//    一个类可以同时实现多个接口
//    同时可以继承一个类
}

抽象类和接口的区别

• 成员区别

  ​ 抽象类 变量；常量；有构造方法；有抽象方法，也有非抽象方法

  ​ 接口 常量；抽象方法

• 关系区别

  ​ 类和类 继承，单继承

  ​ 类和接口 实现，可以单实现，也可以多实现

  ​ 接口和接口 继承，单继承，多继承

• 设计理念区别

  ​ 抽象类 对类抽象，包括属性、行为

  ​ 接口 对行为抽象，主要是行为

注：成员区别和关系区别是语法层面的

​ 抽象类是对事物的抽象，而接口是对行为的抽象