Java 接口

一、接口

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<E>{
     public int compareTo(E o);
}

一些类都实现了这个接口

public class Integer extends Number implements Comparable<Integer>{
    // 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] + " ");;
            }
        }
    }
}

Java 接口

原文：https://www.cnblogs.com/youpeng/p/10991778.html