Java—接口

目录

1.接口

1.1接口概述

1.2接口的特点

1.3接口的成员特点

案例:猫和狗

1.4类和接口的关系

1.5抽象类和接口的区别

案例:运动员和教练

---

1.接口

1.1接口概述

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

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

1.2接口的特点

接口用关键字interface修饰
        public interface接口名{}

类实现接口用implements表示
        public class类名implements接口名{}

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

        多态的形式:具体类多态，抽象类多态，接口多态。
        多态的前提:有继承或者实现关系;有方法重写;有父(类/接口)引用指向(子/实现)类对象

接口的实现类
        要么重写接口中的所有抽象方法

        要么是抽象类

接口：

package zyy03;
/*定义了一个接口*/
public interface Jump {
    public abstract void Jumpping();
}

猫类（接口的实现类）：

package zyy03;

public class Cat implements Jump{
    @Override
    public void Jumpping() {
        System.out.println("猫可以跳高");
    }
}

测试类：

package zyy03;

public class Demo {
    public static void main(String[] args) {
        //Jump j=new Jump();//接口是对行为的抽象，所以和抽象类一样不能实例化
        Jump j=new Cat();//用实现类对象进行实例化
        j.Jumpping();
    }
}

1.3接口的成员特点

成员变量
        只能是常量
        默认修饰符:public static final

构造方法
        接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在
        一个类如果没有父类，默认继承自Object类

成员方法
        只能是抽象方法
        默认修饰符:public abstract

案例:猫和狗

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

思路:
定义接口(Jumpping)
        成员方法:跳高();

定义抽象动物类(Animal)
        成员变量:姓名，年龄:

        构造方法:无参，带参:

        成员方法:aet/set方法，

        吃饭{}

定义具体猫类(Cat)，继承动物类，实现跳高接口
        构造方法:无参，带参;

        成员方法:重写吃饭（）{..}，重写跳高方法（）{...}

定义狗类(Dog)，继承动物类，实现跳高接口
        构造方法:无参，带参;

        成员方法:重写吃饭(){….}，重写跳高方法(){...)

定义测试类(AnimalDemo)，写代码测试5

 接口：

package zyy03;
/*定义了一个接口*/
public interface Jump {
     void Jumpping();
}

抽象动物类：

package zyy03;

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();

}

猫类：

package zyy03;

public class Cat extends Animal implements Jump{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    @Override
    public void Jumpping() {
        System.out.println("猫可以跳高");
    }

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

狗类：

package zyy03;

public class Dog extends Animal implements Jump{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

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

    public Dog() {
    }

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

测试类：

package zyy03;

public class Demo {
    public static void main(String[] args) {
        //Jump j=new Jump();//接口是对行为的抽象，所以和抽象类一样不能实例化
        Jump j=new Cat();//用实现类对象进行实例化
        j.Jumpping();
        Animal a=new Cat();
        a.setName("zyy");
        a.setAge(14);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        //a.Jumpping;
        System.out.println("************");
        Jump j1=new Dog();//用实现类对象进行实例化
        j.Jumpping();
        Animal b=new Dog();
        b.setName("jw");
        b.setAge(18);
        System.out.println(b.getName()+","+b.getAge());
        b.eat();
        //b.Jumpping;
    }
}

1.4类和接口的关系

类和类的关系
        继承关系，只能单继承，但是可以多层继承

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

接口和接口的关系
        继承关系，可以单继承，也可以多继承

1.5抽象类和接口的区别

成员区别
        抽象类：         变量，常量；有构造方法;有抽象方法，也有非抽象方法 
        接口：             常量;抽象方法 

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

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

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

案例:运动员和教练

需求:我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都需要学习英语，请用所学知识分析，这个室例中有哪些具体类，哪些抽象类，哪些接口，并用代码实现

分析:从具体到抽象
乒乓球运动员

篮球运动员

乒乓球教练

篮球教练

实现:从抽象到具体

使用:使用的是具体的类的对象

思路:

①定义说英语接口         成员方法:说英语; 
②定义抽象人类      成员变量:姓名，年龄:构造方法:无参，带参:成员方法:get/set方法，吃饭; 
③定义抽象教练类，继承人类         构造方法:无参，带参;成员方法:教0; 
④定义抽象运动员类，继承人类         构造方法:无参，带参;成员方法:学习0; 
⑤ 定义具体篮球教练类，继承教练类         构造方法:无参，带参:成员方法:重写吃饭，重写教
⑥定义具体乒乓球教练类，继承教练类，实现说英语接口
        构造方法:无参，带参;        成员方法:重写吃饭，重写教，重写说英语
⑦定义具体篮球运动员类，继承运动员类        

        构造方法:无参，带参;

        成员方法:重写吃饭，重写学习

⑧定义具体乒乓球运动员类，继承运动员类，实现说英语接口
        构造方法:无参，带参

        成员方法:重写吃饭，重写学习，重写说英语
⑨ 定义测试类，写代码测试

  接口：

package zyy05;

public interface Inter {
    void English();
}

抽象运动员：

package zyy05;

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

    public Athlete(String name, int age) {
        super(name, age);
    }
    public abstract void study();
}

抽象类教练：

package zyy05;

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

    public Coach(String name, int age) {
        super(name, age);
    }
    public abstract void teach();
}

抽象类人：

package zyy05;

public abstract class Person {
    private String name;
    private int age;
    public abstract void eat();

    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;
    }
}

具体乒乓球运动员：

package zyy05;

public class TennisAthlete extends Athlete implements Inter{
    @Override
    public void eat() {
        System.out.println("乒乓球餐");
    }

    @Override
    public void study() {
        System.out.println("学习打乒乓球");
    }

    @Override
    public void English() {
        System.out.println("乒乓球员学习英语");
    }
}

具体篮球运动员：

package zyy05;

public class BasketballAthlete extends Athlete{
    @Override
    public void eat() {
        System.out.println("篮球餐");
    }

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

    public BasketballAthlete() {
    }

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

具体乒乓球教练：

package zyy05;

public class TennisCoach extends Coach implements Inter{
    @Override
    public void eat() {
        System.out.println("乒乓球餐");
    }

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

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

    public TennisCoach() {
    }

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

具体篮球教练：

package zyy05;

public class BasketballCoach extends Coach{
    @Override
    public void teach() {
        System.out.println("教篮球");
    }

    @Override
    public void eat() {
        System.out.println("篮球餐");
    }

    public BasketballCoach() {
    }

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

测试类：

package zyy05;

public class Demo {
    public static void main(String[] args) {
        //创建对象
        TennisAthlete p=new TennisAthlete();
        p.setName("jw");
        p.setAge(18);
        System.out.println(p.getName()+","+p.getAge());
        p.eat();
        p.study();
        p.English();
        System.out.println("************");
        BasketballAthlete b=new BasketballAthlete();
        b.setName("zyy");
        b.setAge(14);
        System.out.println(b.getName()+","+b.getAge());
        b.eat();
        b.study();
        System.out.println("*************");
        TennisCoach t=new TennisCoach();
        t.setName("jw");
        t.setAge(18);
        System.out.println(t.getName()+","+t.getAge());
        t.eat();
        t.teach();
        t.English();
        System.out.println("************");
        BasketballCoach b1=new BasketballCoach();
        b1.setName("zyy");
        b1.setAge(14);
        System.out.println(b1.getName()+","+b1.getAge());
        b1.eat();
        b1.teach();
        System.out.println("*************");
    }
}