Java中的接口

Java中的接口

接口的概念

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

接口的语法规则

1.将class关键字换成interface 关键字，就定义了一个接口。(创建接口时, 接口的命名一般以大写字母 I 开头)

2.接口当中的成员方法,默认都是抽象方法,被 public abstract 修饰的

3.接口当中的成员方法,默认都是抽象方法, public abstract 修饰的

4.接口当中的普通成员方法,是不能有具体的实现的

5.接口当中的普通成员方法,如果要有具体的实现,必须加上 default 把它变成默认方法

6.接口当中可以有静态的成员方法, 但是和默认方法一样(default). 都是public修饰的

7.接口本身也是不可以被实例化的

8.接口和类的关系是使用implements来关联的

interface IShape{
    void draw();
}
class Rect implements IShape {
    @Override
    public void draw() {
        //重写接口这个抽象方法
        System.out.println("♦");
    }
}

9.一个接口可以引用 具体的实现类的(向上转型)

interface IShape{
    void draw();
}
class Rect implements IShape {
    @Override
    public void draw() {
        //重写这个抽象方法
        System.out.println("♦");
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        //一个接口可以引用 具体的实现类的
        IShape shape = new Rect();//向上转型
        shape.draw();
    }
}

10.接口当中不能有静态代码块,实例代码块,构造方法

11.一个类只能继承一个类,但是可以实现多个接口(先是继承,在实现多个接口.顺序不能颠倒)

//接口
interface IA{
    void funcA();
}
interface IB{
    void funcB();
}
//接口的扩展(继承)
interface IC extends IA, IB{
    void funcC();
}
class T implements IC{
    //继承过来的方法全部都要重写
    @Override
    public void funcA() {}
    @Override
    public void funcB() {}
    @Override
    public void funcC() {}
}

接口的使用实例

1.自定义类型的数据比较需要实现接口(Comparable),或者比较器(Comparator)来进行比较

import java.util.Arrays;
class Student implements Comparable<Student>{
    public String name;
    public int age;
    public double score;
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
    @Override
    public int compareTo(Student o) {
        //需要重写compareTo方法
        return this.age - o.age;//按照升序比较大小
    }
}
public class Test {
    public static void main(String[] args) {
        Student[] students = new Student[2];
        students[0] = new Student("张三",30,81.2);
        students[1] = new Student("李四",21,66.6);
        System.out.println("排序前" + Arrays.toString(students));
        Arrays.sort(students);
        System.out.println("排序后" + Arrays.toString(students));
    }
}
结果:
排序前[Student{name='张三', age=30, score=81.2}, Student{name='李四', age=21, score=66.6}]
排序后[Student{name='李四', age=21, score=66.6}, Student{name='张三', age=30, score=81.2}]

但是这种方法是写到类里面的比较(对类的侵入性比较强,如果我想按照字母的排序话就得修改成年龄代码比较了) 解决办法引入比较器来比较.

//年龄比较器
class AgeComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}
//名字比较器
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[2];
        students[0] = new Student("张三",30,81.2);
        students[1] = new Student("李四",21,66.6);
        System.out.println("排序前" + Arrays.toString(students));
        //传入年龄比较器参数
        AgeComparator ageComparator = new AgeComparator();
        Arrays.sort(students,ageComparator);
        System.out.println("年龄排序后" + Arrays.toString(students));
        //传入名字比较器参数
        NameComparator nameComparator = new NameComparator();
        Arrays.sort(students,nameComparator);
        System.out.println("名字排序后" + Arrays.toString(students));
    }
}
结果:
排序前[Student{name='张三', age=30, score=81.2}, Student{name='李四', age=21, score=66.6}]
年龄排序后[Student{name='李四', age=21, score=66.6}, Student{name='张三', age=30, score=81.2}]
名字排序后[Student{name='张三', age=30, score=81.2}, Student{name='李四', age=21, score=66.6}]
]
年龄排序后[Student{name='李四', age=21, score=66.6}, Student{name='张三', age=30, score=81.2}]
名字排序后[Student{name='张三', age=30, score=81.2}, Student{name='李四', age=21, score=66.6}]