JAVA 抽象类介绍

弗瑞德学JAVA

于 2024-08-10 01:56:43 发布

阅读量620

点赞数 25

分类专栏： JAVA复习文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_37559642/article/details/141057802

版权

JAVA复习专栏收录该内容

58 篇文章 0 订阅

订阅专栏

抽象类

抽象类在Java中是一种特殊的类，用于表示概念的抽象，而不是具体的对象。抽象类不能被实例化，而是用作其他类的基类。这种设计允许开发者在类层次结构中定义一些通用的行为，同时将具体的实现推迟到子类。下面是对Java抽象类的详细介绍：

1.抽象类的定义

抽象类使用abstract关键字来声明，通常包含一个或多个抽象方法（即没有实现的方法）。这些抽象方法必须在子类中实现。抽象类可以包含已实现的方法（非抽象方法），字段，构造器等。

public abstract class Animal {
    // 抽象方法
    public abstract void eat();
    
    // 已实现的方法
    public void sleep() {
        System.out.println("Animal is sleeping");
    }
}

在上面的例子中，Animal类是一个抽象类，包含一个抽象方法eat()，以及一个已实现的方法sleep()。

2. 抽象类的特点

不能实例化：抽象类不能直接创建实例，必须通过子类来实例化。例如，Animal animal = new Animal();是不允许的。
抽象方法：抽象类可以包含一个或多个抽象方法。这些方法只定义了方法签名而没有实现，具体的实现由子类来提供。
非抽象方法：抽象类可以包含非抽象方法（即已实现的方法）。这些方法可以在子类中直接使用，也可以被子类覆盖。
构造器：抽象类可以包含构造器，虽然不能直接实例化抽象类，但子类在实例化时会调用抽象类的构造器以初始化对象的状态。
字段：抽象类可以包含字段（成员变量），这些字段可以被子类继承和使用。
继承：抽象类通常作为其他类的基类，子类通过继承抽象类来获得抽象类中定义的行为和状态。

3. 默认方法与接口多重继承

一个具体的类（非抽象类）如果继承了抽象类，必须实现所有的抽象方法，否则该类也必须被声明为抽象类。例如：

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // 输出：Dog is eating
        dog.sleep(); // 输出：Animal is sleeping
    }
}

在这个例子中，Dog类继承了Animal抽象类，并实现了抽象方法eat()。同时，它也继承了sleep()方法。

4. 抽象类与接口的区别

方法实现：
抽象类可以包含具体实现的方法，接口在Java 8之前则只能包含抽象方法（Java 8之后可以包含默认方法和静态方法）。
字段：
抽象类可以有实例变量（字段），而接口中的字段默认是public static final，即常量。
继承与实现：
一个类只能继承一个抽象类，但可以实现多个接口。这使得接口在需要多重继承时更加灵活。
构造器：
抽象类可以有构造器，而接口没有构造器。
适用场景：
抽象类用于表示一组具有共性行为的类，适合用来建模一类事物的抽象概念（如“动物”）。接口更适合表示一组可以独立实现的行为或能力（如“飞行”或“游泳”）。

5. 抽象类的使用场景

通用行为定义：当你有一组类，它们有一些共同的行为和状态，并且这些行为需要具体的实现时，抽象类是一个很好的选择。例如，Animal类可以定义所有动物的共同行为，如eat()和sleep()，而具体的动物如Dog和Cat则可以提供各自的实现。
模板方法模式：抽象类经常用于设计模式中，如模板方法模式（Template Method Pattern）。在这种模式中，抽象类定义算法的骨架，而将一些具体步骤推迟到子类中实现。

public abstract class Game {
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();

    // 模板方法
    public final void play() {
        initialize();
        startPlay();
        endPlay();
    }
}

public class Football extends Game {
    @Override
    void initialize() {
        System.out.println("Football Game Initialized!");
    }

    @Override
    void startPlay() {
        System.out.println("Football Game Started!");
    }

    @Override
    void endPlay() {
        System.out.println("Football Game Finished!");
    }
}

限制实例化：当你不希望某个类被实例化，而是希望它作为基类使用时，可以将其声明为抽象类。例如，如果你有一个Shape类，不希望直接创建Shape的实例，而是通过具体的子类如Circle或Rectangle来创建对象，那么可以将Shape定义为抽象类。

6. 抽象类的局限性

单一继承限制：由于Java只支持单一继承，一个类只能继承一个抽象类。如果需要实现多个不相关的行为，就无法通过继承抽象类来实现，而必须依赖接口。
强制性：抽象类要求子类必须实现所有抽象方法，这对有些情况下的灵活性会有所限制。
抽象类滥用：如果不合理地使用抽象类，可能会导致类层次结构过于复杂，增加维护难度。因此，开发者在设计时应权衡使用抽象类的必要性。

7. 抽象类的示例

public abstract class Vehicle {
    private String model;
    private int year;

    public Vehicle(String model, int year) {
        this.model = model;
        this.year = year;
    }

    public abstract void startEngine();

    public void stopEngine() {
        System.out.println("Engine stopped.");
    }

    public String getModel() {
        return model;
    }

    public int getYear() {
        return year;
    }
}

public class Car extends Vehicle {
    public Car(String model, int year) {
        super(model, year);
    }

    @Override
    public void startEngine() {
        System.out.println("Car engine started.");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car("Toyota", 2020);
        car.startEngine();  // 输出：Car engine started.
        car.stopEngine();   // 输出：Engine stopped.
        System.out.println(car.getModel());  // 输出：Toyota
    }
}