Java抽象类零基础彻底吃透｜超详细保姆级教程（含全部考点+完整代码+习题）

适合：Java零基础入门、期末复习、考试突击、新手巩固

特点：无知识跳跃、全大白话、全考点覆盖、可直接背诵、可直接交作业

 

标签：Java、抽象类、零基础、面向对象、期末复习、Java入门

 

 

 

目录

 

1. 前言（为什么学抽象类）

2. 前置知识：普通类完整回顾

3. 抽象类诞生的核心思想

4. 抽象类概念 + 语法

5. 抽象方法概念 + 语法

6. 抽象类与抽象方法必考关系

7. 抽象类内部所有可写内容（超容易误区）

8. 不能抽象的4类方法（考试高频）

9. 抽象类为什么不能 new 对象

10. 子类继承抽象类 两大黄金规则（全书重点）

11. 重写抽象方法 4 条铁律

12. 全网最标准 Shape 完整实战代码（可直接运行）

13. 高频易错判断题汇总

14. 终极背诵口诀

15. 知识点思维导图

16. 课后练习题（带答案+编程题完整代码）

17. 全文总结

 

 

 

一、前言

 

很多初学者学到 抽象类 直接懵逼：

 

 普通类已经能用了，为什么还要抽象类？

 抽象方法为什么没有方法体？

 子类到底什么时候要重写？什么时候也要抽象？

 考试判断题、选择题疯狂踩坑

 

原因只有一个：知识点没有一次性学完整！

 

本篇博客一次性把 抽象类所有语法、所有规则、所有易错点、所有考试考点 全部讲完，零基础看完直接满分。

 

 

 

二、前置知识：普通类回顾（必须看懂）

 

普通类 = 描述具体事物的完整模板

 

普通类三要素：

 

1. 成员变量：保存特征（半径、颜色、名字）

2. 构造方法：创建对象、初始化数据

3. 普通方法：必须有方法体 {}，有具体逻辑，可以直接调用

 

普通类特点：

 

✅ 可以直接 new 对象

✅ 所有方法都写完整

✅ 可以直接使用

 

普通类最大缺陷：无法强制子类必须实现某些功能

所以 Java 推出了 抽象类

 

 

 

三、为什么需要抽象类？（核心思想）

 

有些类太笼统、不具体、不是实物，不能 new 对象。

 

举例：图形 Shape

图形包含：圆、矩形、三角形

 

图形本身：

 

没有具体形状

没有固定公式

不能直接算面积、周长

 

所以：

通用规范 → 抽象类

具体实现 → 子类完成

 

抽象类作用：

 

1. 统一规范所有子类

2. 强制子类必须实现指定方法

3. 实现代码复用

4. 为多态做铺垫

 

 

 

四、什么是抽象类？

 

用 abstract 修饰的类 = 抽象类

 

语法：

 

java

abstract class 类名{

 

}

 

 

必考铁律：抽象类不能 new 对象！

 

只能被继承，只能当父模板。

 

 

 

五、什么是抽象方法？（重中之重）

 

抽象方法 = 只有声明、没有方法体、强制子类补全

 

特点：

 

1. 有  abstract 

2. 没有 {} 方法体

3. 分号直接结束

4. 只定规则、不写代码

 

语法：

 

java

public abstract double area();

public abstract double girth();

 

 

意思：

 

所有图形必须会算面积、周长

怎么算？子类自己写！

 

 

 

六、抽象类与抽象方法 必考关系

 

两条死规则

 

1. 有抽象方法 → 一定是抽象类（普通类绝对不能有抽象方法）

2. 抽象类 → 可以没有抽象方法（可以单纯禁止 new 对象）

 

大白话口诀

 

有抽象方法必抽象类，抽象类可无抽象方法

 

 

 

七、抽象类里面可以写哪些内容？

 

（90%新手记错）

 

抽象类可以包含：

 

1. 成员变量 ✅

2. 构造方法 ✅

3. 普通方法 ✅

4. 抽象方法 ✅

 

超级重点：抽象类有构造方法！

 

作用：

子类继承后用 super() 调用，初始化父类属性

 

 

 

八、四类绝对不能抽象的方法（考试高频）

 

以下 不能加 abstract：

 

1. 构造方法

2. static 静态方法

3. private 私有方法

4. final 方法

 

逐句通俗解释

 

构造方法：必须有方法体，不能空

静态方法：属于类，不能重写

私有方法：子类看不到，不能重写

final 方法：禁止重写，abstract 要求必须重写 → 冲突

 

一句话总结：

不能被重写的方法，一律不能抽象

 

 

 

九、抽象类为什么不能 new 对象？

 

1. 包含空的抽象方法，没有代码逻辑

2. 如果可以 new，调用空方法程序崩溃

3. 抽象类定位是：模板类，不创建对象

 

只能：子类 new 对象

 

 

 

十、子类继承抽象类 两大核心规则（全书最重点）

 

情况一：子类 没有重写完所有抽象方法

 

👉 子类必须也变成抽象类（加 abstract）

👉 子类也不能 new 对象

 

情况二：子类 重写全部抽象方法

 

👉 子类是普通类

👉 可以正常 new 对象

 

终极总结

 

没补全 → 一起抽象

补全完 → 变普通类

 

 

 

十一、重写抽象方法 4 条铁律

 

1. 方法名、参数列表 必须一模一样

2. 返回值类型 必须兼容

3. 访问权限 只能放大、不能缩小（public 不能变 private）

4. 必须加 @Override（规范+防错）

 

 

 

十二、完整可运行实战代码（Shape图形案例）

 

直接复制即可运行

 

java

// 抽象父类：图形模板

abstract class Shape {

    protected String name;

 

    // 抽象类构造方法

    public Shape(String name) {

        this.name = name;

    }

 

    // 普通方法（所有子类复用）

    public void showInfo() {

        System.out.println("图形名称：" + name);

    }

 

    // 抽象方法：强制子类实现

    public abstract double area();

    public abstract double girth();

}

 

// 圆形子类

class Circle extends Shape {

    private double radius;

    private final double PI = 3.14;

 

    public Circle(String name, double radius) {

        super(name);

        this.radius = radius;

    }

 

    @Override

    public double area() {

        return PI * radius * radius;

    }

 

    @Override

    public double girth() {

        return 2 * PI * radius;

    }

}

 

// 矩形子类

class Rectangle extends Shape {

    private double length;

    private double width;

 

    public Rectangle(String name, double length, double width) {

        super(name);

        this.length = length;

        this.width = width;

    }

 

    @Override

    public double area() {

        return length * width;

    }

 

    @Override

    public double girth() {

        return 2 * (length + width);

    }

}

 

// 测试类

public class TestShape {

    public static void main(String[] args) {

        Shape c = new Circle("圆形", 5);

        Shape r = new Rectangle("矩形", 4, 6);

 

        c.showInfo();

        System.out.println("面积：" + c.area());

        System.out.println("周长：" + c.girth());

 

        System.out.println("------------------");

 

        r.showInfo();

        System.out.println("面积：" + r.area());

        System.out.println("周长：" + r.girth());

    }

}

 

 

运行结果

 

plaintext

图形名称：圆形

面积：78.5

周长：31.4

------------------

图形名称：矩形

面积：24.0

周长：20.0

 

 

 

 

十三、高频易错判断题（考试必背）

 

1. 抽象类一定有抽象方法？❌ 错

2. 普通类可以有抽象方法？❌ 错

3. 抽象类可以 new 对象？❌ 错

4. 抽象类有构造方法？✅ 对

5. 静态/私有/构造方法可以抽象？❌ 全错

6. 子类没写完抽象方法必须抽象？✅ 对

 

 

 

十四、抽象类终极口诀（考前速记）

 

抽象类，abstract，

不能new，只当模板；

有抽象方法必抽象类，

抽象类可无抽象方案；

构造静态私有final，

全都不能做抽象；

子类补完方法变普通，

少补一个还得抽象；

重写方法不能乱改，

权限只能放宽不能降。

 

 

 

十五、知识点思维导图（文字版）

 

plaintext

抽象类

├── 定义：abstract class

├── 特点：不能实例化、做模板

├── 内部结构：变量、构造、普通方法、抽象方法

├── 抽象方法：无方法体、强制重写

├── 禁止抽象：构造、static、private、final

└── 子类规则

     ├── 没重写完 → 子类抽象

     └── 全重写 → 子类普通

 

 

 

 

十六、课后练习题（带完整答案）

 

1. 判断题

 

1. 有抽象方法的类一定是抽象类（✅）

2. 抽象类不能有普通方法（❌）

3. 抽象类可以有构造方法（✅）

4. 静态方法可以是抽象方法（❌）

 

2. 简答题

 

问：抽象类为什么不能实例化？

答：

抽象类包含未实现的抽象方法，没有方法体，若允许实例化会导致调用无逻辑代码；且抽象类是模板类，设计目的用于继承，不用于创建对象。

 

3. 编程题（完整标准答案）

 

题目

 

定义抽象类 Animal，包含抽象方法 eat()

定义子类 Dog、Cat 实现 eat()

 

完整可运行代码

 

java

// 抽象父类：动物类

abstract class Animal {

    // 抽象方法：吃东西（只定义规范，不实现）

    public abstract void eat();

}

 

// 子类：狗 继承动物类

class Dog extends Animal {

    // 重写、实现父类抽象方法

    @Override

    public void eat() {

        System.out.println("小狗吃骨头");

    }

}

 

// 子类：猫 继承动物类

class Cat extends Animal {

    // 重写、实现父类抽象方法

    @Override

    public void eat() {

        System.out.println("小猫吃鱼");

    }

}

 

// 测试类

public class TestAnimal {

    public static void main(String[] args) {

        // 多态写法：父类引用指向子类对象

        Animal dog = new Dog();

        Animal cat = new Cat();

 

        // 调用重写后的方法

        dog.eat();

        cat.eat();

    }

}

 

 

运行结果

 

plaintext

小狗吃骨头

小猫吃鱼

 

 

解题思路

 

1. 使用  abstract  定义抽象父类 Animal

2. 在抽象类中定义无方法体的抽象方法 eat()

3. 让 Dog、Cat 子类继承 Animal

4. 子类必须重写实现所有抽象方法，写出各自独有逻辑

5. 通过多态创建对象、调用方法，完成程序

 

 

 

十七、全文总结

 

读完本文你掌握了：

 

 抽象类诞生意义和普通类区别

 抽象类、抽象方法全部语法

 四大禁止抽象方法考点

 子类两种继承规则（考试核心）

 完整 Shape 项目实战

 所有易错点、口诀、习题全覆盖