Java接口

接口概念与特性

Java接口时一系列方法的声明，是一些特征方法的集合，一个接口只有方法的特征而没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以有不同的行为。

以下以Comparable接口为例，该接口有一个compareTo方法，接受一个Object对象，返回一个整型数值。(用于比较大小)

让一个类实现一个接口的步骤：

1)将类声明为实现给定的接口，使用implements关键字；

2)对接口中所有方法进行定义。

class A implements Comparable{
   public int ComparaTo(Object obj){
   ......
   }
}

接口的一些特性

1)接口中所有方法自动地属于public，因此，在接口声明方法中，不必提供关键字public。

2)接口不能包含实例域或静态方法，可以包含常量，常量自动地属于public static final。

3)实现接口时，必须将方法声明为public，与1)比较，该处为实现时。

public int compareTo(Object obj){...}

4)接口不是类，不能实例化接口；可以声明接口的变量，但该变量必须引用实现了该接口的类对象。

c = new Comparable(...)　　//错误
Comparable c;//正确
c = new Employee(...)　　//若Employee类实现了Comparable接口，此语句正确，否则错误

 

5)接口允许被拓展，使用extends关键字可以将接口拓展成另一个接口。

public interface A{...}
public interface B extends A{...}    //此时，接口B将包含A的方法和它自己定义的方法

6)尽管每个类只能有一个超类，但却可以实现多个接口；使用逗号分割开多个接口。

class A implements Comparable, Cloneable

一个实例：Employee类实现Comparable接口，使得能够使用Array.sort方法对工资排序。

package interfaces;

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

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

    public String getName() {
        return name;
    }

    public double getSalary() {
        return salary;
    }

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

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

package interfaces;

import java.util.Arrays;

public class EmployeeSortTest {
    public static void main(String[] args){
        Employee[] staff = new Employee[3];
        staff[0] = new Employee("Harry",30000);
        staff[1] = new Employee("Tony", 52000);
        staff[2] = new Employee("Tom", 36000);

        Arrays.sort(staff);

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

name=Harry,salary=30000.0
name=Tom,salary=36000.0
name=Tony,salary=52000.0

接口与抽象类

在c++中，一个类允许有多个超类，该特性称为多继承，而Java不支持多继承。因而，使用抽象类作为通用属性就存在这样的问题：当一个类已经继承于一个类，就不能再拓展于第二个类了。接口解决了这个问题，因为一个类可以实现多个接口。

以下为抽象类和接口的区别与相似性：

抽象类	接口
不能被实例化
被子类继承	被子类实现
包含或不包含抽象方法	包含或不包含抽象方法(java se 8后可以在接口中实现方法)
抽象方法必须被子类实现，否则子类也必须声明为抽象的	抽象方法必须被子类实现
一个类只能有一个抽象(或普通)的超类	一个类可以实现多个接口
表示该对象是什么	一般表示该对象能做什么
abstract修饰	implements修饰

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

默认方法与冲突

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

public interface A{
   default int func(){...}
}

这样，实现这个接口时可以选择不覆盖该方法。

如果一个接口中将一个方法定义为默认方法，然后又在超类或另一个接口中定义了同样的方法。这样就可能会出现命名冲突,Java解决办法

1)超类优先。如果一个超类提供了具体的方法，接口中的同名同参数的方法将被忽略。

2)接口冲突。若两个接口有同样的方法的实现，那么必须在子类中覆盖该方法。

接口与回调

回调时一种常见的程序设计模式。在这种模式中，可以指出某个特定事件发生时应该采取的动作。例如按下鼠标产生什么效果。下面是一个例子：

java.swing中有一个Timer类，可以使用它在到达指定时间间隔发出通告。创建一个对象实现java.awt.event包中的ActionListener接口。到达指定间隔时间发生一些事情。

package timer;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;

public class TimerTest {

    public static void main(String[] args) {
        ActionListener listener = new TimePrinter();

        Timer t = new Timer(10000, listener);//定时器对象,传递对象
        t.start();
        JOptionPane.showMessageDialog(null, "quit program");//产生消息框
        System.exit(0);
    }
}

class TimePrinter implements ActionListener{
    public void actionPerformed(ActionEvent event){//实现事件响应方法
        System.out.println("at the time, the time is "+ new Date());
        Toolkit.getDefaultToolkit().beep();//发出铃响
    }
}

接口与深浅拷贝

浅拷贝：原变量和副本都是同一个对象的引用。

Employee e = new Employee();
Employee copy = e;

深拷贝：元变量和副本属于不同的引用，有相同的状态。

 

这里需要实现Cloneable接口，这个接口指示一个类提供clone方法。它是Object的一个protected方法。这说明不能直接调用这个方法。

设计为protected的原因：Object类对某个对象进行clone，它逐一地拷贝所有域。如果域是基本类型自然没有问题，如果域包含一个对象的引用，那么拷贝这个域将得到相同的引用。如此一来，拷贝对象仍然和原对象共享一些信息。

也就是说，如果默认clone方法不能满足需求(课变得而子对象)，那么必须：

1)实现Cloneable接口

2)重新定义clone方法，指定public修饰符。

以下例子：拷贝一个Employee实例，修改日期

package clone;

import java.util.Date;
import java.util.GregorianCalendar;

public class Employee implements Cloneable {
    private String name;
    private double salary;
    private Date hireDay;

    public Employee(String name, double salary){
        this.name = name;
        this.salary = salary;
        hireDay = new Date();
    }

    public Employee clone() throws CloneNotSupportedException{//实现克隆方法
        Employee cloned = (Employee) super.clone();//此时name和hireDay是引用
        cloned.hireDay = (Date) hireDay.clone();//拷贝hireDay
        return cloned;
    }

    public void setHireday(int year, int month, int day){
        Date newHireDay = new GregorianCalendar(year,month-1,day).getTime();//格林威治时间
        hireDay.setTime(newHireDay.getTime());
    }

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

    public String toString(){
        return "Employee[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
    }
}

package clone;

public class CloneTest {
    public static void main(String[] args){
        try{
            Employee original = new Employee("John", 50000);
            original.setHireday(2000,1,1);
            Employee copy = original.clone();
            copy.setHireday(2002,12,31);
            System.out.println("original="+original);
            System.out.println("copy="+copy);
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
    }
}

结果：

original=Employee[name=John,salary=50000.0,hireDay=Sat Jan 01 00:00:00 CST 2000]
copy=Employee[name=John,salary=50000.0,hireDay=Tue Dec 31 00:00:00 CST 2002]