2021-10-13

接口

1. 为了完成某种功能： 门和门铃
2. 为了兼容某种规范： USB接口

语法：

修饰符 abstract interface 接口名 { //其中abstract是默认的

        //修饰符只能是public或默认不写

}

public abstract interface I { 
    public static final int i = 1; //public static final默认的 
    public abstract void f(); //抽象方法，//public static默认的 
    public static void h() { //静态方法在接口中可以有方法体， public是默认的         
        System.out.println("静态方法"); 
    } 
    public default void i() { //public是默认的 
        System.out.println("默认方法"); 
    } 
    private void j() {
        System.out.println("私有方法");
    }
}

标记性接口： 一个接口中没有任何方法，比如Serializable

函数式接口： 一个接口中有一个抽象方法（至于有没有其它的比如static，default方法都没关系）。

函数式接口可以用来存放一个lambda表达式。

@FunctionalInterface注解用来校验一个接口是不是函数式接口。

接口的使用

1. 接口和接口之间： 继承 interface K{} public interface J extends I, K{ //接口可以继承多个父接口 }
2. 接口和类之间： 实现 public class A implements I, J{ //类可以实现多个接口 //当一个类实现了接口后，应该实现其中的所有抽象方法，否则这个类应该被标记为抽象的 }

Java接口中的default，static和private方法

1. private方法         私有方法唯一的作用就是被default和static方法调用
2. static方法            static方法一般是一些工具方法，可以直接执行。 一些不会变更的，非常常用的功能，都可以以static方法的形式出现在接口中
3. default方法          一般是一些工具方法，而且实现这个接口的类可以选择性的覆盖这个方法

default方法冲突及其解决:

当一个类同时实现多个接口，且这些接口中又有相同的default方法，那么这个类谁的也不用，必须覆盖。

public interface I { 
    default void f() { 
        System.out.println("接口I中的方法f"); 
    } 
} 
public interface J { 
    default void f() { 
        System.out.println("接口J中的方法f"); 
    } 
} 
public class A implements I, J{ 
    public static void main(String[] args) { 
        A a = new A(); 
        a.f(); 
    } 
    @Override 
    public void f() { 
        System.out.println("A自己的方法f"); 
    } 
} 

2-3对比：static不能被覆盖，default可以

Java中的常见接口：

1. Comparable: 对象之间进行大小比较。通常用于排序。 comparaTo
2. Comparator： 无法使用Comparable的情况下，就可以考虑使用Comparator接口。compara
3. Cloneable接口： 对象克隆（拷贝），创建出一个和当前对象完全相同的新对象。 

浅拷贝: 被拷贝的对象实现Cloneable接口，之后调用Object中的clone方法即可

import java.util.Date; 
public class A implements Cloneable { 
    public int i; 
    public Date date;

    public A(int i, Date date) {
        this.i = i;
        this.date = date;
    }
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    @Override
    public String toString() {
        return "A{" +
            "i=" + i +
            ", date=" + date +
            '}';
    }

}

import java.util.Date; 
public class Test { 
    public static void main(String[] args) throws CloneNotSupportedException { 
        A a = new A(1, new Date()); 
        System.out.println(a);

        A a1 = (A) a.clone();
        System.out.println(a1);
    }

}

深拷贝

浅拷贝对于基本类型都是正常做了一个复制，但是引用类型只是拷贝了一下地址。 深拷贝就是对于引用类型的对象也做一份拷贝。
 

@Override 
public Object clone() throws CloneNotSupportedException { 
    A newA = (A)super.clone(); 
    newA.date = (Date) this.date.clone(); 
    return newA; 
}

public class Test { 
    public static void main(String[] args) throws CloneNotSupportedException { 
        A a = new A(1, new Date()); 
        A a1 = (A) a.clone();
    
        a.i = 10000;
        a.date.setYear(1);
        System.out.println(a);
        System.out.println(a1);
    }

}

当一个类里面没有引用类型，浅拷贝就是深拷贝。 当存在引用类型的时候，对每一个引用类型再次拷贝就是深拷贝。