Java中接口的与类和抽象类的关系

抽象类：抽象对象，接口：抽象方法，两者配合，一个负责将一类对象抽象化，一个负责将特殊方法，后加特殊方法抽象化，然后再用一个具体类进行继承与实现来达到很好的效果

一、接口与类

1、类和类的关系：

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

2、类和接口的关系：

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

3、接口和接口的关系：

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

4、参考代码：

package com.itheima_04;
/*
接口与接口之间是继承关系 并且可以进行多继承（接口的目的主要是提供抽象方法）
 */
public interface Inter1 extends Inter3, Inter2{
}
package com.itheima_04;

public interface Inter2 {
}
package com.itheima_04;

public interface Inter3 {
}
package com.itheima_04;
/*
一个类在 继承一个类的基础上 还可以实现多个接口
 */
public class inertImpl extends Object implements Inter1, Inter2, Inter3{

}

二、接口与抽象类的区别（事物与行为的抽象）

1、成员区别：

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

接 口： 常量； 无构造方法； 抽象方法

2、关系区别：

类与类：继承与单继承

类与接口：实现，可以单实现，也可以多实现

接口与接口：继承，单继承，多继承

3、设计理念区别

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

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

举例说明：

门和报警的例子：

门：都有open()和close()两个动作，这个时候，我们可以分别使用抽象类和接口来定义这个概念

在此基础上添加报警功能

//抽象类
public abstract class Door{
    public abstract void open();
    public abstract void close();
	public abstract void alarm();	//可以发现万一有的门不能报警？
}
//接口
public interface Door{
    //public abstract void open();
    //public abstract void close();
    void open();
    void close();
    void alarm();			//有的又只能报警呢？
}

所以有：

public interface Alram{
    void alarm();	//将报警独立于一个接口（需要即实现）
}

public abstract class Door{	//将门都有的放在门的抽象类中
    public abstract void open();
    public abstract void close();
}

//而这个类就可以取所需要的，也还可以再写一些特殊的接口来多实现，这样有利于代码的复用性和维护性
public class AlramDoor extends Door implements Alram{
    public void open(){
        //...
    }
    
    public void close(){
        //...
    }
    
    public void alarm(){
        //...
    }
}

三、案例运动员和教练

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

分析：具体到抽象 乒乓球、篮球（运动员） 乒乓球、篮球（教练） 【都是人；有的要学英语】

实现：从抽象到具体

使用：使用的是具体的类和对象

package com.itheima_05;
//说英语接口
public interface SpeakEnglish {
    public abstract void speak();
}
package com.itheima_05;
//抽象的人类
public abstract class Person {
    //成员变量
    private String name;
    private int age;

    //构造方法
    public Person(){}

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

    //set\get\show方法
    public void setName(String name){this.name = name;}

    public String getName(){return this.name;}

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

    public int getAge(){return this.age;}

    public void show(){
        System.out.println(getName() + "," + getAge());
    }

    //定义一个 抽象类
    public abstract void eat();
}
package com.itheima_05;
//抽象教练类
public abstract class Coach extends Person{//抽象类无需重写父类抽象方法
    //构造方法
    public Coach(){}

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

    //定义一个教练类的特殊抽象方法
    public abstract void teach();
}
package com.itheima_05;
//抽象运动员类
public abstract class Player extends Person{
    //定义构造方法
    public Player(){}

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

    //定义一个抽象运动员的特殊方法
    public abstract void study();
}
package com.itheima_05;
//篮球教练类
public class BasketballCoach extends Coach{
    //构造方法
    public BasketballCoach() {
    }

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

    //重写抽象类
    @Override
    public void eat(){
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }

    @Override
    public void teach(){
        System.out.println("篮球教练教如何运球和投篮");
    }
}
package com.itheima_05;
//篮球运动员类
public class BasketballPlayer extends Player{
    //构造方法
    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("篮球运动员学习如何运球和投篮");
    }
}
package com.itheima_05;
//乒乓球教练类
public class PingPangCoach extends Coach implements SpeakEnglish{
    //构造方法

    public PingPangCoach() {
    }

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

    //重写抽象方法
    @Override
    public void eat(){
        System.out.println("乒乓球教练吃牛肉，和牛奶");
    }

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

    @Override
    public void speak(){
        System.out.println("乒乓球教练说英语");
    }
}
package com.itheima_05;
//乒乓球运动员类
public class PingPangPlayer extends Player implements SpeakEnglish{
    //构造方法
    public PingPangPlayer(){}

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

    //重写抽象方法
    @Override
    public void eat(){
        System.out.println("乒乓球运动员吃大米饭，和排骨汤");
    }

    @Override
    public void study(){
        System.out.println("乒乓球运动员学发球和接球");
    }

    @Override
    public void speak(){
        System.out.println("乒乓球运动员说英语");
    }
}
package com.itheima_05;
/*
测试类
 */
public class PersonDemo {
    public static void main(String[] args){
        //创建对象
        PingPangPlayer ppp = new PingPangPlayer();
        ppp.setName("张三");
        ppp.setAge(30);
        ppp.show();
        ppp.eat();
        ppp.study();
        ppp.speak();

        System.out.println("--------------------------");

        BasketballPlayer bp = new BasketballPlayer();
        bp.setName("李四");
        bp.setAge(32);
        bp.show();
        bp.eat();
        bp.study();
    }
}