目录
接口
1.接口是什么
在Java中，接口（Interface）是一种引用类型，它是方法声明的集合，这些方法都是抽象的，即它们都没有实现（没有方法体）。接口是一种形式上的契约，它指定了一组方法，但不提供这些方法的具体实现。接口的主要用途是定义对象的交互方式，即对象可以做什么，而不是对象如何去做。
2.接口的特性
//抽象类是对行为的抽象，而接口是一种行为规范(行为的定义)
//接口当中只能使用抽象方法，接口当中都是默认为abstract和public修饰的
//接口类不能创建对象，只能使用多态
//一个类可以实现多个接口，(设计接口的目的之一就是要实现java类的多继承)
隐式的抽象：在Java中，当你声明一个类实现某个接口时，这个类必须实现接口中所有的方法，除非这个类本身被声明为抽象类。
如果不想Cat类实现run()方法，可以把Cat设置为抽象类，把run()传给子类
抽象类的设计的目的之一：更好的实现接口当中定义的方法
3.接口的声明
接口使用interface关键字声明，接口的名称通常使用大写字母开始的驼峰式命名法。
interface Animal {
void eat();
void sleep();
}4.接口的实现
类使用implements关键字来实现接口。实现接口的类必须提供接口中所有方法的具体实现（除非这个类被声明为抽象类）。
class Dog implements Animal {
@Override
public void eat() {
System.out.println("Dog is eating");
}
@Override
public void sleep() {
System.out.println("Dog is sleeping");
}
}5.典型的接口和抽象类的使用
init()：初始化Servlet对象
service()：处理客户端的请求
destroy()：销毁Servlet对象
getServletConfig()：返回Servlet的ServletConfig对象，该对象包含了Servlet的初始化参数和ServletContext对象，获取servlet的配置
getServletInfo()：返回Servlet的信息
GenericServlet实现了除了service方法以外的所有方法
自定义的servlet类只需要继承，就可以使用上边一系列的方法
6.接口示例
示例1
题目描述
设计一个动物管理系统，包括以下几个部分:
1.定义一个动物接口 (Animal) :包含所有 动物共有的方法，如eat()和sleep().
2.定义一个可飞行的接口(Flyable)。包含飞行的方法fly()，这个接口将由能够飞行的动物实现。
3.定义一个可游泳的接口(Swimmable) :包含游泳的方法swim() ，这个接口将由能够游泳的动物实现。
4.定义一个抽象类(AnimalBase)提供eat()和sleep()方法的具体实现，作为所有动物类的基类。
5.实现具体的动物类:如Bird (鸟，实现Flyable 接口并继承AnimalBase )，Fish (鱼，实现Swimmable接口并继承AnimalBase )，Dog (狗， 仅继承AnimalBase)
6.编写测试类:在测试类中创建这些动物的实例，并调用它们的方法，展示其行为。
Animals接口
package Animals;
public interface Animal {
void eat();
void sleep();
}Flyable接口
package Animals;
public interface Flyable {
void fly();
}Swimmable接口
package Animals;
public interface Swimmable {
void swim();
}AnimalBase抽象类，实现Animal接口，包含eat(),sleep()方法的具体实现
package Animals;
public abstract class AnimalBase implements Animal{
@Override
public void eat() {
System.out.println("所有的动物都会吃东西");
}
@Override
public void sleep() {
System.out.println("所有的动物都会睡觉");
}
}Bird类，继承AnimalBase抽象类，实现Flyable接口，包含fly()方法的具体实现
package Animals;
public class Bird extends AnimalBase implements Flyable{
@Override
public void fly() {
System.out.println("鸟会飞");
}
}Fish类，继承AnimalBase抽象类，实现Swimmable接口，包含swim()方法的具体实现
package Animals;
public class Fish extends AnimalBase implements Swimmable{
@Override
public void swim() {
System.out.println("鱼会游泳");
}
}Dog类，继承AnimalBase抽象类
package Animals;
public class Dog extends AnimalBase{
}Test类
package Animals;
public class Test {
public static void main(String[] args) {
Bird bird = new Bird();
Dog dog = new Dog();
Fish fish = new Fish();
bird.eat();
bird.sleep();
bird.fly();
System.out.println(" ");
dog.sleep();
dog.eat();
System.out.println(" ");
fish.eat();
fish.sleep();
fish.swim();
}
}输出结果为：
所有的动物都会吃东西
所有的动物都会睡觉
鸟会飞
所有的动物都会睡觉
所有的动物都会吃东西
所有的动物都会吃东西
所有的动物都会睡觉
鱼会游泳
示例2
有一个int类型的数组的时候我们可以使用JDK自带的Arrays.sort()方法进行排序
package 接口1;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] arr = new int[]{5,7,4,2,0,3,1,6};
Arrays.sort(arr); //排序，使用sort()方法
System.out.println(Arrays.toString(arr));
}
}输出结果为：
[0, 1, 2, 3, 4, 5, 6, 7]
当我们想对引用数据进行排序应该怎么办，还能直接使用Arrays.sort()方法吗
我们定义Person类
package 接口1;
public class 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 +
'}';
}
}想进行引用数据的排序，新建一个persons数组，把p1，p2，p3，p4全部加载进来，使用排序的方法并输出
package 接口1;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
Person p1 = new Person(22,180);
Person p2 = new Person(20,190);
Person p3 = new Person(18,170);
Person p4 = new Person(23,181);
Person[] persons =new Person[]{p1,p2,p3,p4};
Arrays.sort(persons);
System.out.println(Arrays.toString(persons));
}
}结果报错，无法转换Comparable接口（Comparable接口是用来排序的）
解决办法，如果你想要让对象进行排序，只需要去实现Comparable接口，然后实现它的comparaleTo()方法就可以了
修改后的Person类
在Person类中，实现Comparable接口，泛型，<>中间写什么无所谓，实现相关接口，就要实现接口里的方法compareTo()
package 接口1;
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从小到大进行排序age - o.age
//指定age从大到小进行排序o.age - age
return age - o.age;
}
}package 接口1;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
Person p1 = new Person(22,180);
Person p2 = new Person(20,190);
Person p3 = new Person(18,170);
Person p4 = new Person(23,181);
Person[] persons =new Person[]{p1,p2,p3,p4};
Arrays.sort(persons);
System.out.println(Arrays.toString(persons));
}
}再次输出：
[Person{age=18, height=170}, Person{age=20, height=190}, Person{age=22, height=180}, Person{age=23, height=181}]
此时根据age字段从小到大进行排序的
我们还可以自定义sort方法的排序代码
我这里使用冒泡排序
Arrays2类
package 接口1;
public class Arrays2 {
public static void sort(Comparable[] arr){//使用Comparable类型，因为此类为父类，子类可以进入并会向上转型
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){ //使用compareTo进行大小比较
Comparable temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
}
}
}Test类
package 接口1;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
Person p1 = new Person(22,180);
Person p2 = new Person(20,190);
Person p3 = new Person(18,170);
Person p4 = new Person(23,181);
Person[] persons =new Person[]{p1,p2,p3,p4};
Arrays2.sort(persons);
System.out.println(Arrays.toString(persons));
}
}Person类不需要改动
输出结果为：
[Person{age=18, height=170}, Person{age=20, height=190}, Person{age=22, height=180}, Person{age=23, height=181}]
总结
接口的存在是为了能够实现多继承
当你声明一个类实现某个接口时，这个类必须实现接口中所有的方法，除非这个类本身被声明为抽象类。
想要用引用类型进行排序，必须实现Comparable接口，实现compareTo方法，使用引用类型中的某一数值类型的数据进行比较排序
标签：Java,age,接口,height,---,Person,new,public From： https://blog.csdn.net/jlihan/article/details/141862157