Java基础——自学习使用(抽象类)

一、抽象类的定义

        在Java中，抽象类是一种不能被实例化的类，它主要用于被其他类继承。抽象类可以包含抽象方法（没有方法体的方法，仅有一个方法签名，以abstract关键字声明）和非抽象方法（即具有实现体的普通方法）。如果一个类包含了至少一个抽象方法，那么这个类就必须被声明为抽象类。然而，即使一个抽象类不包含任何抽象方法，它也可以被声明为抽象类，这样的抽象类主要用于限制其实例化。

        

        继承的本质是代码的复用，在很多时候，当子类继承父类的方法时，有时父类的方法并不适合子类，此时一般会用到重写，但是如果有多个子类都需要调用修改该方法，此时我们会发现，该方法其实没有必要在父类中实现，完全可以不实现，此时子类只需要实现自己的方法，我们要使用多态使内存形态有各种各样的形式，所以必须使用继承，否则无法使用多态来丰富代码。

         想使用多态，而又不想在父类实现一些方法，于是出现了抽象类。抽象类当中可以写抽象方法，抽象方法只需要对方法定义不需要实现，那么既可以使用多态，也不会造成代码的冗余。

(接口没有构造器)

        抽象类（Abstract Class）在面向对象编程中是一种特殊的类，它不能被实例化（即不能直接创建对象）。抽象类的主要目的是作为其他类的基类（父类），提供一组必须由子类实现的方法或属性。这些方法在抽象类中通常被声明为抽象方法，即没有具体实现的方法，只有方法签名。

下面是一个简化的示例，用于解释抽象类的概念：

// 定义一个抽象类 Shape  
abstract class Shape {  
    // 抽象方法，没有具体实现  
    abstract void draw();  
  
    // 非抽象方法，可以直接使用  
    void setColor(String color) {  
        System.out.println("Setting color to " + color);  
    }  
}  
  
// Circle 类继承自 Shape 类，并实现 draw 方法  
class Circle extends Shape {  
    @Override  
    void draw() {  
        System.out.println("Drawing a circle...");  
    }  
}  
  
// Rectangle 类也继承自 Shape 类，并实现 draw 方法  
class Rectangle extends Shape {  
    @Override  
    void draw() {  
        System.out.println("Drawing a rectangle...");  
    }  
}  
  
// 使用  
public class TestShapes {  
    public static void main(String[] args) {  
        // 不能直接实例化 Shape 类  
        // Shape shape = new Shape(); // 编译错误  
  
        // 可以实例化 Circle 和 Rectangle 类  
        Circle circle = new Circle();  
        circle.draw();  
        circle.setColor("Red");  
  
        Rectangle rectangle = new Rectangle();  
        rectangle.draw();  
        rectangle.setColor("Blue");  
    }  
}

在这个示例中，Shape 是一个抽象类，它定义了一个抽象方法 draw() 和一个非抽象方法 setColor()。Circle 和 Rectangle 是 Shape 的子类，它们各自实现了 draw() 方法，因此可以创建它们的实例并调用 draw() 和 setColor() 方法。由于 Shape 是抽象类，所以不能直接创建其实例。

二、抽象类的特点

1.abstract修饰的类叫做抽象类，abstract修饰的方法叫做抽象方法

格式：public abstract class 类名{}

2.abstract修饰的抽象方法必须在子类当中实现，前提是子类不是抽象类

//父类
public abstract class A{
    public abstract void run();
}

//子类
public class B extends A{
    public abstract void run(){
        System.out.println("Hello World");    
    }
}

3.抽象类一定是父类***

4.只有抽象类当中才能有抽象方法，普通类当中不能有抽象方法

5.抽象类当中不一定非要写抽象方法，也可以写普通方法

abstract class Animal {  
    abstract void makeSound();  
    void run(){
         System.out.println("跑的很快");
    }
}  

6.抽象类不能被实例化（不能被被创建对象），只能使用多态

// 抽象类 Vehicle  
abstract class Vehicle {  
    // 抽象方法，要求子类实现  
    abstract void move();  
}  
  
// 抽象类 Car 继承自 Vehicle  
// Car 类继承了 Vehicle 类的抽象方法 move()，但自身没有提供实现  
// 它也可以添加自己的抽象方法  
abstract class Car extends Vehicle {  
    // 抽象方法，仅 Car 的子类需要实现  
    abstract void startEngine();  
}  
  
// 具体的类 ElectricCar 继承自 Car  
class ElectricCar extends Car {  
    @Override  
    void move() {  
        System.out.println("Moving silently...");  
    }  
  
    @Override  
    void startEngine() {  
        System.out.println("Starting electric engine...");  
    }  
  
    // ElectricCar 也可以有自己特有的方法  
    void chargeBattery() {  
        System.out.println("Charging battery...");  
    }  
}  
  
// 主类，用于测试  
public class Main {  
    public static void main(String[] args) {  
        // 创建 ElectricCar 的对象  
        ElectricCar myCar = new ElectricCar();  
          
        // 调用 ElectricCar 的方法  
        myCar.move();  
        myCar.startEngine();  
        myCar.chargeBattery(); // 调用 ElectricCar 特有的方法  
    }  
}

7.final和abstract不能同时使用，final修饰的类不能被继承，final修饰的方法不能被重写

8.abstract修饰的方法不能被static修饰,static修饰的方法属于类

9.抽象方法不能使用private访问修饰符修饰

10.抽象类是有构造器的，但是它的构造器不能创建对象，构造器的目的是为了完成一些必要的初始化操作