Java教程

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 finalpublic关键字都可以省略 (在阿里编码规约中,定义接口尽量简洁,以上关键字都不需要写)

 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接口的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!