Java基础(接口)

明月锁清秋.

于 2024-08-31 20:46:28 发布

阅读量479

点赞数 16

分类专栏：编程语言学习文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_74384492/article/details/141757059

版权

编程语言学习专栏收录该内容

9 篇文章 0 订阅

订阅专栏

为什么要有接口

在Java中，类只支持单继承，但是有些适合，一个类需要继承多个父类来达到优化代码的效果，此时，类的单继承成了新类创建的束缚，接口的创建解决了这一问题。

接口的定义

接口是一种行为规范，一个接口中只有方法的特征和声明，没有此方法的实现，这些方法需要在不同的地方被不同的类实现，这些实现可以具有不能的功能。

接口的特点

接口用interface定义

定义接口

如下图所示，定义一个名称为动物的接口和名称为飞行的接口。

public interface Animal {
    public abstract void eat();
    public abstract void sleep();
}

public interface Flyable {
    public abstract void fly();
}

类继承接口

如下图所示，将AnimalBase类继承动物接口。

public abstract class AnimalBase implements Animal{
    @Override
    public void eat() {
        System.out.println("这是eat方法");
    }

    @Override
    public void sleep() {
        System.out.println("这是sleep方法");

    }
}

如下图所示，将bird类继承AnimalBase类和飞行接口。

public class Bird extends AnimalBase implements Flyable{
    @Override
    public void fly() {
        System.out.println("这是fly方法");
    }
}

接口当中只能使用抽象方法

接口当中只能使用抽象方法，所以不需要写abstract关键字，默认也是public访问修饰符修饰的。如下图所示，abstract关键字和public关键字都处于灰色状态，表示这个方法默认已经是abstract和public修饰的方法。

接口类不能创建对象，只能用多态

接口没有构造方法，接口没有办法使用new关键字开辟内存空间创建对象，但是可以使用多态。

一个类可以继承多个接口

设计接口的目的之一就是要实现Java类的多继承。由此，一个类可以继承多个接口。

实现接口中的方法

在实现(继承)接口的类中，普通类必须实现接口中的所有方法，如果不实现接口中所有的方法，那么该类是抽象类

接口和接口之间可以互相继承

接口与接口之间可以相互继承，如下所示，飞行接口继承了动物接口。

public interface Flyable extends Animal {
    public abstract void fly();
}

其他特点

接口中所有的成员变量都是由public static final修饰。

接口中的所有方法默认都是public abstract修饰。

与继承关系类似，接口与实现类之间存在多态性。

抽象类与接口的区别

抽象类是对行为的抽象，是一种模板设计。接口是一种行为规范(接口的定义)。

接口实例

实例1 Servlet

Servlet接口中有init()初始化方法、service()服务方法、destroy()销毁方法，这三个方法定义了servlet生命周期。除此之外还有getServletConfig()方法获取servlet的配置、getServletInfo()方法获取servlet信息。

GenericServlet是一个抽象类，实现了Servlet接口中的部分方法（与生命周期相关的方法）。

HttpServlet实现了service()方法。

使用Servlet时可以继承上面的基本方法，使代码更加简洁。

实例2 comparable接口

引用类型排序

基本数据类型进行排序时，可以使用Arrays.sort()进行排序。但是将Arrays.sort()用于引用类型时，程序将会报错。

实现引用类型的排序，我们可以使用comparable接口。

public class Person implements Comparable<Person>{
    private Integer age;
    private Integer height;
 
    public Person(int age, int height) {
        this.age = age;
        this.height = height;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", height=" + height +
                '}';
    }
 
    //实现排序的核心方法
    @Override
    public int compareTo(Person o) {
        //制定age从小到大进行排序age - o.age
        //制定age从大到小进行排序o.age - age
        return age - o.age;
    }
}

public class _02 {
    public static void main(String[] args) {
        Person p1=new Person(30,180);
        Person p2=new Person(22,178);
        Person p3=new Person(27,166);
        Person p4=new Person(35,177);
        Person[] persons=new Person[]{p1,p2,p3,p4};
        Arrays.sort(persons);
        System.out.println(Arrays.toString(persons));
    }
}

程序输出：

sort方法分析

冒泡排序

public class Person implements Comparable<Person>{
    private Integer age;
    private Integer height;
 
    public Person(int age, int height) {
        this.age = age;
        this.height = height;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", height=" + height +
                '}';
    }
 
    //实现排序的核心方法
    @Override
    public int compareTo(Person o) {
        //制定age从小到大进行排序age - o.age
        //制定age从大到小进行排序o.age - age
        return age - o.age;
    }
}

public class Arrays {
 
    // 冒泡排序
    public static void sort(Comparable[] arr){
        for(int j = 0;j<arr.length;j++){
            for (int i = 0;i<arr.length-1;i++){
                if(arr[i].compareTo(arr[i+1]) >0){  // 5 -  7
                    Comparable temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }
    }

public class _02 {
    public static void main(String[] args) {
        Person p1=new Person(30,180);
        Person p2=new Person(22,178);
        Person p3=new Person(27,166);
        Person p4=new Person(35,177);
        Person[] persons =new Person[]{p1,p2,p3,p4};
        Arrays2.sort(persons);
        System.out.println(Arrays.toString(persons));
    }
}

程序输出：

快速排序

public class Person implements Comparable<Person>{
    private Integer age;
    private Integer height;
 
    public Person(int age, int height) {
        this.age = age;
        this.height = height;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", height=" + height +
                '}';
    }
 
    //实现排序的核心方法
    @Override
    public int compareTo(Person o) {
        //制定age从小到大进行排序age - o.age
        //制定age从大到小进行排序o.age - age
        return age - o.age;
    }
}

public class Arrays {
//快速排序
    public static void sort(Comparable[] arr, int left, int right){
        if(left>=right){
            return;
        }
        Comparable base = arr[left];
        int i = left;
        int j = right;
        while (i!=j){
            while (arr[j].compareTo(base)>=0 && i<j){
                j--;
            }
            while (arr[i].compareTo(base)<=0 && i<j){
                i++;
            }
            Comparable temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
}

public class _02 {
    public static void main(String[] args) {
        Person p1=new Person(30,180);
        Person p2=new Person(22,178);
        Person p3=new Person(27,166);
        Person p4=new Person(35,177);
        Person[] persons =new Person[]{p1,p2,p3,p4};
        Arrays3.sort(persons,0,persons.length-1);
        System.out.println(Arrays.toString(persons));
    }
}

程序输出：