文章目录
提示：以下是本篇文章正文内容，Java系列学习将会持续更新
(1)基本概念
接口就是一种比抽象类还抽象的类，可以看作是特殊的抽象类，类体内只有全局常量和抽象方法(JDK8之前)。在JDK8中扩展了default方法。
①定义类的关键字是class ，继承类的关键字是extends
定义接口的关键字是interface，而实现接口的关键字是implements
②一般接口类的命名以I开头，实现接口的子类以Impl结尾，以便与普通类做区分。
③接口中只有全局常量和抽象方法。
当多个类型之间具有相同的行为能力的时候，java中就可以通过接口来进行类型之间的联系。通过接口可以解决java中单继承所带来的一些类型无法共享的问题。
接口不关心类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供的某些方法。
(2)语法格式
访问修饰符 interface 接口名称 {
常量的定义.........;
抽象方法的定义......;
}
public interface IMessage {
//接口的常量使用public static final修饰，但是可以省略
int NUM = 10;
//public abstract 修饰符可以省略
String message();
}
访问修饰符 class 子类名 implements 父接口1,父接口2,... {
父接口抽象方法的重写...;
}
public class MessageImpl implements Imessage {
//对父接口中的抽象方法进行覆写
@Override
public String message(){
return “Hello,Bit”;
}
}
(3)基本原则
1.接口中只有public权限；接口中只有全局常量和抽象方法；在接口内部abstract static final和public关键字都可以省略 (在阿里编码规约中，定义接口尽量简洁，以上关键字都不需要写)
2.子类必须覆写父接口中的所有抽象方法。
3.接口的多实现，子类可以同时实现多个父接口。
public class MessageImpl implements IMessage,INews{}
4.接口没有单继承限制，接口可以使用extends来继承多个父接口。
interface A { void textA(); }
interface B { void textB(); }
interface C extends A,B { void textC(); }
4.子类可以同时继承父类和实现接口。
public class DTest extends D implements A,B {}
(4)注意事项
1.接口不能创建对象。
2.接口可以实现多继承，也就是说一个接口可以同时继承多个父接口。
3.实现接口的类如果不能实现所有接口中待重写的方法，则必须设置为抽象类。
4.一个类可以继承自一个父类，同时实现多个接口。
(5)案例
IRun接口类
//动物行为的接口：跑
public interface IRun {
void run();
}
ISwim接口类
//动物行为的接口：游
public interface ISwim {
void swim();
}
IFly接口类
//动物行为的接口：飞
public interface IFly {
void fly();
}
Animal抽象类
//定义动物抽象类
public abstract class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
//抽象方法：吃
public abstract void eat(String food);
}
Dog类：实现继承和接口
//狗狗具备跑的行为
public class Dog extends Animal implements IRun{
public Dog(String name) {
super(name);
}
@Override
public void eat(String food) {
System.out.println("狗狗" + this.name + "吃了"+ food);
}
@Override
public void run() {
System.out.println("狗狗" + this.name + "正在撒欢的跑~~");
}
}
Frog类：实现继承和接口
//青蛙具备跳和游的行为
public class Frog extends Animal implements IRun,ISwim{
public Frog(String name) {
super(name);
}
@Override
public void eat(String food) {
System.out.println(this.name + "吃了" +food);
}
@Override
public void run() {
System.out.println(this.name + "正在河边跳");
}
@Override
public void swim() {
System.out.println(this.name + "正在蛙泳");
}
}
Goose类：实现继承和接口
//大鹅具备走、游、飞的行为
public class Goose extends Animal implements IRun,ISwim,IFly {
public Goose(String name) {
super(name);
}
@Override
public void eat(String food) {
System.out.println(this.name + "吃了" + food);
}
@Override
public void fly() {
System.out.println(this.name + "正在小飞一下~~");
}
@Override
public void run() {
System.out.println(this.name + "扇着翅膀跑~~");
}
@Override
public void swim() {
System.out.println(this.name + "在水里游泳");
}
}
Test类：main()方法测试
public class Test {
public static void main(String[] args) {
Dog dog = new Dog("小六");
dog.eat("狗粮");
dog.run();
System.out.println("---------------");
Frog frog = new Frog("小蛙");
frog.eat("昆虫");
frog.run();
frog.swim();
System.out.println("---------------");
Goose goose = new Goose("凶猛的大鹅");
goose.eat("小虾米");
goose.run();
goose.swim();
goose.fly();
}
}
运行结果：
回到目录…
(6)JDK内置的两大接口
①java.lang.Comparable
Student是自定义类，当使用Arrays.sort()对自定义类型进行排序时，自定义类型需要实现Comparable接口，使其具备比较的能力。
package java.lang;
public interface Comparable<T> {
@Contract(pure = true)
public int compareTo(@NotNull T o);
}
案例：
/**
* 实现java.lang.Comparable接口
*/
import java.util.Arrays;
public class Student implements Comparable<Student> {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
// 此时根据年龄大小比较
@Override
public int compareTo(Student o) {
if (this.age == o.age) {
return 0;
}else if (this.age < o.age) {
return -1;
}
return 1;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public static void main(String[] args) {
Student stu1 = new Student("小白",18);
Student stu2 = new Student("小黑",20);
Student stu3 = new Student("老姜",30);
Student[] students = {stu3,stu1,stu2};
// 数组排序算法,按照升序排序
Arrays.sort(students);
System.out.println(Arrays.toString(students));
}
}
②java.lang.Cloneable
复制一个新的对象，新对象的属性值从旧对象中拷贝过来的。
package java.lang;
public interface Cloneable {
}
这是标记接口，本身没有任何抽象方法，当一个类实现了Cloneable接口，就表示该类具备了克隆能力(JVM赋予的)。
实现接口后，内部需要覆写Object类中的clone()方法
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
案例：
/**
* 实现java.lang.Cloneable接口
*/
public class Animal implements Cloneable{
private String name;
//覆写Object类中的clone()方法
@Override
protected Animal clone() throws CloneNotSupportedException {
return (Animal) super.clone();
}
public static void main(String[] args) throws CloneNotSupportedException {
Animal animal1 = new Animal();
animal1.name = "熊猫";
Animal animal2 = animal1.clone();
//只是拷贝一个，并不是同一个对象
System.out.println(animal1 == animal2);
System.out.println(animal2.name);
}
}
(7)抽象类和接口的区别
| No | 区别 | 抽象类(abstract) | 接口(interface) |
|---|---|---|---|
| 1 | 结构组成 | 普通类+抽象方法 | 抽象方法+全局常量 |
| 2 | 权限 | 各种权限 | public |
| 3 | 子类使用 | 使用extends继承抽象类 | 使用implements继承接口 |
| 4 | 关系 | 一个抽象类可以实现若干个接口 | 接口不能继承抽象类，但是接口可以使用extends继承多个父接口 |
| 5 | 子类限制 | 一个子类只能继承一个抽象类 | 一个子类可以实现多个接口 |
总结:
提示：这里对文章进行总结：
以上就是今天的学习内容，本文是继续Java面向对象的学习，认识什么是接口类，学习语法格式和用法，了解JDK内置的两大接口，以及抽象类和接口的区别。之后的学习内容将持续更新！！！