Java中接口的特点及其概述

1：接口概述：

• 接口就是一种公共的规范标准，只要符合规范标准，大家都可以通过Java中的接口更多的体现在对行为的抽象。

接口的特点：

• 接口用interface关键字修饰。

public interface 接口名字{}

• 类和接口之间是实现关系, 用implements关键字表示。

public class 类名 implements 接口名{}

• 接口不能实例化
  — 那接口如何实例化呢?可以通过多态的方式, 创建其子类对象, 来完成接口的实例化。
  — 多态的形式：具体类多态，抽象类多态，接口多态。
  — 多态的前提：有继承或者实现关系；重写父类所有的方法；有父（类/接口）引用指向（子/实现）类对象。
• 接口的实现类：
  — 1.要么重写父接口中所有的抽象方法。
  — 2.要么是抽象类。

/**
 * 接口
 */
public interface Jumpping {
    //抽象方法
    public abstract void jump();

}

*****这里接口中的抽象方法可以省略 public 和 abstract两个关键字。****

public class Cat implements Jumpping {

    // 重写父类中的所有抽象方法
    @Override
    public void jump() {
        System.out.println("猫要跳上楼顶............");
    }
    
    //子类成员方法
    public void eat(){
        System.out.println("猫吃鱼.....");
    }
}


/**
 * 测试类
 */
public class TestJumping {
    public static void main(String[] args) {
        //创建对象 测试接口多态
        Jumpping j1 = new Cat();
        j1.jump();  //猫要跳上楼顶............

        //测试子类对象
        Cat c1 = new Cat();
        c1.eat();  //猫吃鱼.....

        //向下转型
        Cat c2 = (Cat)j1;
        c2.eat();  //猫吃鱼.....  了解
    }
}

接口的成员特点：

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

//接口类
public interface Study {
    int a = 20;     //这里的变量在接口中  相当于一个静态常量
    final int c = 50;
    static final int d = 50;
    // 新特性 有一个静态方法
    static void method1(){
        System.out.println("我是JDK1.8的新特性: 接口中可以写静态方法");
    }
    //新特性  有一个默认方法
    default void method2() {
        System.out.println("我是JDK1.8的新特性: 接口中可以写默认方法");
    }
    //抽象方法   省略了 public abstract
    void eat();
    void code();
}


//  实现类
public class StudyImpl implements Study {

    @Override
    public void eat() {
        System.out.println("学生要吃东西........");
    }

    @Override
    public void code() {
        System.out.println("吃完东西就好好敲代码..");
    }

}


//测试类
public class TestStudy {
    public static void main(String[] args) {
        //接口多态写法
        Study s = new StudyImpl();
        s.eat();   //学生要吃东西........
        s.code();  //吃完东西就好好敲代码..
    }
}

类和接口之间的关系：

• 类和类之间的关系： 继承关系，只能单继承，但是可以多层次。
• 类和接口之间的关系： 实实现关系, 可以单实现, 也可以多实现. 还可以在继承一个类的同时实现多个接口。
• 接口与接口之间: 继承关系, 可以单继承, 也可以多继承。

抽象类和接口的区别（记忆）

成员区别：

• 抽象类
  ​ 变量,常量；有构造方法；有抽象方法,也有非抽象方法
• 接口
  ​ 常量；抽象方法

关系区别：

• 类与类
  ​ 继承，单继承
• 类与接口
  ​ 实现，可以单实现，也可以多实现
• 接口与接口
  ​ 继承，单继承，多继承

设计理念区别

• 抽象类
  ​ 对类抽象，包括属性、行为
• 接口
  ​ 对行为抽象，主要是行为

具体案例：

    // 学习英语接口
    public interface StudyEnglish {
    
        void speakEnglish();
    
    }



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 Player extends Person {

    public Player() {
    }

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


}



public abstract class Coach extends Player {

    public Coach() {
    }

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

    public abstract void teach();
}




public class BaskballCoach extends Coach implements StudyEnglish  {

    public BaskballCoach() {
    }

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

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


    @Override
    public void eat() {
        System.out.println("篮球教练吃玉米");
    }

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




public class BaskballPalyer extends Player implements StudyEnglish {


    @Override
    public void eat() {
        System.out.println("篮球运动员吃牛肉.......");
    }

    @Override
    public void speakEnglish() {
        System.out.println("篮球运动员学习英语....");
    }

}




/**
 * 测试类
 */
public class TestDemo01 {
    public static void main(String[] args) {
        BaskballCoach bbc = new BaskballCoach();
        bbc.setName("波波维奇");
        bbc.setAge(78);
        System.out.println(bbc.getName()+"  "+bbc.getAge());
        bbc.eat();
        bbc.speakEnglish();
        bbc.teach();

        System.out.println("-----------------------------");
        BaskballPalyer bbp = new BaskballPalyer();
        bbp.setName("刘阿福");
        bbp.setAge(23);
        System.out.println(bbp.getName() + " "+bbp.getAge());
        bbp.eat();
        bbp.speakEnglish();

    }
}