Java面向对象之interface接口

本文主要是介绍Java面向对象之interface接口，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

文章目录

- (1)基本概念
- (2)语法格式
- (3)基本原则
- (4)注意事项
- (5)案例
- (6)JDK内置的两大接口
- (7)抽象类和接口的区别

提示：以下是本篇文章正文内容，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内置的两大接口，以及抽象类和接口的区别。之后的学习内容将持续更新！！！

这篇关于Java面向对象之interface接口的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程