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] + " ");;
			}
		}
	}
}