Java学习笔记@接口

笔者：unirithe

日期：2021-11-7

接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合。

接口的特点

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

• 实现接口用implements

  public class 类名 implements 接口名 {} 重写接口所有方法

  public static class 类名 implements 接口名 {} 无需重写接口所有方法

• 接口无法直接实例化

  • 通过接口多态实现， 即实现类对象的实例化

  关于多态

  • 形式： 具体类多态、抽象类多态、接口多态
  • 前提：
    • 继承extends或实现implements关系
    • 有方法重写@Override
    • 有父类/接口 引用指向(子/实现)类对象

• 成员变量只能是常量，默认为 static final

• 接口里的所有方法默认抽象abstract，只声明不实现

• 不能有构造方法、实现类的构造方法里的super() 是调用其父类Object类的构造方法

案例分析

不同方式下创建接口对象

public class Cat extends Animal implements Jumpping 的各种创建对象方式的区别：

声明方式	描述
Jumpping a = new Cat()	转型为接口，无法进行有参构造，可以调用类实现接口的方法
Animal a = new Cat() / new Cat("maomi")	转型为父类，可无参、有参构造，无法调用实现接口的方法
Cat a = new Cat()	无转型，即可使用父类的构造方法，又可以使用实现接口的方法

总结 ：对象的可用范围取决于等号左边规定的类型，若为接口，则只能调用接口里的方法以及静态变量，若为父类，则无法再调用接口的方法，接下来是本次总结的具体案例。

案例：猫、动物、跳跃

需求：模拟输出猫咪进食和跳跃，采用抽象类和接口来实现这个案例。

Juppming.java 声明接口，实现类的非静态类需要重写接口内的Jump方法

public interface Jumpping {
    public void jump();
}

Animal.java 声明抽象类，包含动物名称和岁数两个属性，并有对应的get和set方法，另外声明eat抽象方法，其子类必须实现。

public abstract class Animal {
    private String name;

    public Animal() {
    }

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public abstract void eat();
}

Cat.java 声明实体类，继承Animal类并实现Jummping接口，且必须实现抽象类和接口声明的方法

public class Cat extends Animal implements Jumpping{
    public Cat(){}
    public Cat(String name){
        super(name);
    }
    @Override
    public void jump() {
        System.out.println("猫在跳高...");
    }

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

AnimalDemo.java 测试类，使用五种方式创建对象，观察区别

public class AnimalDemo {
    public static void main(String[] args) {
        System.out.println("-------> 1. 接口定义<------- ");
        Jumpping j = new Cat();
        j.jump();

        System.out.println("-------> 2. 父类无参构造定义  <-------");
        Animal a = new Cat();
        a.setName("多啦A梦");
        System.out.println(a.getName());
        a.eat();

        System.out.println("-------> 3. 父类带参构造定义 <------- ");
        Animal b = new Cat("加菲猫");
        System.out.println(b.getName());

        System.out.println("------->  4. 具体接口实现类无参构造定义 <-------");
        Cat c = new Cat();
        c.setName("小橘猫");
        System.out.println(c.getName());
        c.eat();
        c.jump();
        System.out.println("------->  5. 具体接口实现类带参构造定义 <-------");
        new Cat("小橘猫").eat();
    }
}

运行结果

-------> 1. 接口定义<-------
猫在跳高...
-------> 2. 父类无参构造定义 <-------
多啦A梦
猫在吃鱼...
-------> 3. 父类带参构造定义 <-------
加菲猫
-------> 4. 具体接口实现类无参构造定义 <-------
小橘猫
猫在吃鱼...
猫在跳高...
-------> 5. 具体接口实现类带参构造定义 <-------
猫在吃鱼...

门和警报器

案例：门和警报器 (alram) 的设计

public interface Alram{
    void alarm();
}
public static class Door{
    public abstract void open(); 
    public abstract void close();
}
public AlarmDoor extends Door implements Alarm{
    public void open(){ 
        //... 
    }
    public void close(){
        //...
    }
    public void alarm(){
        //...
    }
     
}

运动员和教练

案例：运动员和教练

需求：乒乓球运动员、教练和篮球运动员、教练。为了出国交流，跟乒乓球相关的人员都需学习英语

分析：从具体到抽象

• 抽象类 运动员 行为 ：学习
• 抽象类 教练 行为 ：教
• 抽象类 人类 属性：姓名 ， 行为：吃饭
• 接口：学习英语

SpearkEnglish.java 接口

public interface SpearkEnglish {
    void speak();
}

Person.java 实体抽象类 —— 人类

public abstract class Person {
    private String name;
    public Person(){}
    public Person(String name){
        this.name = name;
    }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public abstract void eat();
}

Coach.java 实体抽象类 —— 教练

public abstract class Coach extends Person{
    public Coach(){}
    public Coach(String name){super(name);}
    public abstract void teach();
}

Player.java 实体抽象类 —— 运动员

public abstract class Player extends Person{
    public Player(){}
    public Player(String name){ super(name); }
    public abstract void study();
}

PingpangCoach.java 具体实现类——乒乓教练

public class PingpangCoach extends Coach implements SpearkEnglish{
    public PingpangCoach(){}
    public PingpangCoach(String name){super(name);}
    @Override
    public void teach() {
        System.out.println(this.getName() + " 教练教乒乓");
    }

    @Override
    public void eat() {
        System.out.println(this.getName() + " 教练吃乒乓饭");
    }

    @Override
    public void speak() {
        System.out.println(this.getName() + " 教练说英语");
    }
}

BasketballCoach.java 具体实现类—— 篮球教练

public class BasketballCoach extends Coach{
    public BasketballCoach(){}
    public BasketballCoach(String name) {super(name);}
    @Override
    public void teach() {
        System.out.println(this.getName() + " 教练教篮球");
    }

    @Override
    public void eat() {
        System.out.println(this.getName() + " 教练吃篮球饭");
    }
}

PingpangPlayer.java 具体实现类——乒乓运动员

public class PingpangPlayer extends Player implements SpearkEnglish{
    public PingpangPlayer(){}
    public PingpangPlayer(String name){super(name);}
    @Override
    public void eat() {
        System.out.println(this.getName() + " 运动员吃乒乓饭");
    }

    @Override
    public void study() {
        System.out.println(this.getName() + " 运动员学乒乓");
    }

    @Override
    public void speak() {
        System.out.println(this.getName() + " 运动员说英语");
    }
}

BasketballPlayer.java 具体实现类——篮球运动员

public class BasketballPlayer extends Player{
    public BasketballPlayer(){}
    public BasketballPlayer(String name){super(name);}
    @Override
    public void eat() {
        System.out.println(this.getName() + " 运动员吃篮球饭");
    }

    @Override
    public void study() {
        System.out.println(this.getName() + " 运动员学习篮球");
    }
}

PersonDemo.java 测试类

public class PersonDemo {
    public static void main(String[] args) {
        PingpangPlayer a =  new PingpangPlayer("A");
        PingpangCoach b = new PingpangCoach("AA");
        BasketballPlayer c = new BasketballPlayer("B");
        BasketballCoach d = new BasketballCoach("BB");
        // 所有运动员吃饭时间
        System.out.println("---------吃饭时间---------");
        a.eat(); b.eat(); c.eat(); d.eat();

        // 所有运动员学习时间
        System.out.println("---------学习时间---------");
        b.teach(); a.study(); d.teach(); c.study();

        System.out.println("---------英语交流时间--------");
        // 篮球运动员说英语时间
        a.speak(); b.speak();
    }
}

运行结果

---------吃饭时间---------
A 运动员吃乒乓饭
AA 教练吃乒乓饭
B 运动员吃篮球饭
BB 教练吃篮球饭
---------学习时间---------
AA 教练教乒乓
A 运动员学乒乓
BB 教练教篮球
B 运动员学习篮球
---------英语交流时间--------
A 运动员说英语
AA 教练说英语

类和接口的三种关系

• 类和类的关系
  • 单继承：public class obj extends Object
• 类和接口的关系
  • 类实现接口：public class InterImpl implements Inter1, inter2, inter3
  • 类单继承实现接口：public class InterImpl extends Object implements Inter1, Inter2
• 接口和接口的关系
  • 单继承： public interface Inter2 extends Inter1
  • 多继承：public interface Inter3 extends Inter1, Inter2

抽象类和接口的区别

• 成员区别、设计理念区别

抽象类	接口
变量、常量、有构造方法，有抽象方法，也有普通方法	默认static final常量， 只有抽象方法
对类抽象，包括属性、行为	对行为抽象，主要是行为

接口方法的形参和返回值

• 方法的形参若有接口名，则实际上是传入实现类，可以是匿名类。接下来使用接口模拟电脑插上U盘后上传文件

interface Inter { 
    void upload();
}
class Computer{
    private static Inter usb;
    public static void setUsb(Inter a){
        Computer.usb = a;
    };
    public static void main(String[] args){
        Computer.setUsb(new Inter() {
            @Override
            public void upload() {
                System.out.println("上传文件!");
            }
        });
        usb.upload();
    }
}

• 方法的返回值中若有接口名，实际返回的是接口的某个实现类对象，若没有则通过匿名类实现

interface Inter { 
    void upload();
}
class Usb implements Inter{
    @Override
    public void upload() {
        System.out.println("上传文件.");
    }
}
class Computer{
    public static Inter getUsb(){
        return new Usb();
    };
    public static void main(String[] args){
        Computer.getUsb().upload();
    }
}