文章目录

• 一、接口概念
• 二、类实现接口
• 三、接口与抽象类
• 四、默认方法
• 五、设计模式：回调 （callback）

一、接口概念

对希望符合这个接口的类的一组需求

eg.Comparable接口的代码

public interface Comparable
{
    int compareTo(Object other);
}

任何实现Comparable接口的类都要包含compareTo方法

• 接口中的所有方法都自动是public方法，接口中声明方法时，不必提供关键字public。 实现接口时，必须把方法声明为public
• 接口绝不会有实例字段 但可以包含常量 总是public static final
• Java8之前，接口中绝对不会实现方法
• 可以声明接口变量 Comparable x;
• 接口变量必须引用实现了这个接口的类对象 x=new Employee(…)
• instanceof可以用于检查一个对象是否实现了某个特定的接口 obj instanceof Comparable

public interface Moveable {
    void move(double x,double y);
    double SPEED=95;
}
//接口中的字段总是public static final

二、类实现接口

步骤：

1. 让类声明为实现给定的接口 implements
2. 对接口中的所有方法提供定义

eg. 如果希望Arrays类的sort方法对Employee对象数组进行排序，Employee类就必须实现Comparable接口
class Employee implements Comparable

  public int compareTo(Object o) {
        Employee other=(Employee) o;
        return Double.compare(salary,other.salary);
    }

public class EmployeeInterface implements Comparable<EmployeeInterface>{
    private String name;
    private double salary;

    public EmployeeInterface(String name,double salary)
    {
        this.name=name;
        this.salary=salary;
    }

    public String getName() {
        return name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public void raiseSalary(double byPercent)
    {
        this.salary+=this.salary*byPercent/100;
    }

    @Override
    public int compareTo(EmployeeInterface o) {
        return Double.compare(this.salary,o.salary);
    }
}

import java.lang.reflect.Array;
import java.util.Arrays;

public class EmployeeSortTest {
    public static void main(String[] args) {
        EmployeeInterface[] staff=new EmployeeInterface[3];
        staff[0]=new EmployeeInterface("Harry Hacker",35000);
        staff[1]=new EmployeeInterface("Carl Cracker",75000);
        staff[2]=new EmployeeInterface("qaq",100);

        Arrays.sort(staff); //排序 一定要实现接口Comparable

        for(EmployeeInterface e:staff)
        {
            System.out.println("name="+e.getName()+" salary="+e.getSalary());
        }
    }
}

//结果：
//name=qaq salary=100.0
//name=Harry Hacker salary=35000.0
//name=Carl Cracker salary=75000.0

三、接口与抽象类

抽象类的问题：每个类只能扩展一个类

而每个类可以实现多个接口

C++支持多重继承，但Java不支持

四、默认方法

使用default关键字 可以为接口方法提供一个默认实现

    default int compareTo(T other)
    {
        return 0;
    }

eg. Iterator接口

解决默认方法冲突：
先在一个接口中将一个方法定义为默认方法，又在超类或另一个接口中定义同样的方法，what happened？

1. 超类优先
2. 接口冲突

五、设计模式：回调 （callback）

在这种模式中，可以指定某个特定事件发生时应该采取的动作。

Java：向定时器传入某个类的对象，然后，定时器调用这个对象的方法。由于对象可以携带一些附加信息，所以传递一个对象比传递一个函数要灵活得多。

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.time.Instant;
import javax.swing.*;

public class TimerTest {
    public static void main(String[] args) {
        TimePrinter listener=new TimePrinter();//创建监听器对象
        Timer timer=new Timer(1000,listener); //这里传递listener这个对象
        timer.start();

        JOptionPane.showMessageDialog(null,"Quit program?");
        System.exit(0);


    }
}

class TimePrinter implements ActionListener
{
    @Override
    public void actionPerformed(ActionEvent event) {
        System.out.println("At the tone,the time is "+ Instant.ofEpochMilli(event.getWhen()));
        Toolkit.getDefaultToolkit().beep();
    }
}