首页 > 资讯 > 后端开发 > Python >Java入门基础之抽象类与接口

407

分享到

Java入门基础之抽象类与接口

2024-04-02 19:04:59 407人浏览薄情痞子

Python 官方文档：入门教程 => 点击学习

摘要

目录一.抽象类1.什么是抽象类2.语法规则3.抽象类的作用二.接口1.什么是接口2.语法规则3.实现多个接口4.接口之间的继承三.接口的使用实例1. Comparable 接口2.C

一.抽象类

1.什么是抽象类

首先我们来回顾一下上一篇文章提到的一个例子：打印图形

class Shape { 
 	public void draw() { 
 		// 啥都不用干
 	} 
} 
class Cycle extends Shape { 
 	@Override 
 	public void draw() { 
 		System.out.println("○"); 
 	} 
} 
class Rect extends Shape { 
 	@Override 
 	public void draw() { 
 		System.out.println("□"); 
 	} 
} 
class Flower extends Shape { 
 	@Override 
 	public void draw() { 
 		System.out.println("♣"); 
 	} 
} 
/我是分割线// 

public class Test { 
 	public static void main(String[] args) { 
 		Shape shape1 = new Flower(); 
 		Shape shape2 = new Cycle(); 
 		Shape shape3 = new Rect(); 
 		drawMap(shape1); 
 		drawMap(shape2); 
 		drawMap(shape3); 
 	} 
 	// 打印单个图形
 	public static void drawShape(Shape shape) { 
 		shape.draw(); 
 	} 
}

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

2.语法规则

那么，抽象类到底怎么写呢？请看代码：

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

在 draw 方法前加上 abstract 关键字，表示这是一个抽象方法。同时抽象方法没有方法体(没有 { },不能执行具体代码)

对于包含抽象方法的类, 必须加上 abstract 关键字表示这是一个抽象类

注意事项：

抽象类不能直接实例化：

Shape shape = new Shape(); 
// 编译出错
Error:(30, 23) java: Shape是抽象的; 无法实例化

抽象方法不能是 private 的：

abstract class Shape { 
 	abstract private void draw(); 
} 
// 编译出错
Error:(4, 27) java: 非法的修饰符组合: abstract和private

抽象类中可以包含其他的非抽象方法，也可以包含字段。这个非抽象方法和普通方法的规则都是一样的，可以被重写，也可以被子类直接调用：

abstract class Shape { 
 	abstract public void draw(); 
 	void func() { 
 		System.out.println("func"); 
 	} 
} 
class Rect extends Shape { 
 
} 
public class Test { 
 	public static void main(String[] args) { 
 		Shape shape = new Rect(); 
 		shape.func(); 
 	} 
} 
// 执行结果
func

3.抽象类的作用

抽象类存在的最大意义就是为了被继承

抽象类本身不能被实例化，要想使用，只能创建该抽象类的子类，然后让子类重写抽象类中的抽象方法。

那大家可能有一个疑问，普通的类也可以被继承，普通的方法也可以被重写呀，为啥非得用抽象类和抽象方法呢?

确实如此，但是使用抽象类相当于多了一重编译器的校验：

使用抽象类的场景就如上面的代码，实际工作不应该由父类完成，而应由子类完成。

那么此时如果不小心误用成父类了，使用普通类编译器是不会报错的。但是父类是抽象类就会在实例化的时候提示错误，让我们尽早发现问题。

很多语法存在的意义都是为了 “预防出错”，例如我们曾经用过的 final 也是类似。创建的变量用户不去修改，不就相当于常量嘛? 但是加上 final 能够在不小心误修改的时候，让编译器及时提醒我们。
充分利用编译器的校验, 在实际开发中是非常有意义的。

二.接口

1.什么是接口

接口是抽象类的更进一步。抽象类中还可以包含非抽象方法和字段。而接口中包含的方法都是抽象方法, 字段只能包含静态常量

2.语法规则

在刚才的打印图形的示例中，我们的父类 Shape 并没有包含别的非抽象方法，也可以设计成一个接口：

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

使用 interface 定义一个接口
接口中的方法一定是抽象方法，因此可以省略 abstract
接口中的方法一定是 public ，因此可以省略 public
Cycle 使用 implements 继承接口。此时表达的含义不再是 “扩展”，而是 “实现”
在调用的时候同样可以创建一个接口的引用，对应到一个子类的实例
接口不能单独被实例化
从jdk1.8开始，接口中的普通方法可以有具体实现，但这个方法必须是default修饰的。

扩展(extends) vs 实现(implements)：

扩展指的是当前已经有一定的功能了，进一步扩充功能
实现指的是当前啥都没有，需要从头构造出来

注意事项：

接口中只能包含抽象方法。对于字段来说，接口中只能包含静态常量(final static)：

interface IShape { 
 	void draw(); 
 	public static final int num = 10; 
}

其中的 public, static, final 的关键字都可以省略.省略后的 num 仍然表示 public 的静态常量

总结：

我们创建接口的时候，接口的命名一般以大写字母 I 开头
接口的命名一般使用 “形容词” 词性的单词
阿里编码规范中约定，接口中的方法和属性不要加任何修饰符号，保持代码的简洁性

一段易错的代码：

interface IShape { 
 	abstract void draw() ; // 即便不写public，也是public 
} 
class Rect implements IShape { 
 	void draw() { 
 		System.out.println("□") ; //权限更加严格了，所以无法重写
 	} 
}

3.实现多个接口

有的时候我们需要让一个类同时继承多个父类。这件事情在有些编程语言通过多继承的方式来实现的。

然而 Java 中只支持单继承，一个类只能 extends 一个父类。但是可以同时实现多个接口，也能达到多继承类似的效果。

现在我们通过类来表示一组动物:

class Animal { 
 	protected String name; 
 
 	public Animal(String name) { 
 		this.name = name; 
 	} 
}

另外我们再提供一组接口，分别表示 “会飞的” “会跑的” “会游泳的” :

interface IFlying { 
 	void fly(); 
} 
interface IRunning { 
 	void run(); 
} 
interface ISwimming { 
 	void swim(); 
}

接下来我们创建几个具体的动物

猫，是会跑的 :

class Cat extends Animal implements IRunning { 
 	public Cat(String name) { 
 		super(name); 
 	} 
 	@Override 
 	public void run() { 
 		System.out.println(this.name + "正在用四条腿跑"); 
 	} 
}

鱼，是会游的 :

class Fish extends Animal implements ISwimming { 
 	public Fish(String name) { 
 		super(name); 
 	} 
 	@Override 
 	public void swim() { 
 		System.out.println(this.name + "正在用尾巴游泳"); 
 	} 
}

青蛙，既能跑，又能游 :

class Frog extends Animal implements IRunning, ISwimming { 
 	public Frog(String name) { 
 		super(name); 
 	} 
 	@Override 
 	public void run() { 
 		System.out.println(this.name + "正在往前跳"); 
 	} 
 	@Override 
 	public void swim() { 
 		System.out.println(this.name + "正在蹬腿游泳"); 
 	} 
}

PS : idea 中使用 ctrl + i 快速实现接口

还有一种神奇的动物，水陆空三栖，叫做 “鸭子” :

class Duck extends Animal implements IRunning, ISwimming, IFlying { 
 	public Duck(String name) { 
 		super(name); 
 	} 
 	@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 + "正在漂在水上"); 
 	} 
}

上面的代码展示了 Java 面向对象编程中最常见的用法 : 一个类继承一个父类，同时实现多种接口

继承表达的含义是 is - a 语义，而接口表达的含义是具有 xxx 特性

猫是一种动物，具有会跑的特性
青蛙也是一种动物，既能跑，也能游泳
鸭子也是一种动物，既能跑，也能游，还能飞

这样设计有什么好处呢?

时刻牢记多态的好处，让我们忘记类型.有了接口之后，类的使用者就不必关注具体类型，而只关注某个类是否具备某种能力

例如, 现在实现一个方法, 叫 “散步”:

public static void walk(IRunning running) { 
 	System.out.println("我带着伙伴去散步"); 
 	running.run(); 
}

在这个 walk 方法内部，我们并不关注到底是哪种动物，只要参数是会跑的，就行:

Cat cat = new Cat("小猫"); 
walk(cat); 
Frog frog = new Frog("小青蛙"); 
walk(frog); 
// 执行结果
我带着伙伴去散步
小猫正在用四条腿跑
我带着伙伴去散步
小青蛙正在往前跳

甚至参数可以不是 “动物”，只要会跑!

class Robot implements IRunning { 
 	private String name; 
 	public Robot(String name) { 
 		this.name = name; 
 	} 
 	@Override 
 	public void run() { 
 		System.out.println(this.name + "正在用轮子跑"); 
 	} 
} 
Robot robot = new Robot("机器人"); 
walk(robot); 
// 执行结果
机器人正在用轮子跑

4.接口之间的继承

接口可以继承一个接口，达到复用的效果.使用 extends 关键字:

interface IRunning { 
 	void run(); 
} 
interface ISwimming { 
 	void swim(); 
} 
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming { 

} 
class Frog implements IAmphibious { 
 
}

通过接口继承创建一个新的接口 IAmphibious 表示 “两栖的”

此时实现接口创建的 Frog 类，就继续要实现 run 方法，也需要实现 swim 方法，接口间的继承相当于把多个接口合并在一起

三.接口的使用实例

1. Comparable 接口

刚才的例子比较抽象, 我们再来一个更能实际的例子,给对象数组排序 :

给定一个学生类

class Student { 
 	private String name; 
 	private int score; 
 	public Student(String name, int score) { 
 		this.name = name; 
 		this.score = score; 
 	} 

 	@Override 
 	public String toString() { 
 		return "[" + this.name + ":" + this.score + "]"; 
 	} 
}

再给定一个学生对象数组, 对这个对象数组中的元素进行排序(按分数降序):

Student[] students = new Student[] { 
 new Student("张三", 95), 
 new Student("李四", 96), 
 new Student("王五", 97), 
 new Student("赵六", 92), 
};

按照我们之前的理解, 数组我们有一个现成的 sort 方法,我们来试试能否直接用sort方法进行排序:

仔细思考, 不难发现学生和普通的整数不一样, 两个整数是可以直接比较的, 大小关系明确. 而两个学生对象的大小关系怎么确定? 需要我们额外指定

让我们的 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法:

class Student implements Comparable { 
 	private String name; 
 	private int score; 
 	public Student(String name, int score) { 
 		this.name = name; 
 		this.score = score; 
 	} 
 	@Override 
 	public String toString() { 
 		return "[" + this.name + ":" + this.score + "]"; 
 	} 
 	@Override 
 	public int compareTo(Object o) { 
 		Student s = (Student)o; 
 		if (this.score > s.score) { 
 			return -1; 
 		} else if (this.score < s.score) { 
 			return 1; 
 		} else { 
 			return 0; 
 		} 
 	} 
}

在 sort 方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象

然后比较当前对象和参数对象的大小关系(按分数来算):

如果当前对象应排在参数对象之前, 返回小于 0 的数字
如果当前对象应排在参数对象之后, 返回大于 0 的数字
如果当前对象和参数对象不分先后, 返回 0

我们再次执行一下:

这时候结果就符合我们预期了(￣▽￣)*

compareTo其实就是一个比较规则 , 如果我们想自定义比较类型的话 , 一定要实现可以比较的接口 . 但是 , Comparable接口有个很大的缺点 , 那就是对类的侵入性很强 , 所以我们一般不轻易改动

2.Comparator接口

刚才我们提到了Comparable接口对类的侵入性很强 , 那么有没有一个比较灵活的接口供我们使用呢? 答案是肯定的 , 那就是Comparator接口

我们先来写一个用年龄进行比较的比较器:

class AgeComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1,Student o2) {
        return o1.age - o2.age;
    }
}

再来写一个用姓名进行比较的比较器:

class NameComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}

这时候,我们实例化这两个比较器,并且在sort方法中传入要排列的数组和我们写的比较器对象 :

class Student implements Comparable<Student>{
    public int age;
    public String name;

    public Student(int age, String name, double score) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
public class Test {

    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student(12,"af");
        students[1] = new Student(6,"be");
        students[2] = new Student(18,"zhangsan");

        System.out.println("按年龄排序：");
        AgeComparator ageComparator = new AgeComparator();
        Arrays.sort(students,ageComparator);
        System.out.println(Arrays.toString(students));
        System.out.println("---------------------------");
        System.out.println("按姓名排序：");
        NameComparator nameComparator = new NameComparator();
        Arrays.sort(students,nameComparator);
        System.out.println(Arrays.toString(students));
    }
}

运行结果:

所以 Comparator接口只需要根据自己的需求重新写比较器就 ok 了, 灵活很多, 而不是像Comparable接口直接就写死了

3.Clonable接口

Java 中内置了一些很有用的接口 , Clonable 就是其中之一

Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 “拷贝”. 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常

实现Clonable接口
别忘了要抛出异常
重写Object的clone方法

我们来看一个例子 :

class Person implements Cloneable{
    public int age;

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class TestDemo {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person person = new Person();
        person.age = 99;
        Person person2 = (Person) person.clone();
        System.out.println(person2);
    }
}

运行结果:

此时内存如下:

这时候,我们再来加一个Money类,并且在Person类中实例化它:

class Money implements Cloneable{
    public double m = 12.5;
    }
}
class Person implements Cloneable{
    public int age;
    public Money money = new Money();

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

我们在person2中拷贝一份money的值,这时候修改person2中的money,那么person1的money是否改变呢?

public class TestDemo {
    
    public static void main(String[] args) throws CloneNotSupportedException{
        Person person = new Person();
        Person person2 = (Person) person.clone();
        System.out.println(person.money.m);
        System.out.println(person2.money.m);
        System.out.println("-------------------------");
        person2.money.m = 13.5;
        System.out.println(person.money.m);
        System.out.println(person2.money.m);
    }
}

答案是不会改变!

那么是否说明Clonable接口就是只能实现浅拷贝呢?

答案也是否 , 决定深浅拷贝的并不是方法的用途 , 而是代码的实现 !

我们来看看此时的内存分布图:

要想实现深拷贝,我们拷贝person的时候就要把person对象里的money也拷贝一份,让person2的money指向新拷贝出来的money ,这时候咱们就实现了深拷贝

具体的操作实现只需要将Money类重写clone方法(方便克隆),然后将Person中的clone方法进行修改 ,将money也进行拷贝即可

具体代码如下 :

class Money implements Cloneable{
    public double m = 12.5;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person implements Cloneable{
    public int age;
    public Money money = new Money();

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person tmp = (Person) super.clone();
        tmp.money = (Money) this.money.clone();
        return tmp;
//        return super.clone();
    }
}

我们来测试一下 :

public class TestDemo {

    public static void main(String[] args) throws CloneNotSupportedException{
        Person person = new Person();
        Person person2 = (Person) person.clone();
        System.out.println(person.money.m);
        System.out.println(person2.money.m);
        System.out.println("-------------------------");
        person2.money.m = 13.5;
        System.out.println(person.money.m);
        System.out.println(person2.money.m);
    }