什么？你还不知道接口，快来看javase接口详细讲述吧

1. 接口

1.1 接口的概述

1.2 接口的特点

• 用关键字 interface进行修饰，public interface 接口名{}
• 类实现接口 用implements表示 public class 类名 implements 接口名{}
• 接口要通过多态进行实例化(接口多态)
  多态形式
• 具体类多态
• 抽象类多态
• 接口多态
• 多态的前提:有继承或者实现关系;有方法重写;有父(类/接口)引用指向(子/实现)类对象
• 接口实现类：要么重写接口中所有重写方法，要么是抽象类
  举例
  建立接口
  

//接口
public interface jumpping {//接口
    public abstract void jumpping();
    //这里定义了抽象方法，因此子类要重写方法
}

//猫类
public class Cat implements jumpping {//类实现接口
    //抽象，要重写接口中的抽象方法，或者加个abstract
    @Override//采用重写的方法
    public void jumpping() {
        System.out.println("猫跳高了");
    }
}

//测试类
public class JumppingDemo {
    public static void main(String[] args) {
        jumpping j=new Cat();//多态，父类引用指向子类对象
        j.jumpping();
        //方法编译看左面，重写了方法，执行看右面，猫类中的
    }
}

运行结果
猫跳高了

1.3 接口的成员特点

成员变量

• 在接口中的成员变量默认是 final修饰，在测试类中不可再进行赋值，否则会报错
• 在接口中的成员变量默认是静态的，也就意味着在测试类中直接用，接口名.num输出即public static final int num=3; 与int num=3是同样的效果

构造方法

• 构造方法：接口中没有构造方法，因为主要对行为进行抽象的，是没有具体存在的，一个类如果没有父类，默认继承Object类
• 成员方法
• 默认修饰符public abstract
• 只能是抽象方法
  举例
  成员变量举例

//接口类
public interface jumpping {//接口
    public  int age=10;//相当于加上了final修饰
}

//测试类
public class JumppingDemo {
    public static void main(String[] args) {
        System.out.println(jumpping.age);
        //因为是静态，直接可用接口名.成员变量调用成员变量
    }
}

构造方法
构造方法不存在，也就是说父类不存在，那么子类继承Object在进行实现接口

public class interImpl extends Object implements jumpping {
   public  interImpl() {
       super();
   }
}

成员方法

public interface jumpping {//接口
    void eat();//默认为抽象类，且只能是抽象类
    //成员方法不能有方法主体，也即是 void eat{};
}

1.4 案例

//动物抽象类
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();//定义抽象方法
}

public interface jumpping {//接口
    void jumpping();//默认为抽象类，且只能是抽象类;
}

//猫类
public class Cat extends Animal implements jumpping{
//继承了抽象类，实现了接口
    public Cat() {
    }

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

    @Override
    public void jumpping() {
        System.out.println("猫跳高了");
    }

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

//测试:
public class JumppingDemo {
    public static void main(String[] args) {
       jumpping j=new Cat();
       j.jumpping();
       Animal a=new Cat();
       a=new Cat("加菲猫",5);//有参构造
        System.out.println(a.getName()+","+a.getAge());
        a.eat();

    }
}

但当猫类数据比较多时，直接用猫类中的，即Cat c=new Cat();会更加方便，直接可以调用方法c.eat(); c.jumpping();使用起来更加方便。

运行结果：
猫跳高了
加菲猫,5
猫吃鱼肉了

1.5 类与接口的关系

• 类与类的关系：继承关系，只能单继承，但是可以多层继承
• 类与接口的关系：实现关系，可以单实现，也可以多实现，还可以继承一个类时同时实现多个接口
• 接口与接口的关系：继承关系，可以单继承，也可以多继承。

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

public class Inter extends Inter1,Inter2,Inter3{
//接口与接口之间是继承关系，且可以继承多个
}

1.5 抽象类与接口的区别

• 成员区别：
  抽象类（常量，变量，有构造方法，抽象方法，非抽象方法）
  接口（常量，抽象方法）

• 关系区别：
  类与类是单继承，多层继承
  类与接口实现关系，可以实现，也可以多实现
  接口与接口继承，多继承，单继承

• 设计理念区别
  抽象类：对类进行抽象，包括属性，行为
  接口：对行为进行抽象，主要是行为
  
  

运动员与教练案例

需求：

代码思路：

定义说英语接口

//定义说英语接口
public interface SpackEnglish {
    public  abstract void Spack();
    //英语接口

定义抽象人类

public abstract class Person {//定义抽象类
    private String name;
    private int age;

    public Person() {
    }

    public Person(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();
}

定义抽象教练类继承人类

public abstract class Coach extends Person{
    public Coach() {
    }//无参构造
    public Coach(String name,int age){
        super(name, age);
    }
    public abstract void teach();//定义抽象方法教

}

定义抽象运动员继承人类

public abstract class Play extends Person{
    public Play() {
    }

    public Play(String name, int age) {
        super(name, age);
    }
    public abstract void study();
    //定义抽象方法
}

定义具体运动员继承抽象篮球教练，并重写方法

public class BasketBallCoach extends Coach {
    public BasketBallCoach() {
    }

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

    @Override
    public void teach() {
        System.out.println("篮球教练教篮球");

    }

    @Override
    public void eat() {
        System.out.println("吃肉喝汤");
    }
}

定义乒乓球教练类，并实现接口

public class PingpangBallCoach extends Coach implements SpackEnglish{
    public PingpangBallCoach() {
    }

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

    @Override
    public void eat() {
        System.out.println("乒乓球教练吃牛肉");
    }

    @Override
    public void Spack() {
        System.out.println("乒乓球教练说英语");
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练教乒乓球");
    }
}

定义篮球运动员，继承抽象运动员类，方法重写

public class BasketballPlayer extends Play{
    public BasketballPlayer() {//无参构造
    }
    public BasketballPlayer(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("篮球队员喝胡辣汤");
    }

    @Override
    public void study() {
        System.out.println("篮球队员学习篮球");
    }
}

编写测试类

public class PresonDemo {
    public static void main(String[] args) {
        PingpangBallCoach pc=new PingpangBallCoach();//具体类
        pc=new PingpangBallCoach("张三",18);
        System.out.println(pc.getName()+pc.getAge());
        pc.eat();
        pc.Spack();
        pc.teach();
    }
}

运行结果：

张三18
乒乓球教练教吃牛肉
乒乓球教练说英语
乒乓球教练教乒乓球

1.6 引用类型的形参和返回值

1.类名作为形参和返回值

• 方法的形参是类名，需要的是该类的对象
  调用方法首先要创建一个对象，在通过对象来进行调用方法

猫类

public class Cat {
    public  void eat(){
        System.out.println("猫爱吃鱼");
    }
}

//操作类

public class Operator {
    public void useCat(Cat c){
    //这里等同于Cat c=new Cat();
     //传递的是以类作为参数，这里要在测试类创建对象
        c.eat();//调用方法
    }
}

测试类：

public class CatDemo {
    public static void main(String[] args) {
        Operator o=new Operator();//创建对象
        Cat c=new Cat();//这里要先创建一个对象，才能通过对象调用方法
        o.useCat(c);//将c传递过去
    }
}

2.类名作为返回值
返回的是个对象

public class Operator {
    public Cat getCat() {
        Cat c=new Cat();//创建对象
        return  c;//返回对象
    }
}

测试函数：

public class CatDemo {
    public static void main(String[] args) {
        Operator o=new Operator();//创建对象
        Cat cat = o.getCat();//这里的cat 相当于 new Cat();
        cat.eat();//调用方法

    }
}

运行结果：

猫爱吃鱼

3.抽象类作为形参和返回值

• 因为抽象类作为形参时返回的是对象，又因为它是个抽象类，所以不能进行直接实例化，那么就需要创建子类对象，通过子类对象进行多态，从而进行实例化

//创建抽象类
public abstract void Animal(){
public void eat();
}

//创建猫类继承Animal并重写eat()方法
public class Cat extends Animal {
    public  void eat(){//重写方法
        System.out.println("猫爱吃鱼");
    }
}

//操作类
public class Operator {
    public void useAnimal(Animal a){//多态

        a.eat();//通过对象调用方法,编译看左面，执行看右边
    }
    public Animal getAnimal(){//作为返回值
    Anaiml a=new Cat();//多态创建
    return a;
    }
}

//测试类
public class CatDemo {
    public static void main(String[] args) {
        Operator o=new Operator();//创建对象
        Animal a=new Cat();
        o.useAnimal(a);
        a.eat();//调用方法
      Aimal a2=o.getAnimal();//new Cat
      a2.eat();
        }
}

运行结果
猫爱吃鱼
猫爱吃鱼

4. 接口名作为形参和返回值
作为形参

//接口
public interface jumpping {//接口
    void jump();//默认为抽象类，且只能是抽象类;
}

//操作类
public class Operator {
    public void useOperator(jumpping j) {//new Cat()
        //接口作为形参,要通过多态进行实例化对象
        j.jump();//实例化的对象调用方法
    }
}

//子类
public class Cat  implements jumpping{
//实现接口
    @Override//重写方法
    public void jump() {
        System.out.println("猫跳高了");
    }
}

//测试类
public class JumppingDemo {
    public static void main(String[] args) {
        //创建操作类对象
        Operator o=new Operator();
        //通过多态进行实例化
       jumpping j=new Cat();
       o.useOperator(j);//传递过去
    }
}

做为返回值

• 方法的形参是接口名，需要的是该接口的实现类对象
• 方法返回值是接口名，返回的也是该接口的实现对象

//接口
public interface jumpping {//接口
    void jump();//默认为抽象类，且只能是抽象类;
}

//操作类
public class Operator {
    public jumpping getCat( )//接口作为返回值
    {
    jummping j=new Cat();//多态调用
    return j;
    }
}

//实现类
public class Cat  implements jumpping{
//实现接口
    @Override//重写方法
    public void jump() {
        System.out.println("猫跳高了");
    }
}

//测试类
public class JumppingDemo {
    public static void main(String[] args) {
        //创建操作类对象
        Operator o=new Operator();
        //通过多态进行实例化
       jumpping j2=o.getCat();//new cat()
       j2.jump();
       
    }
}

运行结果
猫跳高了

以上就是接口的详细内容，还望大家多多支持点赞收藏，记得三联哦~