【Java】抽象类与接口全解析

最新推荐文章于 2025-08-05 17:34:52 发布
最新推荐文章于 2025-08-05 17:34:52 发布
阅读量2.2k 收藏 95
点赞数 78
CC 4.0 BY-SA版权
分类专栏： 【Java】内容概括 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/user340/article/details/148381303
本文章已经生成可运行项目，

在这里插入图片描述

🎁个人主页：User_芊芊君子
🎉欢迎大家点赞👍评论📝收藏⭐文章
🔍系列专栏：【Java】内容概括

在这里插入图片描述
在这里插入图片描述

【前言】

在Java面向对象编程中，抽象类和接口是两个非常重要的概念，它们为代码的抽象化、模块化和可扩展性提供了强大的支持。无论是开发大型企业级应用，还是小型程序，掌握抽象类和接口的使用都至关重要。本文将通过详细的理论讲解、丰富的代码示例、直观的图片以及对比表格，帮助你深入理解Java抽象类和接口的本质与应用。

文章目录：

一、抽象类

1.什么是抽象类

在面对对象的概念中，所以对象都是通过类来描述的，但并不是所有的类都是用来描述对象的，如果一个类中没有包含足够的信息来描述一个具体的对象，这样的类就是抽象类
在这里插入图片描述

Dog类和Cat类都属于Animal类，但Dog（）和Cat（）方法没有实际的行为，可以将他们设计成抽象方法，包含抽象方法的类就是抽象类。

2.抽象类语法

在Java中，被abstract修饰的类称抽象类，抽象类中，被abstract修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。

public abstract class Animal {
    abstract public void eat();//抽象方法：被abstract修饰，没有方法体
    public double show(){      //自己增加的方法
        return show1;
    }
    protected double show1;//参数
}

3.抽象类特征

3.1 抽象类不能实例化对象

public abstract class Animal {
    Animal animal = new Animal();
}

在这里插入图片描述

3.2 抽象方法不能是private的

public abstract class Animal {
    abstract private void eat();//抽象方法：被abstract修饰，没有方法体
}

在这里插入图片描述

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

abstract final void eat();
abstract public static void eat();

在这里插入图片描述

3.4 抽象类必须被继承，并且继承后子类要重写父类的抽象方法，除非子类也是抽象类，用abstract修饰

public abstract class Cat extends Animal {
    @Override
    public  void eat(){
        
    }
}

public abstract class Cat extends Animal {
    @Override
    public abstract void eat();
   
}

3.5 抽象类中不⼀定包含抽象⽅法，但是有抽象⽅法的类⼀定是抽象类

3.6 抽象类中可以有构造⽅法，供⼦类创建对象时，初始化⽗类的成员变量

4.抽象类的作用

抽象类本身不能被实例化，只能创建子类，并且重写抽象方法，这就起到检验的作用

二、接口

1.什么是接口？

字面意思：我们生活中的水龙头，插座，充电线都是有接口的，才能插上。接口就是公共的行为规范标准，在实现时，只要符合规范标准，就能通用

2.语法规则

接口的定义和类基本相同，将class换成interface关键字

public interface IShape {
    public static final int SIZE = 100;//接口变量默认public static final
    public abstract void test();//接口方法默认public abstract
}

【注意】

  • 接口命名一般以大写字母I开头;
  • 接口不能被实例化；

3.接口的使用

类与接口之间是implements的关系

public class 类名 implenments 接口名{
//...
}

这里建立一个IUSB接口和Mouse类

public interface IUSB {
    void openDevice();
    void closeDevice();
}

public class Mouse implements IUSB{
    @Override
    public void openDevice() {
        System.out.println("打开鼠标");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标");
    }
}

4.接口特性

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

public class TestUSB {
    public static void main(String[] args) {
        USB usb = new USB();
    }
}

在这里插入图片描述

4.2 接口中的方法会被默认为public abstract,其他修饰符会报错

public interface USB {
    private void openDevice();//private使用错误
    void closeDevice();
}

在这里插入图片描述

4.3 接口中的方法不能在接口中实现，只能通过接口的类来实现

public interface USB {
    //void openDevice();
    void closeDevice(){
        System.out.println("关闭USB设备");
    }
}

在这里插入图片描述

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

public class Mouse implements USB{
    @Override
    public void openDevice() {
        System.out.println("打开鼠标");
    }
}

在这里插入图片描述

4.5 接口中可以有变量，但他会被默认为public static final 变量

public interface USB {
    int susu = 250;//默认被final public static修饰
    void openDevice();
    void closeDevice();
}

4.6 接口中不能有静态代码块和构造方法

public interface USB {
    public USB(){

    }
    {

    }
    int susu = 250;//默认被final public static修饰
    void openDevice();
    void closeDevice();
}

在这里插入图片描述

5.实现多个接口

一个类可以实现多个接口，这就是继承所做不到的

  • 这里创建一个Dog类，可以让他实现多个接口，如IRunning,ISwimming,IFlying。每个接口的抽象方法都有重写，否则必须设置为抽象类
  • AIT + InS快捷键重写
public class Dog extends Animal implements IRunning,ISwimming{
    @Override
    public void run() {

    }

    @Override
    public void swim() {
        
    }
}

狗：既能跑，又能游；

【注意】

有了接口之后，我们就不用注意具体类型，只需要关注这个类是否具备某种类型

6.接口间的继承

在Java中，类和类之间是单继承的，但一个类可以实现多个接口，接口与接口之间可以多继承

这段代码就继承了两个接口：游和跑

public class Dog extends Animal implements ISwimming,IRunning{
    @Override
    public void run() {
        
    }

    @Override
    public void swim() {

    }
}

7.接口使用实例

对象之间大小比较:

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

    @Override
    public String toString() {
        return super.toString();
    }
}


public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("小华",20);
        Student s2 = new Student("小张",10);
        System.out.println(s1>s2);
    }
}

在这里插入图片描述

这样进行比较会报错，因为没有指定根据分数还是什么来比较，这样不太灵活，我们可以使用接口，如下：

使用Comparable接口

public class Student implements Comparable<Student>{
    public String name;
    public int age;
    public Student (String name,int age){
        this.name=name;
        this.age=age;
    }

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

     @Override
     public int compareTo(Student o) {
        if(this.age>o.age)
            return 1;
        else if(this.age == o.age)
            return 0;
        else
            return -1;
     }
 }


public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("小华",20);
        Student s2 = new Student("小张",12);
        //System.out.println(s1>s2);
        if(s1.compareTo(s2)>0){
            System.out.println("s1>s2");
        }
    }
}

在这里插入图片描述
使用Comparator接口

import java.util.Comparator;

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


public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("小华",20);
        Student s2 = new Student("小张",12);
        AgeComparator ageComparator=new AgeComparator();
        int ret = ageComparator.compare(s1,s2);
        if(ret>0){
            System.out.println("s1>s2");
        }

在这里插入图片描述

如果是根据名字来比较的，就要看对应字母的大小

8.Clonable接口和深拷贝

8.1 Clonable接口

Java 中内置了⼀些很有⽤的接⼝,Clonable就是其中之⼀.
Object 类中存在⼀个clone⽅法,调⽤这个⽅法可以创建⼀个对象的"拷⻉".但是要想合法调⽤clone
⽅法,必须要先实现Clonable接⼝,否则就会抛出CloneNotSupportedException异常.

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

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

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

public class Test1 {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person person1 = new Person("小华子",20);
        Person person2 = (Person) person1.clone();//强制类型转换
        System.out.println(person2);
    }
}

在这里插入图片描述
受查异常/编译时异常
在这里插入图片描述
解决方法：
在这里插入图片描述

8.2 浅拷贝

class Money implements Cloneable{
    public double money = 9.9;

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

lic class Test1 {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person person1 = new Person("小华子",20);
        Person person2 = (Person) person1.clone();

        System.out.println(person1.m.money);
        System.out.println(person2.m.money);
        System.out.println("==============");
        person2.m.money = 19.9;
        System.out.println(person1.m.money);
        System.out.println(person2.m.money);

        }

在这里插入图片描述

在这里插入图片描述

通过clone，我们只是拷⻉了Person对象。但是Person对象中的Money对象，并没有拷⻉。通过person2这个引⽤修改了m的值后，person1这个引⽤访问m的时候，值也发⽣了改变。这⾥就是发⽣了浅拷⻉。

8.3 深拷贝

class Money implements Cloneable{
    public double money = 9.9;

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

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

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

public class Test1 {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person person1 = new Person("小华子",20);
        Person person2 = (Person) person1.clone();

        System.out.println(person1.m.money);
        System.out.println(person2.m.money);
        System.out.println("==============");
        person2.m.money = 19.9;
        System.out.println(person1.m.money);
        System.out.println(person2.m.money);

        }

核心代码：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

9.抽象类和接口的区别

抽象类中可以包含普通⽅法和普通字段,这样的普通⽅法和字段可以被⼦类直接使⽤(不必重写),
⽽接⼝中不能包含普通⽅法,⼦类必须重写所有的抽象⽅法.

No区别抽象类(abstract)接口(interface)
1结构组成普通类+抽象方法抽象方法+全局常量
2权限各种权限public
3子类使用使用extends关键字继承抽象类使用implements关键字实现接口
4关系一个抽象类可以实现若干接口接口不能继承抽象类，可extends继承多个父接口
5子类限制一个子类只能继承一个抽象类一个子类可以实现多个接口

【总结】

在 Java 里，抽象类与接口是实现抽象编程的关键工具。抽象类融合普通类与抽象方法，可定义部分实现逻辑，权限灵活；接口由抽象方法和全局常量构成，成员权限默认 public 。子类继承抽象类用 extends ，实现接口用 implements 。关系上，抽象类能实现多个接口，接口可多继承。继承限制方面，子类单继承抽象类，却可多实现接口 。二者各有适用场景，抽象类适合提炼共性、留存部分实现；接口利于规范行为、实现多态解耦。合理运用它们，能让代码架构更清晰、可扩展与可维护，助力构建灵活且健壮的 Java 程序 。

在这里插入图片描述

本文章已经生成可运行项目
Java抽象类与接口详解
weixin_64793514的博客
10-19 1267
什么是抽象类，什么是接口，其用法，通过本文，尽收眼底。
JAVA抽象类及接口使用方法解析
09-07
在Java编程语言中，抽象类和接口是两种重要的面向对象设计工具，它们允许开发者定义行为和属性的模板，而无需具体实现所有细节。抽象类和接口各有特点，但都为多态性和代码重用提供了支持。 **抽象类（Abstract ...
深入解析Java抽象类与接口
m0_73982171的博客
03-19 1187
抽象方法:抽象方法是接口的核心部分,所有实现接口的类都必须实现这些方法,抽象方法默认是public和abstract的,这些修饰符可以省略.默认方法:默认方法是在Java8中引入的,允许接口提供具体实现.实现类可以选择重写默认方法静态方法:静态方法也是在Java8中引入的,它们属于接口本身,可以通过接口名直接调用,而不需要实现类的对象私有方法:私有方法是在Java9中引入的,用于在接口中为默认方法或其他私有方法提供辅助功能.这些方法不能被实现类访问,只能在接口内部使用。
Java抽象类与接口深度解析：核心区别与应用场景全指南
ztt123654的博客
08-01 817
定义：使用abstract// 抽象方法public void sleep() { // 具体方法特点不能直接实例化（会编译报错）可包含抽象方法（无实现）和具体方法（有实现）子类必须实现所有抽象方法（除非子类也是抽象类）应用场景模板方法模式：定义算法骨架，子类实现具体步骤代码复用：将公共逻辑放在抽象类中定义：使用interfacevoid fly();// 抽象方法default void land() { // 默认方法（Java 8+）
Java笔试面试-抽象类与接口
热门推荐
HenryLei的博客
09-15 10万+
抽象类 定义：   在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。简单来说，使用关键字 abstract 修饰的类就叫做抽象类。 使用： abstract class AbstractAnimal { public AbstractAnimal() { ...
Java抽象类与接口：什么是抽象类与接口？JDK 8默认方法是什么？如何正确使用？
猫头虎技术团队：授渔优于赠鱼，兴趣引领智慧，探索之乐尤显珍贵。商务合作+：Libin9iOak ，万粉变现+：优快云WF，猫头虎承诺每年免费为100名C站创作者做账号流量诊断服务！全网搜：猫头虎技术团队，点击文章底部名片或直接私信我一切皆可谈，快找虎哥！
12-17 3444
Java抽象类与接口：什么是抽象类与接口？JDK 8默认方法是什么？如何正确使用？ 在Java开发中，抽象类和接口是常见的设计工具，但很多人却常常混淆它们的概念和使用场景。JDK 8中新增的接口默认方法更让初学者摸不着头脑。今天，猫头虎带你一文彻底搞懂： 抽象类与接口的核心区别 JDK 8默认方法的实现与作用 实战代码演示，如何正确使用它们？
Java中抽象类与接口详解
qm_hu的博客
05-06 1382
private我们已经知道,抽象类就是为了被继承,但是private修饰的并不支持继承,自然抽象类中也不能有private修饰了finalfinal修饰的类不支持继承,所以也不能与抽象类中abstract在一起使用static抽象方法不能用static修饰,static修饰的方法是类级别的方法,不是对象级别的方法.而抽象类使用来被继承的.首先抽象类是半抽象的,接口是完全抽象的,这也决定了他们的不同1.一个类可以实现(implements)多个接口,但是一个普通类只能继承(extends)一个抽象类。
Java面向对象核心：多态、抽象类与接口实战解析
2403_89107873的博客
04-13 1227
本文为Java全栈学习系列笔记，结合企业级开发实践，深度解析OOP核心特性。适合具备基础语法知识的开发者进阶学习，文中包含大量工程化经验总结。
【面试问题】Java 接口与抽象类的区别
2202_75481735的博客
03-19 1176
定义：使用abstract关键字声明的类，包含抽象方法（无实现）和具体方法（有实现）。特点不能被实例化，必须通过子类继承（extends子类必须实现所有抽象方法（除非子类也是抽象类）。可以包含构造方法、成员变量和非抽象方法。维度抽象类接口关系继承（is-a）实现（can-do）代码复用强（继承状态和实现）弱（仅契约，无实现复用）灵活性低（单继承）高（多实现）设计约束部分抽象（可包含具体方法）完全抽象（Java 8 前）最佳实践模板设计、公共逻辑抽取行为契约、功能组合口诀。
Java抽象类和接口的深度解析.pptx.pptx
12-19
Java抽象类和接口是面向对象编程中的重要概念，它们在软件设计中扮演着定义和组织代码结构的关键角色。本文将深入解析这两种类型的细节，并通过实例分析它们的应用。 首先，我们来了解一下抽象类和接口的基本概念。...
java 抽象类和接口的区别详细解析
09-05
Java中的抽象类（abstract class）和接口（interface）都是用于实现多态性和抽象化概念的工具，它们在面向对象设计中扮演着重要角色。然而，它们之间存在显著的区别，理解这些差异有助于开发者根据具体需求做出合适...
Java抽象类和接口解析.pdf
12-29
Java抽象类和接口解析
JVM 01 运行区域
2301_79308687的博客
08-02 1080
虚拟机隐藏平台差异，解决不同平台代码运行结果不一致问题，实现，实现用户代码跨平台。它本身是一个操作系统上的应用程序，将字节码文件翻译成特定机器的机器码。
Flash循环存储的地址回绕处理：跨边界写入的三种实现方案
最新发布
u010360138的博客
08-05 586
本文介绍了三种实现Flash循环存储地址计算的方法：1）条件判断法通过显式判断是否溢出实现地址回绕，逻辑清晰通用性强；2）模运算法利用取模运算自动处理地址回绕，代码简洁；3）位掩码法在存储区大小为2的幂时使用位与运算替代模运算，性能最优。三种方法功能等效但各有特点，选择时应考虑存储区特性、性能需求和代码可读性。关键注意事项包括写入延迟、地址有效性检查和边界条件处理。
mybatis-plus动态数据源
qq_62408075的博客
08-01 217
不同于mybatis动态数据，mybatisplus自带很多查询方法。
YAML文件
2301_80251684的博客
08-04 214
YAML是一种数据序列化格式，常用于配置文件、数据交换和存储。其设计目标是简洁易读，同时支持复杂数据结构。
Mybatis学习之特殊SQL的执行（六）
PP东博客
08-05 293
{ids}不推荐使用，因为这边会自动添加单引号，变成 delete from t_user where id in (‘9,10’)。上述三种方式，推荐是哟第二第三种。Java的Mapper接口。Java的Mapper接口。Java的Mapper接口。Java的Mapper接口。Mapper.xml文件。Mapper.xml文件。Mapper.xml文件。Mapper.xml文件。
从源码角度分析导致 JVM 内存泄露的 ThreadLocal
m0_60963435的博客
08-03 893
摘要： ThreadLocal用于实现线程局部变量，解决多线程环境下变量共享问题。在Spring事务管理中，ThreadLocal确保同一线程内的数据库连接保持一致，避免事务失效。其核心原理是为每个线程维护独立的变量副本，通过ThreadLocalMap存储，键为ThreadLocal实例，值为用户数据。ThreadLocalMap采用线性探测法解决哈希冲突。 ThreadLocal可能引发内存泄漏问题，主要因ThreadLocalMap的键为弱引用，但值仍为强引用。若线程长期存活，可能导致值无法回收。建议
Java32：综合项目：微头条管理系统
zzx_nihao的博客
08-03 1017
INSERT INTO `news_user` (uid,username,user_pwd,nick_name) VALUES (1, 'zhangsan', 'e10adc3949ba59abbe56e057f20f883e', '张三');INSERT INTO `news_user` (uid,username,user_pwd,nick_name) VALUES (2, 'lisi', 'e10adc3949ba59abbe56e057f20f883e', '李四');//防全局修改和删除。
评论 86
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值