Java 详解 接口

一、概述

1.1、何为接口

    我们知道继承普通类和继承抽象类的存在，继承本质上就是实现对共性的抽取同时实现代码的复用，通过对现实事物抽象成为一个类，类内包含这一类事物的属性和行为，继承的存在就是将这一类事物的共同属性和行为抽取出来，当我们在定义属于这一类事物的类时可以直接继承使用，而抽象类的出现是因为父类提供的信息不足以描述一个具体的类，因此将父类定义为抽象类，间接加上了一层校验，防止在代码中不小心使用父类创建并使用父类对象。但是继承也有缺点，继承是对共性的抽取，不同的对象虽然同属一个类但各自都会有不同的个性。
    
    比如：动物类，狗属于动物，鸟属于动物，但是狗会跑，鸟不会，鸟会飞，但是狗不会，这就是两者的个性而非共性，因此其父类动物类就不可以含有行为跑和行为飞。可能有人会说：在定义狗类的时候可以定义自己特有的行为跑，在定义鸟类的时候可以定义鸟类自己特有的行为飞，这种方法确实可以，但是在定义一个鸭子类呢？鸭子可以飞可以跑，难道也要在定义鸭子类的时候再单独定义行为跑行为飞？不免有些繁琐了吧，当定义的类多了，每个类都有单独的自己的行为，但是不同的类之间又有共性，那继承的本质何在？
    
    因此在这个时候接口就被定义出来了，接口可以理解为是对外提供的一组公共的行为规范标准，只要是当前类实例化的对象符合行为规范标准，那么我们就可以让当前类实现这个接口，举个例子：我们可以定义一个接口，是行为跑的标准，狗这个对象会跑，因此狗这个类就可以实现该接口，再定义一个接口，是行为飞的标准，鸟这个对象会飞，鸭子这个对象也会飞，因此鸟和鸭子这两个类都可以实现该接口。

    当鸭子类实现了接口跑和接口游之后，鸭子类就包含有了行为跑和行为游，狗类实现了接口跑后，狗类就包含有了行为跑。因此接口技术用于描述类具有什么功能，但是接口中并不给出具体的实现，当某个类需要使用当前接口时再去实现接口中的方法，类需要遵从接口中描述的统一标准进行定义，所以接口就是统一的行为规范标准，接口在实现的时候，只需要符合行为规范标准就可以通用。在Java中，接口可以看作是多个类的公共规范，是一种引用类型。

1.2、接口的定义

    接口的定义和类的定义相似，类的定义需要所以class关键字，而接口的定义需要使用interface关键字，而接口的定义方式就是将类的定义关键字class换成interface关键字即可。

访问修饰符  class  类名访问修饰符  interface  接口名

    接口的创建和类的创建一样，都是通过右键单击src生成的

二、特点

2.1、接口的成员变量

    接口的成员属性默认是被 public
static final修饰的，主要就是意味着在接口中定义的成员属性默认是静态常量。

    1、当接口的变量被private
protected访问修饰符修饰时编译器直接爆红
    2、当变量没有任何修饰符修饰的时候，在实现类当中不可以对其进行修改
    3、当变量只被pulic修饰的时候，在实现类当中也不可以对其进行修改
    4、当变量被public static final
修饰时，三个关键字都是灰色的，说明变量是默认被这三个关键字修饰的，因此这三个关键字可以不用编写，编译器会自动加上的

2.2、接口的成员方法

    接口的成员方法默认是被public
abstract修饰的，也就是说不可以有具体的实现内容，这也就意味着接口中的成员方法默认是抽象 方法。

    如图：方法func（）有{
}，代表有具体的实现，但是不符合抽象方法的语法，编译器直接爆红；方法func1（）编写完参数列表后直接引号结尾，符合抽象方法的语法。

    我们可以发现被public
abstract修饰的方法和什么的不修饰的方法都是一样的，并且func（）方法的关键字public abstract
是灰色的，说明方法默认是被这两个关键字修饰的，即便程序员没有编写，编译器也会自动添加的。

    也就是说在接口当中不可以有普通方法的实现，一旦实现编译器直接爆红，但是一定要实现普通方法也不是不可以，只需要将普通方法修饰成为静态方法即可：

    或者是让当前方法被default修饰：

2.3、接口中不可以含有构造器和代码块

    因此在接口中定义的属性都只能够通过就地初始化进行初始化，无法通过构造器进行初始化

2.4、接口不可以实例化对象

    接口和抽象类一样，都是引用型数据类型，但都不可以通过关键字new进行实例化对象的，本质上两者提供的信息都不足以描述一个具体的对象，就没有必要实例化对象，如果误把抽象类或者接口进行实例化对象并使用了，那么编译器会直接爆红提示错误，因此接口也含有和抽象类一样的校验功能。

2.5、接口和类之间使用implements关键字进行连接

    类和类之间是继承关系，类和接口之间是实现关系。子类继承父类，类实现接口

public interface Itest {public abstract void func();public void func1();void func3();
}class teat implements Itest {}

    需要注意的是，接口和抽象类一样里面都包含有抽象方法，这也就意味着当类实现了接口后，需要重写接口里面全部的抽象方法。

public interface Itest {public abstract void func();public void func1();void func3();
}class teat implements Itest {@Overridepublic void func() {}@Overridepublic void func1() {}@Overridepublic void func3() {}
}

2.6、当类在重写接口中的方法时，不可以使用默认的访问权限

    重写的规则为： 1、方法名，返回类型，参数列表要一致 2、重写必须要在继承机制下 3、重写方法的访问权限必须要大于等于被重写方法的访问权限
    

在接口中的方法默认是被public abstract修饰的，那么类当中重写方法的访问权限就必须要大于等于public。

2.7、接口虽然不是类，但是接口通过编译了之后也会生成class文件

2.8、如果类没有实现接口当中的全部抽象方法，那么该类必须要设置为抽象类

    如果类当中没有实现接口中的全部抽象方法时，编译器会爆红，直到全部实现之后才不会爆红，因此和抽象类一样，继承抽象类和实现接口的类只有两种选择：要么老老实实全部实现，要么就将当前类设置为抽象类。不过该来的还是回来，抽象类存在的意义就是为了被继承，也就是说即便设、置为抽象类了，该抽象类后面也是会被继承的，那么还是逃不过实现抽象方法的结果

public interface Itest {public abstract void func();public void func1();void func3();
}abstract class teat implements Itest {}class test extends teat {@Overridepublic void func() {}@Overridepublic void func1() {}@Overridepublic void func3() {}
}

2.9、类支持实现多个接口

    在Java中类不支持多继承，类与类之间是单继承，一个类只能有一个父类，但是在Java中，一个类可以实现多个接口。

public class Duck extends Animal implements Iswim , IRun{public Duck(String name) {super(name);}@Overridepublic void run() {System.out.println(name + "在跑");}@Overridepublic void wim() {System.out.println(name + "在游");}
}

    如代码，Duck类继承了Animal类并实现了接口Iswin和接口IRun两个接口

2.10、接口之间支持多继承

    类与类之间支持继承，类与接口之间支持实现，接口与接口之间也支持继承，并且支持多继承，也就是使用接口可以达到多继承的效果。
    接口可以继承接口，从而达到复用的效果，使用extends关键字。

    通过接口继承创建一个新的接口IAmphibious表示“两栖的”，此时如果实现该借口，那么当前类就必须要重写IRun接口和Iswin接口的全部抽象方法。如此一来间接的实现了多继承的效果，也达到了IRun接口和Iswin接口中的方法代码复用，减少了程序员编写重复代码的时间。

三、应用

3.1、实现多个接口

//MAin类
public class Main {public static void funcrun(Irun irun) {irun.run();}public static  void funcfly(Ifly ifly) {ifly.fly();}    public static void funcsein(Iswin iswin) {iswin.swin();}public static void funcer(Isecdwe isecdwe) {isecdwe.run();isecdwe.swin();}public static void functih(ITiHabitat iTiHabitat) {iTiHabitat.fly();iTiHabitat.run();iTiHabitat.swin();}public static void main(String[] args) {Dog dog = new Dog("狗",5);bird birdi = new bird("鸟",5);Duck duck = new Duck("鸭子",5);}
}

//动物类
public abstract class Animal {protected String name;protected int age ;public abstract void eat();public Animal(String name, int age) {this.name = name;this.age = age;}
}

//狗类
public class Dog extends Animal implements Isecdwe{public Dog(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println(name + "在吃狗粮....");}@Overridepublic void run() {System.out.println(name + "在跑....");}@Overridepublic void swin() {System.out.println(name + "在游....");}
}

//鸟类
public class bird extends Animal implements Ifly{@Overridepublic void fly() {System.out.println(name + "在飞.....");}public bird(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println(name + "在吃鸟粮....");}
}

//鸭子类
public class Duck extends Animal implements ITiHabitat {public Duck(String name, int age) {super(name, age);}public void eat() {System.out.println(name + "在吃鸭粮....");}@Overridepublic void run() {System.out.println(name + "在跑.....");}@Overridepublic void swin() {System.out.println(name + "在游....");}@Overridepublic void fly() {System.out.println(name + "在飞....");}
}

//接口跑
public interface Irun {void run();
}//接口游
public interface Iswin {void swin();
}//接口飞
public interface Ifly {void fly();
}//接口两栖
public interface Isecdwe extends Iswin,Irun{
}//接口三栖
public interface ITiHabitat extends Irun,Iswin,Ifly{
}

    在func方法内部，方法不关心传递过来的对象是什么对象，方法内部只关心该对象是否有实现当前接口，然后当前对象实现了接口，那么成功编译，如果没有实现当前接口，那么编译报错。

    

父类：对子类共性的抽取
接口：对象的行为标准规范，也可以说是某种功能特性
    
    不是所有的动物都会飞会游，这些行为不是动物的共性，因此无法将这些行为定义到父类当中，最优解就是将这些非共有行为设置为接口，只要是符合接口定义的行为规范准则的动物都可以实现接口，此时就解决了非共性问题。可以简单理解为：父类是共有特性，接口是独有特性

    Java面向对象编程中最常见的用法：一个类继承一个父类，同时实现多个接口。这样设计有什么好处呢？可以让程序员忘记类型，有了接口之后，类的使用者就不需要再关心具体类型，只需要关心当前类是否有实现某个接口，具备某种能力。
    
    在func方法中，参数列表设置为接口类型，则该方法就不需要关注传递过来的对象是否是动物，只要该对象的类型实现了该接口，就可以使用该方法，也就是说重新定义一个机器人类，只要机器人类实现了该接口，则机器人类就可以调用该方法。

3.2、给对象排序

    当我们实例化了大量的学生对象，此时需要对学生对象进行排序，我们可以定义一个学生类型的数组，并将顺序存储进入数组中。我们知道Java有定义一个冒泡排序的方法sort（），我们能否直接通过该方法进行对学生对象的排序呢？

    编译直接报错

    将数组内容强制转化为Comparable类型。
    
    在调用sort（）方法时，该方法底层会调用compareTo（）方法进行比较，而compareTo（）方法是在Comparable接口底下的方法，我们当前都没有实现Comparabe<>接口，怎么能够强制转化为Comparable类型？因此我们需要在学生类当中实现Comparable。

public class Student implements Comparable<Student>{protected String name;protected int score;@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", score=" + score +'}';}public Student(String name, int score) {this.name = name;this.score = score;}@Overridepublic int compareTo(Student o) {return 0;}
}

    此时我们实现了Comparable，后面的代表泛型，证明比较的是Student这个类，此时还需要重写compareTo（）方法，赋予比较规则。此时我们可以设定比较的规则，是按照姓名来比较还是按照成绩高低来比较，比如我们设定姓名来比较。

    @Overridepublic int compareTo(Student o) {return this.name.compareTo(o.name);}

    此时我们设定好了按照姓名比较的规则，在String类当中有重写的compareTo（）方法，我们直接调用该方法进行比较即可，此时是按照正序进行排序的

    排序成功，我们在更换另外一个比较方式，按照成绩的高低来进行排序，也就是更换compareTo()方法实现内容。

    @Overridepublic int compareTo(Student o) {return this.score - o.score;}

    更换完成，当方法返回的是正数时，代表调用该方法者比较大；当方法返回负数时，代表方法调用者比较小；当方法返回值为0时，代表方法调用者和方法传递值一样大。

    我们可以自己尝试编写sort（）方法，用自己的方法实现排序过程，小小冒泡。

    public static void bubble(Student[] student){for (int i = 0; i < student.length; i++) {for (int j = 0; j < student.length - 1 - i; j++) {if(student[j].compareTo(student[j + 1]) > 0) {Student tmp = student[j];student[j] = student[j + 1];student[j + 1] = tmp;}}}}

    实现完成。

    

color=“red”
size=“3”>在sort（）方法底层会调用compareTo（）方法，compareTo（）的参数是Student，因为我们在实现Comparable接口的时候指定了比较的是Student类的对象，因此通过快捷键生成的重写方法的参数默认是Student类型的。
    对于sort（）方法来说，需要传入的数组每一个对象都是“可比较的”，需要具备cmpareTo（）这样的能力，通过重写compareTo（）这样的方式，就可以定义比较规则。

    但是我们仔细观察，好像不是很方便，因为现在是按照成绩高低进行排序，如果明天我想要按照姓名来排序呢？直接更改代码吗？不合适当我们的代码投入使用了之后，会产生数据，如果对当前已经投入使用的代码进行更改，有可能会导致连锁反应的出现，导致出现其他的错误。那么这个时候我们可以使用sort()方法的重载方法更换底层，将sort（）方法的比较方法更换为Comparetor接口底下的compare（）方法

    我们需要创建一个类来重写compare（），该方法内部的比较规则是按照成绩高低进行排序

public class namesort implements Comparator<Student> {@Overridepublic int compare(Student o1, Student o2) {return o1.score - o2.score;}
}

    再创建另外一个类来重写另外一个规则：按照姓名来排序

public class scoresort implements Comparator<Student> {@Overridepublic int compare(Student o1, Student o2) {return o1.name.compareTo(o2.name);}
}

    此时我们就可以随意按照不同的规则进行比较了，不会再因为单独的规则而影响代码的使。
    
    可能有人会说如果Comparable接口也通过定义两个不同的类实现然后进行重写compareTo()方法，也可以做到不同的规则进行比较，可以吗？首先我们需要注意的是在使用默认底层的情况下是需要将数组内容强制转换为Comparable类型的，也就是说Student类必须实现Comparable接口才可以，再执行下去就是调用compareTo（）方法进行比较，如果将Comparable接口定义在外面的类并重写方法，没什么用啊，外面的类和Student类怎么能够串联在一起？sort（）方法只会调用Student类里面的方法，而不会调用外面的类的方法；
    
    更换底层的重载方法也不可以，重载方法的参数列表规定参数是Comparator类型，传递实现了Comparable的类是行不通的，编译直接报错。

四、总结

    接口可以理解为是配合继承使用的，继承没办法做的事情接口来做，在一定程度上接口也做到了代码的服用以及小部分的共性抽取。更好的说法就是两者相互配合使用，继承一个类实现多个接口，达到强化多态的使用，将多态的使用范围扩大，不局限于父类，不需要每个类都继承父类，只需要实现了接口就可以达到多态的使用，还可以使程序员忘记类型的存在，有了接口之后，类的使用者就不必再关注类型，只需要关注类是否实现接口即可。

    

    接口是一组对外公开的行为规范准则，在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过实现接口的方式，从而实现接口的抽象方法。