一,接口之间的继承
接口与接口之间的继承使用 extends 关键字,并且一个接口可以继承多个接口,例如:
interface A{
void eat();
}
interface B{
void sleep();
}
interface C extends A,B{
int a = 10;
}
注意:接口之间的继承可以不重写抽象方法,但实现了接口的类必须重写接口中的抽象方法,例如:
interface A{
void eat();
}
interface B{
void sleep();
}
interface C extends A,B{
int a = 10;
}
public class Test implements C{
@Override
public void eat() {
System.out.println("吃饭!");
}
@Override
public void sleep() {
System.out.println("睡觉!");
}
}
二,抽象类和接口的区别
1.抽象类中可以有普通方法也可以有抽象方法,而接口中方法默认是由public abstract修饰的
2.抽象类中可以有普通类成员,而接口中的成员变量默认是public static final修饰的
3.一个类只可以继承一个抽象类,却可以实现多个接口
4.接口也可以继承多个接口
三,接口使用实例
比较大小-------对象数组排序
在JAVA中我们可以通过Array.sort()来实现数组的排序,例如:
public class Test1 {
public static void main(String[] args) {
int[] a = new int[]{9,3,2,1,5,4,7,0};
System.out.println(Arrays.toString(a));
Arrays.sort(a);
System.out.println(Arrays.toString(a));
}
}
那么当我们刚才的整形数组变成对象数组时,我们是否还能直接通过Arrays.sort()来实现排序呢?
import java.util.Arrays;
class Person{
public String name;
public int age;
public Person(String name, int age){
this.name = name;
this.age = age;
}
}
public class Test2 {
public static void main(String[] args) {
Person[] people = new Person[3];
people[0] = new Person("zhangsan",10);
people[1] = new Person("lisi",5);
people[2] = new Person("wangwu",9);
Arrays.sort(people);
System.out.println(Arrays.toString(people));
}
}
答案是否定的,因为此时的情况比较复杂,我们定义的Person类有两个成员变量(name和age),也就是说,我们可以按照name来排序,也可以按照age来排序,在这种情况下,我们需要规定按照什么来比较大小,这个时候我们就要使用Comparable接口并重写其中的compareTo方法,例如:
import java.util.Arrays;
class Person implements Comparable<Person>{
public String name;
public int age;
public Person(String name, int age){
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "[" + this.name + "," + this.age + "]";
}
@Override
public int compareTo(Person o) {
return this.age - o.age;
}
}
public class Test2 {
public static void main(String[] args) {
Person[] people = new Person[3];
people[0] = new Person("zhangsan",10);
people[1] = new Person("lisi",5);
people[2] = new Person("wangwu",9);
System.out.println("排序前:"+Arrays.toString(people));
Arrays.sort(people);
System.out.println("排序后:"+Arrays.toString(people));
}
}
总结:在比较一个复杂对象时,需要一个标准(按照什么比较),因此在JAVA中我们需要实现Comparable接口并且重写compareTo方法,因为Arrays.sort()方法会调用comparaTo方法,并以此来排序,在C语言中也有类似的函数,例如qsort函数,需要我们提供一个比较函数。我们可以将两者联系起来,方便理解。
下面我们使用冒泡排序来实现一下sort方法(Person类与上面的一致):
public class Test2 {
public static void bubble(Comparable[] comparable){
for (int i = 0; i < comparable.length - 1; i++) {
for (int j = 0; j < comparable.length - 1 - i; j++) {
if(comparable[j].compareTo(comparable[j+1]) > 0){
Comparable tmp = comparable[j];
comparable[j] = comparable[j+1];
comparable[j+1] = tmp;
}
}
}
}
public static void main(String[] args) {
Person[] people = new Person[3];
people[0] = new Person("zhangsan",10);
people[1] = new Person("lisi",5);
people[2] = new Person("wangwu",9);
System.out.println("排序前:"+Arrays.toString(people));
bubble(people);
System.out.println("排序后:"+Arrays.toString(people));
}
}
接下来介绍另外一种比较大小的方式--------Comparator接口
//通过名字比较
class NameComparator implements Comparator<Person>{
@Override
public int compare(Person o1, Person o2) {
return o1.name.compareTo(o2.name);
}
}
public class Test2 {
public static void main(String[] args) {
Person people1 = new Person("zhangsan",10);
Person people2 = new Person("lisi",5);
NameComparator nameComparator = new NameComparator();
System.out.println(nameComparator.compare(people1,people2));
}
}