1.1.5 Java特性章 Interface(接口)

接口

概念

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。 在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型

接口语法

接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。

public interface 接口名称 {
	// 抽象方法
	public abstract void method1(); // public abstract 是固定搭配，可以不写
	public void method2();
	abstract void method3();
	void method4();
	// 注意：在接口中上述写法都是抽象方法，跟推荐方式4，代码更简洁
}

书写规范

1. 创建接口时, 接口的命名一般以大写字母 I 开头.
2. 接口的命名一般使用 “形容词” 词性的单词.
3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性.

接口使用

接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。

public class 类名称 implements 接口名称 {
	// ...
}

接口特性

1. 接口类型是一种引用类型，但是不能直接new接口的对象

2. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错)

3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

4. 重写接口中方法时，不能使用默认的访问权限,要指定public 或者更低的权限

   public interface USB {
   	void openDevice(); // 默认是public的
   	void closeDevice(); // 默认是public的
   }
   public class Mouse implements USB {
   	@Override
       //这里要用public修饰,不能默认
   	void openDevice() {
   		System.out.println("打开鼠标");
   	}
   
   }
   // 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
   // 正在尝试分配更低的访问权限; 以前为public
   
   

5. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量

6. 接口中不能有静态代码块和构造方法

7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

9. jdk8中：接口中还可以包含default方法(可以直接在接口中写函数内容的关键字)。

继承和接口混用

一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

提示, IDEA 中使用 ctrl + i 快速实现接口

下面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口

这样设计有什么好处呢? 时刻牢记多态的好处, 让人忘记类型. 有了接口之后, 类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力.

class Animal {
	protected String name;
	public Animal(String name) {
		this.name = name;
	}
}

nterface IFlying {
	void fly();
}
interface IRunning {
	void run();
}
interface ISwimming {
	void swim();
}


class Frog extends Animal implements IRunning, ISwimming {
	public Frog(String name) {
		super(name);
	}
	@Override
	public void run() {
		System.out.println(this.name + "正在往前跳");
	}
	@Override
	public void swim() {
		System.out.println(this.name + "正在蹬腿游泳");
	}
}

接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到 多继承的目的。

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字

interface IRunning {
	void run();
}
interface ISwimming {
	void swim();
}
	// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
	...
}
//通过接口继承创建一个新的接口 IAmphibious 表示 "两栖的". 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法.

注意点

注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系

Clonable 接口和深拷贝

Java 中内置了一些很有用的接口, Clonable 就是其中之一.

Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 “拷贝”. 但是要想合法调用 clone 方法, 必须要 先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常

clone继承object的,object拷贝是浅拷贝

1. 浅拷贝即为内容拷贝,是把原来的地址赋给了另一个对象,即另一个对象本身的地址和被clone对象的地址不同,但是两个对象内容指向的对象是相同的,只要new的对象则一定开辟地址,即new的对象一定地址不同,但如果继承object的clone而不重写深拷贝,则clone后两个对象地址不同,但指向的空间地址相同
2. java实现的数据结构比如String他们的clone就是深拷贝,即new的对象地址不同,对象指向的空间地址也不同

对象不同

lass Animal implements Cloneable {
	private String name;
	@Override
	public Animal clone() {
		Animal o = null;
		try {
			o = (Animal)super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return o;
	}
}
public class Test {
	public static void main(String[] args) {
		Animal animal = new Animal();
		Animal animal2 = animal.clone();
		System.out.println(animal == animal2);
	}
}
// 输出结果
// false
//flase的原因是因为两个对象地址不同,但是内容地址相同(应为调用的是super的克隆(也就是object),这个克隆是浅拷贝,即new的对象地址不一样,但是指向的内容相同,而array,String等官方实现的类他们的克隆都是深克隆(new的地址不同,new出对象指向的对象也不同))

对象内容相同

class Money {
	public double m = 99.99;
}
class Person implements Cloneable {
	public Money money = new Money();
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}
public class TestDemo3 {
	public static void main(String[] args) throws CloneNotSupportedException {
		Person person1 = new Person();
		Person person2 = (Person) person.clone();
		System.out.println("通过person2修改前的结果");
		System.out.println(person1.money.m);
		System.out.println(person2.money.m);
		person2.money.m = 13.6;
		System.out.println("通过person2修改后的结果");
		System.out.println(person1.money.m);
		System.out.println(person2.money.m);
	}
}
// 执行结果
通过person2修改前的结果
99.99
99.99
通过person2修改后的结果
13.6
13.6

抽象类与接口的区别

核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中 不能包含普通方法, 子类必须重写所有的抽象方法.(但是. jdk8中：接口中还可以包含default方法,也可以写默认的方法了,但是不能写普通成员变量)

区别	抽象类(abstract)	接口(interface)
结构组成	普通类+抽象方法	抽象方法+全局常量
权限	各种权限	public
子类使用	使用extends关键字继承抽象类	使用implements关键字实现接口
关系	一个抽象类可以实现若干个接口(即子类也要实现继承的接口方法)	接口不能继承抽象类,但是接口可以使用extend关键字继承多个接口(达到多继承的目的)
子类限制	一个子类只能继承一个抽象类(不能多继承)	一个子类可以实现多个接口