抽象类和接口

已于 2024-06-28 15:37:40 修改
阅读量761 收藏 24
点赞数 24
文章标签： java 开发语言
于 2024-06-28 15:35:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80634989/article/details/139276589
版权

正文：

抽象类：

1. 抽象类的语法形式：

只需在class前加上一个abstract关键字。

public abstract class 类名 {


}

2. 为什么会有抽象类的出现?

在我们写在一个类中写一个没有具体实现的方法，在正常类中是无法实现的，但是在抽象类中就可以实现，这大大提高了开发的效率。

3. 这种没有具体实现的方法叫作抽象方法，也需要abstract关键字来修饰，抽象方法只能出现在抽象类中，在普通类中会报错，这也是普通类和抽象类的区别所在。

4. 抽象类不能进行实例化，所以也就不能用final来修饰。

原因：被final修饰的类不能被继承，但是抽象类不能进行实体化，两者之间存在矛盾。

5. 如果一个普通类继承了这个抽象类，那么这个普通类就必须重写这个抽象类当中的所有抽象方法。如果一号抽象类继承了二号抽象类，那继承一号的普通类也要重写二号抽象类的抽象方法。

接口：

语法：

public interface 接口名 {

}

1. 接口当中的成员变量，默认是public static final修饰的，不能是别的修饰，在定义的时候任何一个关键字都可以省略。

2. 接口中的抽象方法默认都是public abstract修饰的，定义方式可与接口中的成员变量类比。

3. 接口中的方法只能是抽象方法，不能有具体实现，如果需要定义一个有具体实现的方法，需要用default或者static修饰，那么可以有具体实现。

4. 接口是不能进行实例化的。

5. 类和接口之间可以使用关键字implements来实现接口，并且类中必须实现接口中的抽象方法。

 

6. 一个接口对应一个字节码文件。

7. 如果一个类不想实现接口中的方法，那么此时这个类可以定义为抽象类，但这个抽象类如果被继承，他的子类就必须实现所有没有被实现的方法。

8. 接口的出现解决了Java不能多继承的问题。

Bird类：

public class Bird extends Animal implements IMove, ILive{
    @Override
    public void move() {
        System.out.println(this.name + "正在飞...");
    }

    @Override
    public void eat() {
        System.out.println(this.name + "正在吃虫子...");
    }

    @Override
    public void live() {
        System.out.println(this.name + "住在鸟窝里...");
    }
}

Dog类：

public class Dog extends Animal implements IMove,ILive{
    @Override
    public void move() {
        System.out.println(this.name + "正在跑...");
    }

    @Override
    public void eat() {
        System.out.println(this.name + "正在狗粮...");
    }

    @Override
    public void live() {
        System.out.println(this.name + "住在狗窝里...");
    }
}

IMove接口：

public interface IMove {
    void move();
}

ILive接口：

public interface ILive {
    void live();
}

9. 接口与接口之间也存在继承关系，也是用extends关键字。

ILive接口：

public interface ILive extends IMove{
    void live();
}

IMove接口：

public interface IMove {
    void move();
}

接下来介绍一些比较常用的接口：

comparable接口：

Student类：

public class Student{
    private String name = "xxx";
    private int age;

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

    public Student() {

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

}

Students类：

import java.util.Arrays;


public class Students {
    Student[] students;

    public Students(Student[] students) {
        this.students = students;
    }

    public Student[] getStudents() {
        return students;
    }

    public void setStudents(Student[] students) {
        this.students = students;
    }

    @Override
    public String toString() {
        return "Students{" +
                "students=" + Arrays.toString(students) +
                '}';
    }
}

如果我们想要对Student[]数组中的元素进行排序，刚开始可能会这样写：

Test类：

import java.util.Arrays;


public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("小明", 15);
        Student student2 = new Student("大宏", 12);
        Student[] students = new Student[2];
        students[0] = student1;
        students[1] = student2;
        Students students1 = new Students(students);
        System.out.println("排序前：" + students1);

        Arrays.sort(students1.students);
        System.out.println("排序后：" + students1);
    }
}

运行起来就会报错：

解决问题：

让Student类实现Comparable接口：

public class Student implements Comparable<Student>{
    private String name = "xxx";
    private int age;

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

    public Student() {

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

}

 编译器有报错：

按住Ctrl鼠标左键点进去观察Comparable的源代码：

观察发现在Comparable接口中存在一个抽象方法，我们需要对其重写：

@Override
    public int compareTo(Student o) {
        return this.age - o.age;
    }

 编译器不报错后我们可以再次尝试运行：

将代码修改一下： 

    @Override
    public int compareTo(Student o) {
        return o.age - this.age;
    }

 运行：

发现Arrays.sort()的底层其实是compareTo() 。

那如果我们想要根据姓名来进行排序，可以这样修改：

    @Override
    public int compareTo(Student o) {
        return this.name.compareTo(o.name);
    }

运行：

观察这种方法是可行的，那就会产生一个痛点，我们只能选择一个参考系，如果想更改就只能对代码动手，这里我们引入Comparator接口可以解决这一问题：

Comparator接口：

CompareByAge类：
import java.util.Comparator;
public class CompareByAge implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getAge() - o2.getAge();
    }
}

CompareByName类：
import java.util.Comparator;
public class CompareByName implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getName().compareTo(o2.getName());
    }
}


Student类：
public class Student{
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

Students类：
import java.util.Arrays;
public class Students {
    Student[] students;

    public Students(Student[] students) {
        this.students = students;
    }

    public Student[] getStudents() {
        return students;
    }

    public void setStudents(Student[] students) {
        this.students = students;
    }

    @Override
    public String toString() {
        return "Students{" +
                "students=" + Arrays.toString(students) +
                '}';
    }
}


Test类：
import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("小明", 15);
        Student student2 = new Student("大宏", 16);
        Student[] students = new Student[]{student1,student2};
        Students students1 = new Students(students);
        System.out.println("排序前：" + students1);

        CompareByName compareByName = new CompareByName();
        Arrays.sort(students1.students, compareByName);

        System.out.println("排序后：" + students1);
    }
}

 运行结果：

 我们可以通过写成多个类来选择我们比较的根据。

Clone接口：

当我们需要创建一个一模一样的对象时可以使用Clone接口实现，举个例子：

Test类：

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person person1 = new Person("wyh", 13);
        Person person2 = (Person) person1.clone();
        System.out.println(person1);
        System.out.println(person2);
    }
}

Person类：

public class Person implements Cloneable{
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

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

运行结果： 克隆成功

我们还可以去测试一下克隆的具体实现是什么样的：

Test类：

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person person1 = new Person("wyh", 13);
        Person person2 = (Person) person1.clone();
        person1.setName("tjy");
        System.out.println(person1);
        System.out.println(person2);
    }
}

 运行结果：

我们改变了person1，但person2并没有跟着改变，由此可以看出Clone是重新在堆中开辟一块空间并将值放进去的：

 深拷贝：

Test类：

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException{
        Deposit deposit = new Deposit(5000);
        Person person1 = new Person("wyh", 13, deposit);
        Person person2 = (Person) person1.clone();
        person1.setName("tjy");
        System.out.println(person1);
        System.out.println(person2);
    }
}

Deposit类：
public class Deposit {
    double money;

    public Deposit(double money) {
        this.money = money;
    }
}

Person类：
public class Person implements Cloneable{
    private String name;
    private int age;
    private Deposit deposit;

    public Person(String name, int age, Deposit deposit) {
        this.name = name;
        this.age = age;
        this.deposit = deposit;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Deposit getDeposit() {
        return deposit;
    }

    public void setDeposit(Deposit deposit) {
        this.deposit = deposit;
    }

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

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

运行结果：

我们发现当一个类的成员变量中存在另一种类，在克隆的时候就会出现克隆出来后的成员变量在同一块空间。

原因：

这时候我们就需要对其深拷贝：

Test类：

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException{
        Deposit deposit = new Deposit(5000);
        Person person1 = new Person("wyh", 13, deposit);
        Person person2 = (Person) person1.clone();
        person1.setName("tjy");
        System.out.println(person1);
        System.out.println(person2);
    }
}
Deposit类：
public class Deposit implements Cloneable{
    double money;

    public Deposit(double money) {
        this.money = money;
    }

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

 Person类：

public class Person implements Cloneable{
    private String name;
    private int age;
    private Deposit deposit;

    public Person(String name, int age, Deposit deposit) {
        this.name = name;
        this.age = age;
        this.deposit = deposit;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Deposit getDeposit() {
        return deposit;
    }

    public void setDeposit(Deposit deposit) {
        this.deposit = deposit;
    }

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person tmp = (Person) super.clone();
        tmp.deposit = (Deposit) this.deposit.clone();
        return tmp;
    }
}

运行结果：

不再指向同一块区域，问题成功解决。

 补充：

2.5条悟T^T
关注
  • 24
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++中抽象类和接口的区别介绍
09-05
在面向对象编程中，抽象类和接口是两种重要的设计机制，它们都用于定义类的蓝图，但有着不同的设计理念和用途。下面将详细解释这两种概念及其区别。 首先，抽象类（Abstract Class）是一种不能被实例化的类，它通常...
抽象类和接口实验报告.doc
12-11
抽象类和接口实验报告
PHP抽象类和接口用法实例详解
01-03
本文实例讲述了PHP抽象类和接口用法。分享给大家供大家参考，具体如下： 前言 对于oop，估计大多数人并不陌生。有些人除PHP外也学习不少其他语言，会发现php的不同之处，可能语法极其丑陋，但并不妨碍它成为世界上...
c#中抽象类和接口的详细介绍
09-04
C#中的抽象类和接口 在C#中，抽象类和接口是两种不同的编程概念，它们都可以用来定义一个类的行为和结构，但它们之间有着明显的区别。 一、抽象类 抽象类是特殊的类，它不能被实例化，但它可以包含抽象方法和普通...
JAVA进阶补充
2301_80150315的博客
08-15 541
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 864
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 535
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 241
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
集合（1）
supercool7的博客
08-12 819
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 927
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
Mybatis XML 数据源为 Oracle 之批量插入或更新 Merge Into 的具体介绍与使用
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
08-12 673
由于近期在所开发的项目中，对于数据入库，有存在即更新，不存在则插入的需求，因此发现了 Oracle中的 MergeInto 命令。本文将对MergeInto的用法进行介绍并将 MergeInto 和批量插入进行结合，同时还会对在 MergeInto 开发中遇到的问题进行总结。MergeInto 命令是 Oracle9i 中新增的命令，有了 MergeInto 语句，我们对数据能够不仅仅只做单一的插入或单一的更新，而是可以将更新与插入一起操作。
构造方法，JavaBean，对象内存图，基础数据类型和引用数据类型
qq_63126439的博客
08-14 256
栈内存处理完数据之后会退出，指向推内存的箭头都会消失，当没有人指向他的时候，堆内存中的数据也会被移除。带参构造方法和无参数构造方法，两者方法名相同，但参数不同，这叫做构造方法的重载。方法区，新增元空间，把原来的方法区的多种功能进行了拆分。创造对象的时候，虚拟机会自动调用构造方法，作用是给成员变量进行初始化的。只要是看见new就会在堆内存创建新的空间，两个空间是独立的，互不影响。基础数据类型，在变量当中存储真实的数据值，和其他空间没有任何关系。使用其他空间的数值，自己的空间存储的是地址值。
基于JAVA生产制造执行系统设计与实现(源码+论文+讲解等)
程序员阿龙的博客
08-13 901
当下，如果 还依然使用纸质文档来记录并且管理相关信息，可能会出现很多问题，比如原始文件的丢失，因为采用纸质文档，很容易受潮或者怕火，不容易备份，需要花费大量的人员和资金来管理用纸质文档存储的信息，最重要的是数据出现问题寻找起来很麻烦，并且修改也困难，如果还这样操作会造成很大的资源浪费和经济损失。所以，对于本课题研究的产品生产制造信息的管理就需要有一款软件来代替手工操作，因此MES生产制造执行系统就应运而生。MES生产制造执行系统运用的工具包括Eclipse，Tomcat以及Navicat等。
【智能排班系统】SpringBoot整合邮件发送服务
记录一名在读研究生的学习笔记、感悟、开发产物
08-12 437
本文档指导如何配置Spring Boot应用以通过QQ邮箱发送邮件。首先，用户需登录QQ邮箱并开启SMTP服务以获取授权码。随后，在Spring Boot项目中，通过`application.yml`配置文件指定SMTP服务器的地址、端口及认证信息等参数。此外，还介绍了如何创建一个配置类`MailConfig`来读取这些配置，并使用Lombok简化getter和setter方法。为了封装邮件发送所需的属性，文档还提供了`EmailDto`类。
基于vue框架的NBA球星管理系统1878g（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
08-12 1008
随着互联网的普及和体育产业的蓬勃发展，篮球运动在全球范围内拥有庞大的粉丝群体，NBA（美国职业篮球联赛）作为其中的佼佼者，其球星更是备受关注。传统的球星信息管理方式往往依赖于纸质文档或简单的电子表格，这种方式不仅效率低下，难以实现数据的即时更新与共享，也无法满足球迷和媒体对球星信息深度挖掘的需求。因此，开发一套基于Vue框架的NBA球星管理系统，通过信息化手段整合球星信息，实现数据的快速录入、存储、查询与分析，对于提升管理效率、满足用户需求具有重要意义。，处理前端请求并提供业务逻辑。
云端追踪：Spring Cloud服务调用日志的精细化管理
2401_85812053的博客
08-11 532
Spring Cloud的日志管理工具和策略，使得在微服务架构下的服务调用日志收集和分析变得井然有序。通过Sleuth的调用链追踪、统一的日志格式、ELK Stack的集成以及Actuator的动态日志级别调整，我们能够高效地监控和管理服务调用日志。本文详细介绍了Spring Cloud中服务调用日志的收集和分析方法，从日志追踪到存储，再到分析和可视化，为读者提供了一个全面的视角。希望读者能够通过本文，深入理解Spring Cloud的日志管理机制，并有效地应用到自己的项目中。
Java面试题（一）----Java基础
weixin_73253843的博客
08-12 701
Java中==和equals有什么区别？ 一个是运算符，一个是方法。 == 如果比较的对象是基本数据类型，则比较数值是否相等； 如果比较的是引用数据类型，则比较的是对象的内存地址是否相等。 因为Java只有值传递，对于==来说，不管是比较基本数据类型，还是引用数据类型的变量，其比较的都是值，只是引用类型变量存的值是对象的地址。引用类型对象变量其实是一个引用，它们的值是指向对象所在的内存地址。
基于vue框架的爱看电影网站v4o92（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
最新发布
h2345678的博客
08-15 810
项目功能：用户,电影分类,电影信息,电影评分基于Vue框架的爱看电影网站项目功能丰富多样，旨在为用户提供一个集电影浏览、信息查询、观影体验、互动交流于一体的综合性平台。
2022年抽象类和接口学习目标及应用指南
本文介绍了2022年抽象类和接口的相关知识，主要包括设计并使用抽象类、使用Calendar类和GregorianCalendar类处理日历、声明接口来模拟弱继承关系、使用Comparable接口定义自然顺序、了解抽象类与接口的异同、声明...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值