目录
接口
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