文章目录
接口
1. 接口的概念
电脑的USB口上,可以插:U盘、鼠标、键盘…所有符合USB协议的设备
电源插座插孔上,可以插:电脑、电视机、电饭煲…所有符合规范的设备
通过上述例子可以看出:接口就是公共的行为规范标准,大家在实现时,只要符合规范标准,就可以通用。在Java中,接口可以看成是:多个类的公共规范,是一种引用数据类型。
2. 语法规则
接口的定义格式与定义类的格式基本相同,将class关键字换成interface 关键字,就定义了一个接口。
public interface 接口名称{
// 抽象方法
public abstract void method1(); // public abstract 是固定搭配,可以不写
public void method2();
abstract void method3();
void method4();//在这里public abstract可以省略
// 注意:在接口中上述写法都是抽象方法,跟推荐方式4,代码更简洁
}
提示:
- 创建接口时, 接口的命名一般以大写字母 I 开头.
- 接口的命名一般使用 "形容词" 词性的单词.
- 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性.
3. 接口特性
- 它使用interface来定义接口,并且他不能实例化。
interface IUS {
void openDevice();
void closeDevice();
}
public class Test {
//假设将IUS实例化 根据结果可以证明接口是不能进行实例化。
IUS ius = new IUS();
public static void main(String[] args) {
}
}
结果:
- 接口当中的成员 默认是public static final
interface IUS {
public static final double a = 2.0;
//下面那个写法和上面的是一样的下面的缩写但意义相同
double b = 1.0;
double c;//报错
}
public class Test {
public static void main(String[] args) {
System.out.println(IUS.a);// 可以直接通过接口名访问,说明是静态的
IUS.a = 2.0; // 说明a具有final属性
// 编译报错:Error:(12, 12) java: 无法为最终变量a分配值
}
}
因为final而报的错
- jie接口中的方法,不写也是默认的public abstract 的,其他修饰符都会报错
只有包含了abstract和public或者默认值在接口中设定方法不会报错, 其他修饰符会报错
- 接口当中的方法 不能具体的实现,但是从JDK8开始就出现了可以使用default写的方法了。
结果:
- 接口当中不能有构造方法和静态代码块
根据上图可以显示构造方法和静态代码块是不能写在接口当中的
- 接口的实现需要通过类,使用关键字implements
语法格式:
public class 类名称 implements 接口名称{
// ...
}
注意:子类和父类之间是extends 继承关系,类与接口之间是 implements 实现关系。
- 接口当中可以有static修饰的方法
在接口中static可以修饰普通方法,但不能修饰抽象方法。
- 重写接口中方法时,不能使用默认的访问权限
在这里Dog类中直接使用void draw()重写接口中的方法时他是默认访问权限而在接口中的void draw()的访问权限是public,重写的时候子类的访问权限一定要大于等于父类的访问权限。使用在这里swim方法没有报错,draw方法报错了。
编译结果:
- 如果类没有实现接口中的所有的抽象方法,则类必须设置为抽象类
如果没有实现抽象类也没有实现重写这里会报错。
- 接口虽然不是类,但是接口编译完成后字节码文件的后缀格式也是.class
4. 接口使用
在这里我们使用一个例子
实现笔记本电脑使用USB鼠标、USB键盘
- USB接口:包含打开设备、关闭设备功能
- 笔记本类:包含开机功能、关机功能、使用USB设备功能
- 鼠标类:实现USB接口,并具备点击功能
- 键盘类:实现USB接口,并具备输入功能
在同一个包中写
IUSB接口
package demo3;
public interface IUSB {
//打开设备
void openDevice();
//关闭设备
void closeDevice();
}
鼠标服务,通过实现接口IUSB来重写相关信息
package demo3;
public class Mouse implements IUSB{
@Override
public void openDevice() {
System.out.println("打开鼠标服务!");
}
@Override
public void closeDevice() {
System.out.println("关闭鼠标服务!");
}
//鼠标特有的方法
public void click() {
System.out.println("点击鼠标");
}
}
在键盘类中实现IUSB接口
package demo3;
public class KeyBoard implements IUSB {
@Override
public void openDevice() {
System.out.println("打开键盘!");
}
@Override
public void closeDevice() {
System.out.println("关闭键盘!");
}
//键盘类中特有的
public void inPut() {
System.out.println("敲击键盘");
}
}
笔记本类,使用USB设备功能
package demo3;
public class Computer {
public void open() {
System.out.println("开机!");
}
public void close() {
System.out.println("关机!");
}
//通过测试类传参数发生了向上转型
public void useDevice(IUSB usb) {
//打开设备
usb.openDevice();
//instanceof是Java中的二元运算符,左边是对象,右边是类;当对象是右边类或子类所创建对象时,返回true;否则,返回false。
//instanceof左边显式声明的类型与右边操作元必须是同种类或存在继承关系,也就是说需要位于同一个继承树,否则会编译错误
if(usb instanceof Mouse) {
//在这里我们通过向下转型来调用子类中特有的方法。
Mouse mouse = (Mouse) usb;
mouse.click();
} else if(usb instanceof KeyBoard) {
KeyBoard keyBoard = (KeyBoard) usb;
((KeyBoard) usb).inPut();
}
//关闭设备
usb.closeDevice();
}
}
测试类
package demo3;
public class Test {
public static void main(String[] args) {
Computer computer = new Computer();
computer.open();
Mouse mouse = new Mouse();
KeyBoard keyBoard = new KeyBoard();
computer.useDevice(mouse);
System.out.println("===================");
computer.useDevice(keyBoard);
computer.close();
}
}
结果:
5. 实现多个接口
在Java中,类和类之间是单继承的一个类只能有一个父类,即Java中不支持多继承,但是一个类可以实现多个接
口。
- java 中不可以继承多个类
当我们想要一下继承多个类的时候编译器就会报错。
- java中可以直接实现多个接口
创建了吃,跑,游三个接口
通过Dog类同时实现了三个接口。
注意:一个类实现多个接口时,每个接口中的抽象方法都要实现,否则类必须设置为抽象类。
在IDEA中快速创建重写方法的快捷方法
IDEA 中使用 ctrl + i 快速实现接口
- 在java中同时实现继承和接口
当在java中同时出现继承和接口 应该 先继承 再接口
6. 接口间的继承
在Java中,类和类之间是单继承的,一个类可以实现多个接口,接口与接口之间可以多继承。即:用接口可以达到
多继承的目的。
接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
void eat();
}
class Frog implements IAmphibious {
@Override
public void run() {
}
@Override
public void swim() {
}
@Override
public void eat() {
}
}
通过接口继承创建一个新的接口 IAmphibious 表示 “两栖的”. 此时实现接口创建的 Frog 类, 就继续要实现 run 方
法, 也需要实现 swim 方法.
接口间的继承相当于把多个接口合并在一起.
7. 通过几个例子更深刻的理解接口
1. comparable
- 以前咱们进行数组的排列是通过Arrays.sort实现的。
通过一个例子来引入comparable接口
class Student {
public String name;
public int age;
public int score;
//构造方法
public Student(String name, int age, int score) {
this.name = name;
this.age = age;
this.score = score;
}
//重写toString
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
}
public class Test {
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] = new Student("zhangsan",19,10);
students[1] = new Student("lisi",59,20);
students[2] = new Student("abs",39,5);
System.out.println(Arrays.toString(students));
Arrays.sort(students);
System.out.println(Arrays.toString(students));
}
}
这个时候我们不知道这个排序要根据什么排序,我们得指定一下拿什么排序。这时候编译器出错了
蓝色的是你源码报错的位置,灰色的是再sort方法里面那里报错了。
根据图解引入接口Comparable
这时候我们将class Student 实现接口Comparable
并在类当中重写compareTo方法
- 通过年龄排序
@Override
public int compareTo(Student o) {
if(this.age > o.age) {
return 1;
} else if(this.age < o.age) {
return -1;
} else {
return 0;
}
//简便方法
return this.age-o.age;
}
- 通过成绩比较
public int compareTo(Student o) {
//简便方法
return this.score-o.score;
}
- 通过名字进行比较
public int compareTo(Student o) {
//这里的compareTo调用的是String类型的方法
return this.name.compareTo(o.name);
}
点进源文件进入查看发现这个compareTo是String类型的方法。
为了进一步了解接口,我们写一个sort方法(使用冒泡排序)
//向上转型
public static void sort(Comparable[] array) {
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length-1-i; j++) {
if (array[j].compareTo(array[j+1])>0) {
Comparable tmp = array[j];
array[j] = array[j+1];
array[j+1] =tmp;
}
}
}
}
这个接口不是很灵活,当写定的化就固定了排序方法不能进行改变了。
2. Comparator接口 — 比较器
在Arrays.sort 中有Comparator。
改造代码
根据年龄比较
class AgeComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.age - o2.age;
}
}
class ScoreComparator implements Comparator<Student>{
//根据成绩比较
@Override
public int compare(Student o1, Student o2) {
return o1.score-o2.score;
}
}
class NameComparator implements Comparator<Student> {
//根据姓名比较
@Override
public int compare(Student o1, Student o2) {
return o1.name.compareTo(o2.name);
}
}
调用的时候:
public class Test {
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] =new Student("zhangsan",8,30);
students[1] =new Student("abc",7,20);
students[2] =new Student("lisi",6,10);
//定义比较年龄的对象
AgeComparator ageComparator = new AgeComparator();
//定义比较成绩的对象
ScoreComparator scoreComparator = new ScoreComparator();
//定义比较名字的对象
NameComparator nameComparator = new NameComparator();
//通过年龄的比较进行排序
Arrays.sort(students,ageComparator);
System.out.println(Arrays.toString(students));
System.out.println("=====================");
//通过成绩的比较进行排序
Arrays.sort(students,scoreComparator);
System.out.println(Arrays.toString(students));
System.out.println("==================");
//通过名字的比较进行排序
Arrays.sort(students,nameComparator);
System.out.println(Arrays.toString(students));
}
}
结果:
8. Clonable 接口和深拷贝
Java 中内置了一些很有用的接口, Clonable 就是其中之一.
Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 “拷贝”. 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常.
要想一个类被克隆要实现一个接口Clonable
这个接口当中什么也没有, 这种空接口被叫做标记接口 ----》作用,表示当前对象可以被克隆
在Idea中类实现了Conable 在类中重写父类Object中的clone的快捷方法 这里提到了Object,Object是所有类的父类。
例子:
class Student implements Cloneable{
//表示当前对象可以被克隆
public String name;
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
//向下转型
Student student = (Student) super.clone();
student.m = (Money) this.m.clone();
return student;
}
}
public class Test {
//在这个main当中如果不属于throws 那么下面调用的.clone()会报错
public static void main(String[] args)throws CloneNotSupportedException {
Student student1 = new Student();
student1.name = "帽子";
//向下转型
Student student2 = (Student) student1.clone();
System.out.println(student1);
System.out.println(student2);
}
}
结果:
浅拷贝
class Money {
public double money = 10.0;
}
class Student implements Cloneable{
//表示当前对象可以被克隆
public String name;
//组合
public Money m = new Money();
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
//重写clone()方法
@Override
protected Object clone() throws CloneNotSupportedException {
Student student = (Student) super.clone();
return student;
}
}
public class Test {
public static void main(String[] args)throws CloneNotSupportedException {
Student student1 = new Student();
Student student2 = (Student) student1.clone();
System.out.println(student1.m.money);
System.out.println(student2.m.money);
student2.m.money = 99;
System.out.println("===============赋值之后============");
System.out.println(student1.m.money);
System.out.println(student2.m.money);
}
}
结果:
图解:
深拷贝
class Money implements Cloneable{
public double money = 10.0;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Student implements Cloneable{
//表示当前对象可以被克隆
public String name;
//组合
public Money m = new Money();
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
Student student = (Student) super.clone();
student.m = (Money) this.m.clone();
return student;
}
}
public class Test {
public static void main(String[] args)throws CloneNotSupportedException {
Student student1 = new Student();
Student student2 = (Student) student1.clone();
System.out.println(student1.m.money);
System.out.println(student2.m.money);
student2.m.money = 99;
System.out.println("===============赋值之后============");
System.out.println(student1.m.money);
System.out.println(student2.m.money);
}
}
结果:
图解:
深浅拷贝和实现的方法没有关系和你实现的方式有关系。
以上内容如果对诸位有帮助的话可以留下你们的赞赞,如果我书写的有问题,请在评论区指出,我会及时修改的。