JavaSE：抽象类和接口

目录

一、前言

二、抽象类

（一）抽象类概念

（二）使用抽象类的注意事项

（三）抽象类的作用

三、接口

（一）接口概念

（二）接口语法规则

（三）接口的使用 

（四）接口特性

（五）实现多个接口

（六）接口间的继承

 （七）使用接口给对象数组排序

 （八）Clonable 接口和深拷贝

 四、抽象类与接口的区别

五、总结

---

一、前言

大家好啊，蜡笔小欣前面和大家分享了Java中的类与对象、继承和多态等内容，相信大家也能感受到 Java的魅力所在，今天小欣将给大家分享Java中的抽象类和接口。在Java中，抽象类和接口是两个重要的概念，用于创建可重用和可扩展的代码。它们允许我们在不同类之间建立契约，同时保持实现代码的灵活性。

二、抽象类

（一）抽象类概念

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的， 如果 一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类 。

 说明：

1.矩形、三角形、圆形都是图形，因此和Shape类的惯性应该是继承关系，

2.虽然图形图Shape中也存在draw方法，但由于Shape类并不是具体的图形，因此其内部的draw方法实际是没有办法实现的，

3.由于Shape类没有办法描述一个具体的图形，导致其draw()方法无法具体实现，因此可以将Shape类设计为“抽象类”。

class Shape {public void draw() {System.out.println("Shape::draw()");}
}class Rect extends Shape {public void draw() {System.out.println("菱形");}
}class Triangle extends Shape {@Overridepublic void draw() {System.out.println("三角形");}
}class Cycle extends Shape {@Overridepublic void draw() {System.out.println("圆形");}
}public class Test {public static void main(String[] args) {Rect rect = new Rect();Triangle triangle = new Triangle();Cycle cycle = new Cycle();Shape[] shapes = {triangle, rect, cycle};for (Shape s : shapes) {s.draw();}}
}

在打印图形例子中，父类 Shape 中的 draw 方法好像并没有什么实际工作, 主要的绘制图形都是由 Shape 的各种子类的 draw 方法来完成的. 像这种没有实际工作的方法, 我们可以把它设计成一个 抽象方法, 包含抽象方法的类我们称为抽象类。

abstract class Shape{public abstract void draw();
}

在 draw 方法前面加上 abstract 关键字就变成了抽象方法，但是包含抽象方法的类，必须用 abstract 修饰。

（二）使用抽象类的注意事项

1. 抽象类不能直接实例化对象

public class Test {public static void main(String[] args) {Shape shape = new Shape();}
}

报错如下图所示：

2.抽象方法是不能用 private 修饰的

abstract class Shape{private abstract void draw();
}

报错如下图所示： 

3.抽象方法不能被final和static修饰，因为抽象方法要被子类重写

抽象类中可以包含其他的非抽象方法，也可以包含字段，这里的非抽象方法和普通方法的挥着都是一样的，可以被重写，也可以被子类直接调用，但是一个普通类要继承抽象类，那么必须重写抽象类当中的所有抽象方法。

abstract class Shape {abstract final void methodA();abstract public static void methodB();public void draw() {System.out.println("Shape::draw()");}
}

报错如下：

4.抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰。

5.抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类。

6.抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量。

（三）抽象类的作用

 抽象类存在的最大意义就是为了被继承，抽象类本身并不能被实例化，要想使用，只能创建该抽象类的子类，然后让子类重写抽象类中的抽象方法。在使用的时候，会多一重编译器的校验。因为直接使用父类的时候就会报错误。

三、接口

（一）接口概念

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用 。 在 Java 中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

（二）接口语法规则

接口的定义格式与定义类的格式基本相同，将 class 关键字换成 interface 关键字，就定义了一个接口。

public interface 接口名称{
// 抽象方法
//接口中的4中写法
public abstract void method1(); // public abstract 是固定搭配，可以不写
public void method2();
abstract void method3();
void method4();
}

Tips：

1. 创建接口时， 接口的命名一般以大写字母 I 开头，

2. 接口的命名一般使用 " 形容词 " 词性的单词，

3. 阿里编码规范中约定， 接口中的方法和属性不要加任何修饰符号， 保持代码的简洁性。

（三）接口的使用 

接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。

public class 类名称 implements 接口名称 {

 ...

}

注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。  

让我们看看下面这个代码：

interface IShape {void draw();
}class Cycle implements IShape {@Overridepublic void draw() {System.out.println("圆形");}
}public class Test {public static void main(String[] args) {IShape shape = new Cycle();shape.draw();}
}

运行结果如下：

（四）接口特性

1. 接口类型是一种引用类型，但是 不能直接new接口的对象

2.接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错)

3.接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

4.重写接口中方法时，不能使用默认的访问权限

5.接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量

 6.接口中不能有静态代码块构造方法

 

7.接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

9. jdk8 中：接口中还可以包含 default 方法

（五）实现多个接口

 有些时候我们需要让一个类同时继承多个父类，但是 Java 实现不了多继承。不过可以通过同时实现多个接口来达到多继承类似的效果。通过类来表示一组动物（通过接口来调用就不用关心引用是谁了）

class Animal {protected String name;public Animal(String name) {this.name = name;}}
interface IFlying {void fly();
}
interface IRunning{void run();
}
interface ISwimming{void swimming();
}
class Bird extends Animal implements IFlying{public Bird(String name) {super(name);}@Overridepublic void fly() {System.out.println(this.name+"正在飞");}
}
class Frog extends Animal implements IRunning,ISwimming{public Frog(String name) {super(name);}@Overridepublic void run() {System.out.println(this.name + "正在跑");}@Overridepublic void swimming() {System.out.println(this.name+"在游泳");}
}
class Duck extends Animal implements IRunning,ISwimming,IFlying{public Duck(String name) {super(name);}@Overridepublic void fly() {System.out.println(this.name+"正在飞");}@Overridepublic void run() {System.out.println((this.name+"正在跑"));}@Overridepublic void swimming() {System.out.println(this.name+"在游泳");}
}
class Roobot implements IRunning{@Overridepublic void run() {System.out.println("机器人在跑");}
}
public class Test {public static void runFunc(IRunning iRunning){iRunning.run();}public static void swimmingFunc(ISwimming iSwimming){iSwimming.swimming();}public static void flyingFunc(IFlying iFlying){iFlying.fly();}public static void main(String[] args) {runFunc(new Duck("鸭子"));runFunc(new Frog("青蛙"));runFunc(new Roobot());}
}

运行结果如下：

通过实现多个接口，可以利用接口来完成需要的功能，通过同时实现多个接口来完成功能。 

（六）接口间的继承

在 Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。 接口可以继承一个接口（也叫扩展） , 达到复用的效果 . 使用 extends 关键字。

interface IA {void funcA();
}
interface IB extends IA {void funcB();
}
//拓展接口的功能 需要对有A和B这俩的方法进行重写
class C implements IB {@Overridepublic void funcB() {}@Overridepublic void funcA() {}
}

 （七）使用接口给对象数组排序

我们通过一个例子来加深理解，通过接口对学生年龄进行排序，

学生类代码如下：

package demo4_8;public class Student implements Comparable<Student> {//Comparable接口有局限性，只能进行默认的比较public String name;public int age;public Student(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}//根据年龄比较大小@Overridepublic int compareTo(Student o) {//if(this.age>o.age) {//return 1;//}else if(this.age == o.age) {//return 0;//}else {//return -1;//}return this.age - o.age;}//根据姓名比较大小/* @Overridepublic int compareTo(Student o) {if (this.name.compareTo(o.name) > 0) {return 1;} else if (this.name.compareTo(o.name) == 0) {return 0;} else {return -1;}}*/
}

Test代码如下：

package demo4_8;import java.util.Arrays;public class Test {//Comparable接口的实使用public static void main(String[] args) {Student[] students = new Student[3];students[0] = new Student("zhangsan", 10);students[1] = new Student("lisi", 15);students[2] = new Student("wangwu", 11);System.out.println(Arrays.toString(students));Arrays.sort(students);System.out.println(Arrays.toString(students));}public static void main1(String[] args) {Student student1 = new Student("zhangsan", 18);Student student2 = new Student("lisi", 20);//比较student1和student2/*1.如果student1>student2 返回大于02.如果student1<student2 返回小于03否则返回0相等* */if (student1.compareTo(student2) > 0) {System.out.println("student1 > student2");} else {System.out.println("student1 <= student2");}}
}

运行结果如下：

 （八）Clonable 接口和深拷贝

Java 中内置了一些很有用的接口 , Clonable 就是其中之一。 Object 类中存在一个 clone 方法 ， 调用这个方法可以创建一个对象的 " 拷贝 "。 但是要想合法调用 clone 方法 ，首 先要实现 Clonable 接口 ， 否则就会抛出 CloneNotSupportedException 异常。

class Person implements Cloneable {public int age;public void eat() {System.out.println("正在吃东西！");}@Overridepublic String toString() {return "Person{" +"age=" + age +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}public class Test {public static void main(String[] args) throws CloneNotSupportedException {Person person = new Person();Person person1 = (Person) person.clone();System.out.println(person1);}
}

运行结果如下：

上面在使用 clone 方法的时候，通过抛出异常，重写异常达到接口的使用。

内存分布如下：

如果把 age 改为 99， 因为 person1 是克隆 person 的，所以person1 的 age 也变成 99 。

因此后面继续对 person1 进行修改，也会改变 age 的值 。

这里就是发生了浅拷贝。

 四、抽象类与接口的区别

它们的核心区别 : 抽象类中可以包含普通方法和普通字段 , 这样的普通 方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法 。

五、总结

抽象类和接口是 Java 中强大的工具，用于实现抽象和多态性。我们通过了解它们之间的区别和选择条件，为我们后期编写代码提供更多的便利性。以上就是本期的内容，希望小伙伴能收获满满，感谢大家的支持，我们下次再见！