【Java 学习】Java抽象类详解：从理论到实践，带你迈向面向对象的深度思考！

文章【Java 学习】Java抽象类详解：从理论到实践，带你迈向面向对象的深度思考！分享给大家，欢迎收藏Java资料网，专注分享技术知识

💬 欢迎讨论：如对文章内容有疑问或见解，欢迎在评论区留言，我需要您的帮助！

👍 点赞、收藏与分享：如果这篇文章对您有所帮助，请不吝点赞、收藏或分享，谢谢您的支持！

🚀 传播技术之美：期待您将这篇文章推荐给更多对需要学习Java语言、低代码开发感兴趣的朋友，让我们共同学习、成长！

1. 什么是抽象类？

举一个Animal类、Cat类和Dog类的例子：

class Animal{
    
    public void eat(){
        System.out.println("吃饭~");
    }
}

class Dog extends Animal{
    public void eat(){
        System.out.println("吃骨头~");
    }
    
    public void bark(){
        System.out.println("汪汪~");
    }
}

class Cat extends Animal {

    // 构造器

    public void eat(){
        System.out.println("吃鱼~");
    }

    public void mimi() {
        System.out.println("喵喵~~");
    }

}


public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        
        Cat cat = new Cat();
        cat.eat();
        
    }
}

关系图如下：

这三个类之间：Dog类继承Animal类，Cat类继承Animal类

当使用时，实例化Dog类和Cat类，但是不实例化Animal类，并且，Animal中的方法都会被Dog类和Cat类重写，似乎Animal中不需要定义方法，只需要写方法名字即可！

在上述的描述中，我们发现Animal这种类，也就是父类（基类）中的方法不需要定义，只需要设置一些名字即可，定义的内容让继承父类的类去实现。

为了满足这个需求，Java设计了一个抽象类（abstract），这种类是一个不能被直接实例化的类，用来作为其他类的模板。它可以包含抽象方法（没有方法体的方法）和非抽象方法（普通的方法，有方法体）。

抽象类本质上是“不能直接使用的类”。它的主要作用是 定义一种规范或基类，让子类去实现具体的功能。

2. 抽象类的语法及特性

2.1 抽象类语法

在Java中，一个类如果被abstract 修饰称为抽象类，抽象类中被给出具体的实现体。

// 抽象类：被abstract修饰的类
public abstract class Shape {

	protected double area;    // 面积


 	// 抽象方法：被abstract修饰的方法，没有方法体
	abstract public void draw();
	abstract void calcArea();
	
 	// 抽象类也是类，也可以增加普通方法和属性
	public double getArea(){
 		return area;
 	}
 }

//abstract 修饰的方法称为抽象方法，抽象方法不用定义实体

注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法

2.2 抽象类特性

1. 抽象类不能直接实例化对象

   Shape shape = new Shape();
    
   // 编译出错
   Shape是抽象的; 无法实例化
   

2. 抽象方法不能使用private访问限定符

   abstract public class Shape {
       protected double area;
       
       // 不合法的使用规则
       // 抽象方法需要被重写，使用private后子类就不能重写
       abstract private void draw();
   
       public double getArea(){
           return area;
       }
   }
   

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

    public abstract class Shape {
       abstract final void methodA();
       abstract public static void methodB();
    }
    
   // 编译报错：
   //非法的修饰符组合: abstract和final
   //非法的修饰符组合: abstract和static
   

4. 抽象类必须被继承，并且继承后子类要重写父类中所有的抽象方法。（下述的三个代码放在不同的文件中）

   //文件 Rect.java
   // 矩形类
   public class Rect extends Shape {
       private double length;
       private double width;
    
       Rect(double length, double width){
           this.length = length;
           this.width = width;
       }
       
       // 实现所有的抽象类
       public void draw(){
           System.out.println("矩形: length= "+length+" width= " + width);
       }
    
       public void calcArea(){
           area = length * width;
       }
    }
   
   //文件 Circle.java
   // 圆类
   public class Circle extends Shape{
   	private double r;
    	final private static double PI = 3.14;
    	
    	public Circle(double r){
    		this.r = r;
    	}
    	
    	 // 实现所有的抽象类
    	public void draw(){
    		System.out.println("圆：r = "+r);
    	}
    	
    	public void calcArea(){
    		area = PI * r * r;
    	}
    }
    
    //文件 Triangle.java
    // 三角形类：
   public class Triangle extends Shape {
    	private double a;
    	private double b;
    	private double c;
    
    	// 实现一个抽象类
    	public void draw() {
    		System.out.println("三角形：a = "+a + " b = "+b+" c = "+c);
    	}
    	
     //double calcArea();   // 编译失败，解决方法：要么实现该抽象方法，要么将三角形设计为抽象类
   }
   

5. 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用abstract修
   饰

    // 三角形类：
   public abstract class Triangle extends Shape {
    	private double a;
    	private double b;
    	private double c;
    
    	public void draw() {
    		System.out.println("三角形：a = "+a + " b = "+b+" c = "+c);
   	}
   
    //double calcArea();   将三角形设计为抽象类，继承该 Triangle类的类需要实现该方法
   }
   

6. 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类

7. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

3. 抽象类的作用

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

有些同学可能会说了, 普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法
呢?
确实如此。但是使用抽象类相当于多了一重编译器的校验。

使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成，而应由子类完成。那么此时如果不小心误用成父类
了，使用普通类编译器是不会报错的。 但是父类是抽象类就会在实例化的时候提示错误， 让我们尽早发现问题。

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

充分利用编译器的校验, 在实际开发中是非常有意义的。

文章来源:https://blog.csdn.net/2302_79527141/article/details/144651582
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！