一、接口

1）定义：接口是一种与类相似的结构，只包含常量和抽象方法

2）格式：

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

特点：

里面所有的东西都是public的

常量是静态（static）的

方法是抽象的

3）例子：

public interface A {    (public static final) int num = 100; //其中打括号的地方，代表可以省略    (public abstract) String sound();}

4）如何使用一个接口呢？实现（implements）抽象方法

public interface A {     int num = 100;     String sound();} class B implements A {    @Override    public String sound() {        return "汪汪";    }}

5）一些零碎

接口可以继承（extends）其他接口。一个接口可以继承多个接口

一个类只可以继承一个类，但可以实现多个接口

二、一些值得记下来的接口

1）Comparable接口定义了比较compareTo方法，用于比较对象。。这个接口在java.lang包中

package java.lang;public interface  Comparable
    
     {     public int compareTo(E o);}
    

一些类都实现了这个接口

public class Integer extends Number implements Comparable
    
     {    // class body omitted    @Override    public int compareTo(Integer o){        //impelmentation omitted    }}
    

2）Cloneable接口，给出了一个可克隆的对象。。这个接口在java.lang中

package java.lang;public interface Cloneable{}

特殊之处：空的，没有常量，也没有抽象方法。这种接口称为标记接口

实现Cloneable接口的类标记可克隆的，而且它的对象可以使用在Object类中定义的clone()方法克隆

public class A implements Cloneable{    private String s;         public A(String s){        this.s = s;    }        @Override    public Object clone(){        Object obj = null;        try{            obj = super.clone();        }catch(CloneNotSupportedException ex){            ex.printStackTrace();        }        return obj;    }     public String getS() {        return s;    }     public void setS(String s) {        this.s = s;    }        }

public class Test {    public static void main(String[] args){        A a1 = new A("mmm");        A a2 = a1;        A a3 = (A)a1.clone();                System.out.println(a1 == a2); //true        System.out.println(a1 == a3); //false        System.out.println(a1.getS().equals(a2.getS()));//true    }}

3）Serializable接口，实现这个接口的类的对象，可以写入到输出流，称为可序列化对象

特点：也是一个标记接口，因为它没有抽象方法

3.1）可序列化对象的特点

3.1.1）可以写入到输出流，也就是说可以存储在文件或者数据库中

3.1.2）它的数据域是序列化的，也就是说可以比较大小的

3.1.3）实现Serializable接口

3.2）存储一个可序列化对象的过程

当存储一个可序列化对象时，会对该对象的类进行编码。编码包括类名、类的签名、对象实例变量的值以及该对象引用的任何其他对象的闭包，但是不存储对象静态变量的值

那么如果一个对象不止一次写入到对象流，会存储对象的多个副本吗？不会。第一次写入一个对象时，就会为它创建一个序列号。java虚拟机将对象的所有内容和序列号一起写入对象流。以后每次存储时，如果再写入相同的对象，就只存储序列号。读出这些对象时，它们的引用相同，因为在内存中实际上存储的只是一个对象

3.3）那要是数据域里面，有些不可比较的数据怎么办？

public class C implements Serializable{    private int v1;    private static double v2;    private transient A v3 = new A(); //这个关键字，是告诉虚拟机                    //将对象写入对象流时忽略这个数据域}

当C类的一个对象进行序列化时，只需要序列化变量v1。因为v2是静态变量，不会序列化。v3有关键字transient，也不会序列化

3.4）例子，序列化数组（数组中所有元素都是可序列化的）

public class Test {    public static void main(String[] args) throws IOException, ClassNotFoundException{        int[] numbers = {1,2,3,4,5};        String[] strings = {"John", "Susan", "Kim"};        try(            ObjectOutputStream output = new ObjectOutputStream(new                      FileOutputStream("array.dat", true));            ){            output.writeObject(numbers);            output.writeObject(strings);        }                try(            ObjectInputStream input = new ObjectInputStream(new                     FileInputStream("array.dat"));              ){            int[] newNumbers = (int[])(input.readObject());            String[] newStrings = (String[])(input.readObject());                        for(int i=0; i < newNumbers.length; i++){                System.out.print(newNumbers[i] + " ");;                System.out.println();            }            for(int i=0; i < newStrings.length; i++){                System.out.print(newStrings[i] + " ");;            }        }    }}