java基础：9.2 接口implements，Comparable，Cloneable接口

1、接口的定义

接口(interface)用来描述类具有什么功能，而不给出每个功能的具体实现。接口只包含常量和抽象方法，不能含有实例域，也不能在接口中实现方法！接口在许多方面都与抽象类很相似，但是它的目的是指明相关或者不相关类的多个对象的共同行为。

每个类只能拥有一个超类，但能拥有多个接口。接口提供了多继承的好处，且避免了多重继承的复杂性和低效性。

与抽象类相似，不能使用new 操作符创建接口的实例。类和接口之间的关系称为接口继承。

服务提供商有一句话“如果类遵从某个特定接口，那么就履行这项服务”。比如：Arrays类中sort方法可以承诺对对象数组进行排序，但要求满足下列前提：对象所属的类必须实现了Comparable接口。

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

1. 将类声明为实现给定的接口，关键字 implements
2. 对接口中的所有方法进行定义！

修饰符 interface 接口名{
常量声明
方法签名
}

//example
abstract class Animal{
    public abstract String sound();   //抽象方法
}

class Chicken extends Animal implements Edible{    //实现了Edible 接口
    ...
    @Override
    public String howToEat(){
        return "chicken:fry it";
    }

    @Override
    public String sound(){           //继承Animal 类并实现sound 方法
        return "Chicken:cock-a-doodle-doo";
    }
    
class Tiger extends Animal{
    ...
}

abstract class Fruit implements Edible(){       //Fruit 类实现Edible。
    // 因为它不实现howToEat 方法，所以Fruit 必须表示为abstract
    ...
}

class Apple extends Fruit {     //Apple 类和Orange 类实现howToEat 方法
    @Override
    public String howToEat(){
        return "orange:make orange juice";
    }
}

当一个类实现接口时，该类用同样的签名和返冋值类型实现定义在接口中的所有方法.

本质上，Edible 接口定义了可食用对象的公共行为。所有可食用的对象都有howToEat方法。

由于接口中所有的数据域都是public static final，所有的方法都是public abstract，所以java允许忽略这些修饰符。

 

2、Comparable接口

package java.lang;
public interface Comparable<E>{
	public int compareTo(E o);
}
/* compareTo 方法判断这个对象相对于给定对象o 的顺序，并且当这个对象小于、等于或
大于给定对象o 时，分别返回负整数、0或正整数*/

Comparable 接口是一个泛型接口。在实现该接口时，泛型类型E 被替换成一种具体的类型。Java 类库中的许多类实现了Comparable 接口以定义对象的自然顺序。Byte、Short、Integer、Long、Float、Double、Character、Biglnteger、BigDecimalx Calendar、String以及Date 类都实现了Comparable 接口。

public class Integer extends Number implements Comparable<Integer> {

    @Override
    public int compareTo(Integer o)
    ..
    }
}


System.out.println(new Integer(3).compareTa(new Integer(5)));
System.out.println("ABC".compareTo("ABE"))；
java.util.Date date1 = new java.util.Date(2013,1,1);
java.util.Date date2 = new java.util.Date(2012,1,1);
System.out.println(datel.compareTo(date2));

 

3、Cloneable接口 [ java.lang ]

如果直接把一个变量赋给另一个变量，例如下面这句，e1,e2将指向同一个引用对象，如果改变e2的值，e1的值同样将被改变。

Employee e2 = e1;

因此，为了使e1,e2可以各自改变状态，需要使用clone方法。clone()完全创造出一个新的对象，有自己的新的地址，只不过初始信息是和原对象是一样的。

Cloneable接口是空的，不包括任何常量和抽象方法。实现Cloneable接口的类标记为可克隆的，这个类必须覆盖在Object类中定义的clone( )方法。

Calendar calendar = new GregorianCalendar(2018,2,1);
Calendar calendar1 = calendar;          //  将calendar的引用复制给calendar1
Calendar calendar2 = (Clendar)calendar.clone();   // 克隆后对象的引用赋值给calendar2
                                                                               //    calendar和calendar2是内容相同 的 不同对象

引用:

public class House implements Cloneable , Comparable<House> {
    private int id;
    private double area;
    ...

    public House(int id , double area ){
    ...}
    ...
    @Override          // 浅复制
    public Object clone() throws CloneNotSupportedException {     
                return super.clone();
        }

    @Override          // 深复制，和上一个只能二选一写。
    public Object clone() throws CloneNotSupportedException {   
            House houseClone() = (House)super.clone();
            houseClone.whenBuilt = (java.util.Date)(whenBuilt.clone());
            return houseClone;
        }

    @Override
    public int compareTo(House o){
            ...  return 1;
            ...  return 0;
        }
}


// 创建
House house1 = new House(1, 1750);
House house2 = (House)house1.clone();

创建

House house1 = new House(1, 1750);

House house2 = (House)house1.clone();

 

 

4、接口和抽象类

通常推荐使用接口，可以定义非相关类的共有父类，更灵活。

public class NewClass extends BaseClass implements Interface1, ... ,InterfaceN{ }

public interface NewInterface extends Interface1, ... ,InterfaceN{ }    // NewInterface 为子接口