java面向对象——抽象类、接口

小雨的分享社区

发布于 2022-10-26 14:26:58

3540

发布于 2022-10-26 14:26:58

文章被收录于专栏：小雨的CSDN

抽象类

抽象类的概念有人会觉得有些抽象，下面我将彻头彻尾的介绍抽象类的概念及其应用我们先来看下面这组代码

在刚才的例子中, 我们发现，父类 Shape 中的 draw 方法好像并没有什么实际工作，主要的输出都是由Shape 的各种子类的 draw 方法来完成的。像这种没有实际工作的方法，我们可以把它设计成一个抽象方法，包含抽象方法的类我们称之为抽象类。

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

1.在 draw 方法前加上 abstract 关键字, 表示这是一个抽象方法. 同时抽象方法没有方法体(没有 { }, 不能执行具体代码). 2.对于包含抽象方法的类, 必须加上 abstract 关键字表示这是一个抽象类。

注意事项：

1.用关键字abstract进行修饰
2.在抽象类中，可以有普通类的所有属性
3.和普通类不一样的地方是：包含了抽象方法
4.不能被实例化：不能new
5.主要作用就是被继承
6.不能用final修饰
7.不能是私有的，不能是static的
8.只要是有一个类，继承了这个抽象类，那么必须重写抽象类中的方法

下面来看一下代码的执行应用：

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

class Cycles extends Shapes{
    @Override
    public void draw(){
        System.out.println("这是一个圆");
    }
}
class Rects extends Shapes{
    @Override
    public void draw(){
        System.out.println("这是一个矩形");
    }
}

public class TextDemo3 {
    public static void main(String[] args) {
        Shapes[] shapes2 = {new Cycles(), new Rects()};
        for (Shapes shape : shapes2) {
            shape.draw();
        }
    }
}

输出结果：这是一个圆这是一个矩形

抽象类主要的作用是继承，需要注意的是，继承后必须在子类的里面进行重写！！

接口

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

下面是接口的具体实现方法

interface Shape{
    void draw();//有几个这种方法，下面重写多少个
}
class Cycle implements Shape{
    @Override
    public void draw(){
        System.out.println("这是一个圆");
    }
}
class Rect implements Shape {
    @Override
    public void draw(){
        System.out.println("这是一个矩形");
    }
}
public class TestDemo1 {
    public static void main(String[] args) {
        Shape shape1 = new Cycle();
        shape1.draw();
    }
}

注意事项

1.使用 interface 定义一个接口 2.接口中的方法一定是抽象方法, 因此可以省略 abstract 3.接口中的方法一定是 public, 因此可以省略 public 4.Cycle 使用 implements 继承接口. 此时表达的含义不再是 “扩展”, 而是 “实现” 5.在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例. 6 接口不能被实例化 7 在接口中不能定义已经实现的方法 8 实现了该接口，一定重写该接口中的方法 9 接口和接口之间可以通过extends进行联系

补充：

1.接口中的方法都是抽象方法 2.其实可以有具体实现的方法（再jdk1，8加入的）,方法前面加上default：（一般情况不用） default public void func(){} 3.接口中定义的成员变量默认为常量，需要初始化 4.接口中的成员变量，默认为public static final 接口中的成员方法默认为： public abstract 5.接口是不可以用来实例化 6.接口和类之间的关系为implements 7.解决java中的单继承问题，可以实现多个接口 8.只要这个类实现了该接口，那么你就可以进行向上转型

实现多个接口（可以实现多继承）

多个接口的实现可以配合继承来完成，该类连接了有几个接口，就要重写多少个方法

下面是完整代码

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

interface Flying{
    void fiy();
}
interface Jumping{
    void jup();
}
interface Swimming{
    void swim();
}

class Dog extends Animal implements Swimming{
    public Dog(String name){
        super(name);
    }
    @Override
    public void swim() {
        System.out.println(this.name +"会游泳");
    }
}
class Bird extends Animal implements Jumping,Flying{
    public Bird(String name){
        super(name);
    }
    @Override
    public void fiy() {
        System.out.println(this.name +"会飞");
    }
    @Override
    public void jup() {
        System.out.println(this.name + "会跳");

    }
}

public class MoreImp {
    public static void jum(Jumping jumping){
        jumping.jup();
    }
    public static void swim(Swimming swimming){
        swimming.swim();
    }
    public static void fly(Flying flying){
        flying.fiy();
    }
    public static void main(String[] args) {
        Dog dog = new Dog("露露");
        swim(dog);
        Bird bird = new Bird("huahua");
        fly(bird);
        jum(bird);
    }
}

接口使用示例（综合）

如果想比较一串数字的大小，并且从小到大输出，我们自然想到了以下函数

Arrays.sort();

但是如果想比较一个学生的分数、姓名等属性，应该怎么去写呢，下面是完整代码

自定义比较用Comparable或者Comparator接口

import java.util.Arrays;
//**自定义比较用Comparable接口**
class Student implements Comparable<Student>{
    public String name;
    public int age;
    public int score;

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

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

    @Override
    public int compareTo(Student o) {
        if(this.age<o.age){
            return -1;
        }
        if (this.age==o.age){
            return 0;
        }
        return 1;
    }
    //或者是以下几种
    // return this.age - o.age;//根据年龄从小到大（前面跟后面比）
    //return this.score - o.score;//根据分数从小到大
    //return this.name.compareTo(o.name);//字符串的比较大小
    }
public class TestDemocracy {
    public static void main(String[] args) {
        Student[] student = new Student[3];
        student[0] = new Student("bit",10,32);
        student[1] = new Student("bi",13,38);
        student[2] = new Student("b",14,34);

        Arrays.sort(student);//比较
        System.out.println(Arrays.toString(student));
    }
}

其中：其中Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法，这样就可以实现几个对象属性的比较大小

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2020-04-03，如有侵权请联系 cloudcommunity@tencent.com 删除

abstract