零基础Java学习之接口

介绍

接口的介绍我们从三个方面来说：

从使用上来说是继承的一种扩展，因为java不支持多继承，而有了接口就能够实现多继承的效果。
有时候需要必须从几个类中抽取出一些共同的行为特征，而它们之间又没有继承的关系，仅仅是具有相同的行为特征而已，比如人和动物都会跑，但是他们不是属于一类的，而且跑的行为的表现形式不一样，他们仅仅都具有跑这个行为而已。
接口可以看出是一种规范，标准，它用来定义了一组规则。如果你需要用到了该接口（再次强调不是继承的关系），那你必须要遵守这个规范。

定义

Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。（官方定义）

换句话说就是：接口，是Java语言中一种引用类型，是方法的集合，接口的内部只是声明了方法，并没有实现（也不能实现）。

注：引用数据类型：数组，类，接口

接口声明格式

【修饰符】 interface 接口名 [extends 其他的接口名]{//接口的成员列表：// 静态常量// 抽象方法// 默认方法// 静态方法// 私有方法
}

接口声明需要注意：

接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。

接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。

接口中的方法都是公有的。

JDK 1.8之前

接口中所有的成员变量，默认都是共有的静态常量(其中public static final可以省略)

接口中的所有成员方法，默认都是共有的抽象方法(其中public abstract可以省略)

接口不能实例化对象的，也没有构造器

没有初始化块

在JDK 1.8时

接口中允许声明默认方法(public 可以省略，建议保留)
default void 方法名(){ 方法体 }
使用方法: 对象名.方法名;
可以被实现类重写

接口中允许声明静态方法(public 可以省略，建议保留)
static void 方法名(){ 方法体 }
使用方法：接口名.方法名(); 一般使用在工具方法上

实现

当接口被定义后，一个或者多个类都可以实现该接口（前面说的几个类中抽取出一些共同的行为特征），也可以一个类实现多个接口。接口的实现需要在相应的类的定义中包含 implements关键字。

语法格式

【修饰符】 class 实现类  implements 接口1【,接口2, ...】{ //一个类可以同时实现多个接口// 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写// 重写接口中默认方法【可选】
}

接口实现需要注意：

必须重写接口中所有抽象方法。

继承了接口的默认方法，即可以直接调用，也可以重写。
重写时，default单词就不要再写了，它只用于在接口中表示默认方法，到类中就没有默认方法的概念了

不能重写静态方法

如果多个接口中有抽象方法有重名的，只需要重写一次

代码示例

public interface Attack {void attack();
}public interface Fly extends Aa,Ba{int id = 1; // 默认共有的静态常量void method(); //默认共有的抽象方法}public class Aircraft implements Fly,Attack {//所有的抽象方法都得实现@Overridepublic void attack() {System.out.println("攻击");}@Overridepublic void method() {}}

接口中方法的调用

说明

对于接口的抽象方法、默认方法，通过实现类对象就可以调用；
但是对于接口的静态方法，必须使用接口名才能调用

代码实例

public interface Fly {public void fly(); //抽象方法//静态方法（默认共有的）static void staticMethod(){System.out.println("Fly中的静态方法");}//默认方法default void defauleMethod(){System.out.println("Fly中的默认方法");}
}public class Aircraft implements Fly {@Overridepublic void fly() {System.out.println("飞机会飞");}@Overridepublic void defauleMethod() {System.out.println("飞机重写的默认方法");}}public class Demo1 {public static void main(String[] args) {Fly.staticMethod();//接口的静态方法可以通过接口名调用Aircraft aircraft = new Aircraft();//        aircraft.staticMethod(); 静态方法不能通过对象调用//        Fly.defaultMethod(); 默认方法不能通过接口调用调用aircraft.defauleMethod();//默认方法通过对象调用}
}

接口的继承

说明

一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。在Java中，类的多继承是不合法，但接口允许多继承（类的扩展的体现）。在接口的多继承中extends关键字只需要使用一次，在其后跟着其他需要继承接口。

语法格式

public interface 接口名1 extends 接口名2 【, 接口名2,...】{ }

子接口继承父接口的方法；如果实现了某一个接口，其父类的抽象方法也必须实现
子接口重写默认方法时，default关键字可以保留。

代码示例

interface A {void a();public default void methodA(){System.out.println("接口A的方法");}
}interface B {void b();public default void methodB(){System.out.println("接口B的方法");}
}interface C extends A,B{@Overridepublic default void methodB() {System.out.println("接口C的方法");}
}class D implements C{@Overridepublic void a() {System.out.println("xxxxx");}@Overridepublic void b() {System.out.println("yyyyy");}}

标记接口

介绍

最常用的继承接口是没有包含任何方法的接口，称为标记接口。

标记接口是没有任何方法和属性的接口。它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。

标记接口作用

简单形象的说就是给某个对象打个标（盖个戳），使对象拥有某个或某些特权。

建立一个公共的父接口：
你可以使用一个标记接口来建立一组接口的父接口。例如：当一个接口继承了EventListener接口，Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。
向一个类添加数据类型：
这种情况是标记接口最初的目的，实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法)，但是该类通过多态性变成一个接口类型。

举例

java.awt.event 包中的 MouseListener 接口继承的 java.util.EventListener 接口定义如下：

package java.util;
public interface EventListener{ }

经典接口介绍

java.lang.Comparable

基本数据类型的数据（除boolean类型外）需要比较大小的话，直接使用比较运算符即可，但是引用数据类型是不能直接使用比较运算符来比较大小的，而这个又是比较常用的。那么，如何解决这个问题呢？

Java给所有引用数据类型的大小比较方式，即指定了一个标准接口，就是java.lang.Comparable接口：

package java.lang;public interface Comparable{int compareTo(Object obj);
}

如果想要比较某个类的对象的大小时候时，按照如下步骤执行：

第一步：哪个类的对象要比较大小，哪个类就实现java.lang.Comparable接口，并重写方法

方法体就是你要如何比较当前对象和指定的另一个对象的大小

第二步：对象比较大小时，通过对象调用compareTo方法，根据方法的返回值决定谁大谁小。

this对象（调用compareTo方法的对象）大于指定对象（传入compareTo()的参数对象）返回正整数
this对象（调用compareTo方法的对象）小于指定对象（传入compareTo()的参数对象）返回负整数
this对象（调用compareTo方法的对象）等于指定对象（传入compareTo()的参数对象）返回零

代码示例

package com.atguigu.bean;public class Person implements Comparable{private int id;private String name;private int age;public Person() {}public Person(int id, String name, int age) {this.id = id;this.name = name;this.age = age;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Person{" +"id=" + id +", name='" + name + '\'' +", age=" + age +'}';}/*根据年龄排序*/@Overridepublic int compareTo(Object o) {//多态参数  Object o=new Person()if (this == o)return 0; //地址一样，则相同if (o instanceof Person){Person per = (Person)o;return this.age - per.age;}return -1; //类型不一致，直接小于}
}import com.atguigu.bean.Person;import java.util.Arrays;public class Demo2 {public static void main(String[] args) {Person[] persons=new Person[5];persons[0]=new Person(1,"翠花",18);persons[1]=new Person(2,"小芬",28);persons[2]=new Person(3,"lily",16);persons[3]=new Person(4,"狗蛋",38);persons[4]=new Person(5,"石破天",19);Arrays.sort(persons);for (int i = 0; i < persons.length ; i++) {System.out.println(persons[i].toString());}}}

java.util.Comparator

如果一个类，实现了Comparable接口，也指定了两个对象的比较大小的规则（也可能没有实现），但是此时此刻如果不想按照它预定义的方法比较大小，该怎么办？（不能随意修改，因为会影响其他地方的使用）

JDK在设计类库之初，也考虑到这种情况了，所以又增加了一个java.util.Comparator接口。

package java.util;public interface Comparator{int compare(Object o1,Object o2);
}

如果想要比较某个类的对象的大小时候时，按照如下步骤执行：

第一步：编写一个类，我们称之为比较器类型，实现java.util.Comparator接口，并重写方法

方法体就是你要如何指定的两个对象的大小

第二步：比较大小时，通过比较器类型的对象调用compare()方法，将要比较大小的两个对象作为compare方法的实参传入，根据方法的返回值决定谁大谁小。

o1对象大于o2返回正整数
o1对象小于o2返回负整数
o1对象等于o2返回零

代码示例

import com.atguigu.bean.Employee;import java.util.Arrays;
import java.util.Comparator;public class Demo3 {public static void main(String[] args) {Employee[] employees = new  Employee[5];employees[0] = new Employee(1,"jack1",2000.6);employees[1] = new Employee(2,"jack2",1001);employees[2] = new Employee(3,"jack3",5000);employees[3] = new Employee(4,"jack4",2000.3);employees[4] = new Employee(5,"jack5",3000);Arrays.sort(employees,new Myclass());for (int i = 0; i < employees.length; i++) {System.out.println(employees[i]);}}
}class Myclass implements Comparator {/*按照薪资进行排序*/@Overridepublic int compare(Object o1, Object o2) {if (o1 == o2)return 1;if (o1 instanceof Employee && o2 instanceof Employee){Employee employee1 = (Employee) o1;Employee employee2 = (Employee) o2;return (int) (employee1.getSalary() - employee2.getSalary());}return -1;}
}