Java学习之接口

2021-06-11

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

1.接口代码演示

package Java_Interface;

public abstract interface typeC {
    public void insert();
}

public class Computer implements typeC {
    @Override
    public void insert() {
        System.out.println("电脑有typeC接口");
    }
}

public abstract class Phone implements typeC {
}

public class Demo_1 {
    public static void main(String[] args) {
        typeC c = new Computer();
        c.insert();
    }
}
//输出结果
/*
	电脑有typeC接口
*/

2.接口的特点

接口用关键字interface修饰

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

public class 类名 implements 接口名 {}
接口不能实例化

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

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

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

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

要么就是抽象类

3.接口成员特点

3.1代码演示

package Java_Interface2;

public abstract interface Usb {
    public static final int speed_1 = 10;
    int speed_2 = 20;
    public final int speed_3 = 30;
    //speed_1 = 1;

    public void insert ();

    public abstract void show();

    //public void show(){}
}

//public class Computer implements Usb
public class Computer extends Object implements Usb { //等价于上面那条语句
    @Override
    public void insert() {
        System.out.println("电脑需要Usb接口");
    }

    public Computer() {
        super();
    }

    @Override
    public void show() {
        System.out.println("电脑");
    }
}

public class Demo_1 {
    public static void main(String[] args) {
        Usb u = new Computer();
        u.insert();
        System.out.println(Usb.speed_3);
        u.show();
    }
}
//输出结果
/*
	电脑需要Usb接口
	30
	电脑
*/

3.2特点

成员变量

只能是常量

默认修饰符：public static final
构造方法

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

一个类如果没有父类，默认继承自Object类
成员方法

只能是抽象方法

默认修饰符：public abstract

关于接口中的方法，JDK8和JDK9中有一些新特性，在后面的文章会将讲到

4.接口版猫和狗案例

4.1代码演示

//我的写法
package Java_Interface3;

public abstract class Animal implements Laugh {
    private String name;
    private int age;

    public void eat(){
        System.out.println("动物爱吃东西");
    }

    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 interface Laugh {
    public void laugh();
}

public class Cat extends Animal {
    @Override
    public void laugh() {
        System.out.println("猫猫会笑了");
    }

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

    public Cat() {
    }

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

public class Dog extends Animal {
    @Override
    public void laugh() {
        System.out.println("狗狗会笑了");
    }

    @Override
    public void eat() {
        System.out.println("狗狗爱吃骨头");
    }

    public Dog() {
    }

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

public class Demo_1 {
    public static void main(String[] args) {
        Animal d = new Dog("小黑", 5);
        d.eat();
        System.out.println(d.getName() + d.getAge());
        d.laugh();
    }
}

//老师的写法
package Java_Interface3;

public abstract class Animal {
    private String name;
    private int age;

    public void eat(){
        System.out.println("动物爱吃东西");
    }

    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 interface Laugh {
    public abstract void laugh();
}

public class Cat extends Animal implements Laugh {
    @Override
    public void laugh() {
        System.out.println("猫猫会笑");
    }

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

    public Cat() {
    }

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

public class Dog extends Animal implements Laugh {
    @Override
    public void laugh() {

    }

    @Override
    public void eat() {
        System.out.println("狗狗爱吃骨头");
    }

    public Dog() {
    }

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

public class Demo_1 {
    public static void main(String[] args) {
        Laugh c = new Cat();
        c.laugh();
        //使用集成度更高的Cat类
        Cat c_2 = new Cat("Tom", 5);
        c_2.laugh();
        c_2.eat();
        System.out.println(c_2.getName() + c_2.getAge());
    }
}

5.类和接口的关系

5.1代码演示

package Java_Interface4;

//类和接口的关系
public class Demo_1 extends Object implements Inter_1,Inter_2,Inter_3 {
}

public interface Inter_1 {
}

public interface Inter_2 {
}

public interface Inter_3 extends Inter_1,Inter_2 {
}

5.2总结

类和类的关系

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

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

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

6.抽象类和接口的区别

6.1代码演示

package Java_Interface5;

public class AlramDoor extends Door implements Alram {
    @Override
    public void open() {
        //...
    }

    @Override
    public void close() {
        //...
    }

    @Override
    public void alram() {
        //...
    }
}

public abstract class Door {
    public abstract void open();
    public abstract void close();
}

public interface Alram {
    void alram();
}
//强调：抽象类是对事物的抽象，而接口是对行为的抽象

6.2总结

成员区别

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

接口常量；抽象方法
关系区别

类与类继承，单继承

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

接口与接口继承，单继承，多继承
设计理念区别

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

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

7.运动员和教练案例

7.1代码演示

package Java_Interface6;

public interface StudyEnglish {
    void speakenglish();
}

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

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

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

    public void teach(){
        System.out.println("教练");
    }
}

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

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

    public void study(){
        System.out.println("学员学习");
    }
}

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

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

    @Override
    public void eat() {

    }

    @Override
    public void teach() {
        super.teach();
    }
}

public class PingpongCoach extends Coach implements StudyEnglish {
    public PingpongCoach() {
    }

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

    @Override
    public void speakenglish() {
        System.out.println("说英语");
    }

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

    @Override
    public void teach() {
        super.teach();
    }
}

public class BasketballStudy extends Athlete {
    public BasketballStudy() {
    }

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

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

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

public class Pingpongstudy extends Athlete implements StudyEnglish {
    public Pingpongstudy() {
    }

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

    @Override
    public void eat() {

    }

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

    @Override
    public void speakenglish() {
        System.out.println("说英语");
    }
}

//测试类
public class Demo_1 {
    public static void main(String[] args) {
        BasketballStudy b_1 = new BasketballStudy("张三", 19);
        System.out.println(b_1.getName() + " | " + b_1.getAge());
        b_1.eat();
        b_1.study();
        //b_1.speakenglish();

        Pingpongstudy p_1 = new Pingpongstudy("李四", 18);
        System.out.println(p_1.getName() + " | " + p_1.getAge());
        p_1.eat();
        p_1.study();
        p_1.speakenglish();
    }
}
//输出结果
/*
	张三 | 19
	吃东西
	学习篮球
	李四 | 18
	学习乒乓球
	说英语
*/

8.接口作为形参和返回值

8.1代码演示

package Java_Interface7;

public interface TypeC {
    void typec();
}

public  class Computer implements TypeC {
    @Override
    public void typec() {
        System.out.println("电脑有Typec接口了");
    }
}

public class ComputerOperator {
    public void useTypec(TypeC t){
        t.typec();
    }

    public TypeC setTypec(){
        TypeC c = new Computer();
        return c;
    }
}

public class Demo_1 {
    public static void main(String[] args) {
        ComputerOperator c = new ComputerOperator();
        TypeC pc_1 = new Computer();
        c.useTypec(pc_1);

        TypeC pc_2 = c.setTypec();
        pc_2.typec();
    }
}
//输出结果
/*
	电脑有Typec接口了
	电脑有Typec接口了
*/

8.2总结

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