Java复习--接口、代理

心已赠人 2022-07-12 02:18 109阅读 0赞

参考《Java核心技术 I》 做的笔记

# 1.接口 #

## 1.1.接口简单介绍 ##

接口：简单地说就是类的需求描述，实现该接口的类都需要遵从接口描述的规则。

如，系统中的`Comparable<T>`接口

public interface Comparable<T> { 
        int compareTo(T another);
    }

需要注意的是：

1.接口中声明的方法默认都是public类型，所以可不用声明

2.接口中不能包含实例域和静态方法

3.实现该接口的子类必须实现接口声明的所有方法，具体实现逻辑由子类定义

例如，若要对学生类比较，可把学生类`Student`实现`Comparable<T>`接口(通过关键字`implement`)，在定义的时候实现`compareTo()`方法

//实现Comparable接口，泛型指定为Student
    class Student implements Comparable<Student> {
    
        private String name;
        private int age;
    
        Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        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;
        }
    
        @Override
        public int compareTo(Student another) {
            //第一个参数减去第二个参数
            return Double.compare(age, another.age);
        }
    }

main方法中：

public static void main(String[] args) {
    
        Student[] students = new Student[3];
    
        students[0] = new Student("jack", 18);
        students[1] = new Student("tom", 22);
        students[2] = new Student("lili", 6);
    
        //传入数组，元素对象必须实现Comparable
        Arrays.sort(students);
        for (Student s : students) {
            System.out.print(s.getName() + "\n");
        }
    }

结果:

lili
    jack
    tom

## 1.2.接口特性 ##

1.接口不能实例化，但可以声明

xxx = new Comparable();//是错误的
    Comparable xxx;// 可以声明接口

2.可以使用`instanceof`检查该类是否实现了某个接口

if(xxx instanceof Comparable){...}

3.接口也可以继承

public interface Walk { 
        void run(double distance);
    }
    
    public interface Run extends Walk { 
        //此句=public static final constant ...
        double RUN_MAX = 100;//接口不能包含实例域或静态方法，但可以包含常量
    
        void run(double distance);
    }

4.一个类可实现多个接口(所以不能用抽象类，因为只能继承一个抽象类)

class Student implements Walk , Run{...}

## 1.3.java8中可以在接口中定义静态方法 ##

public interface Walk {
        void run(double distance);
    
        //接口中定义静态方法
        public static double getDistance(int minute, int speed) {
            return speed * minute;
        }
    
    }

接口中添加静态方法的好处就是，在需要添加新功能的时候，不需要在实现该接口的所有子类中都再添加方法，直接修改接口即可(自己写的接口而已→\_→)

## 1.4.默认方法 ##

可以为接口方法提供一个默认实现，使用关键字`default`

public interface Walk {
        void run(double distance);
        //default关键字，类实现该接口方法的时候默认实现的方法逻辑
        default double getDistance(int minute, int speed) {
            return speed * minute;
    
              }
    
    }

默认方法最主要是为了向下兼容java版本，接口增添新功能的时候，较低的版本可能就无法正常运行，有了默认方法，低版本也可正常调用接口

## 1.5.Comparator接口 ##

首先如下代码中，是普通的字符串数组比较，`String`已经实现了`Comparable`接口，所以可以直接用`Arrays.sort()`方法，按照首字母的字典顺序排序。

代码:

public static void main(String[] args) {
    
        String[] strings = new String[4];
        strings[0] = "a";
        strings[1] = "cdfadfasfasdf";
        strings[2] = "bd";
        strings[3] = "nsegt";
    
        Arrays.sort(strings);
    
        for (String s : strings) {
            System.out.print(s + "\n");
        }
    
    }

结果:

a
    bd
    cdfadfasfasdf
    nsegt

若此时要按照字符串长度来排序，显然更改`String`内部实现`Comparable`接口的的方法是不可能的，所以可以外部自己定义个排序的逻辑类，实现`Comparator`（比较器）接口，只需实现其`compare()`方法即可，如下

代码:

//实现Comparator接口
    class LengthCompartor implements Comparator<String> {
        @Override
        public int compare(String lhs, String rhs) {
            return lhs.length() - rhs.length();
        }
    }

主函数调用：

LengthCompartor compartor = new LengthCompartor();
    Arrays.sort(strings, compartor);
    for (String s : strings) {
        System.out.print(s + "\n");
    }

结果:

a
    bd
    nsegt
    cdfadfasfasdf

# 2.代理 #