13. 抽象类(abstract关键字)

发布时间:2024年01月14日

抽象类

抽象类是在面向对象编程中,一种特殊的类,它不能被实例化,只能作为其他类的基类来使用。

抽象类和普通类的主要区别在于它包含一个或多个抽象方法。

1. 抽象类

抽象类是面向对象编程中的一个概念,它是一种特殊的类,不能被实例化,只能被用作其他类的基类来继承并实现其抽象方法。

1.1 定义格式

定义格式:

abstract class 类名字 { 
  
}

代码举例:

public abstract class Animal {
    public abstract void run()}

抽象类的定义包括:

  1. 抽象类通过关键字 abstract 进行声明。

  2. 抽象类可以包含抽象方法和具体方法。

  3. 抽象方法是一种只有声明而没有实现的方法,需要被子类重写来实现具体的逻辑。

  4. 抽象类可以包含成员变量和成员方法,这些成员变量和成员方法可以被子类继承。

注意:抽象类不一定有抽象方法,但是有抽象方法的类必须定义成抽象类。

示例:

abstract class Shape {
    protected String color; // 颜色属性

    public Shape(String color) {
        this.color = color;
    }

    public abstract void draw(); // 抽象方法,用于绘制形状

    public void setColor(String color) {
        this.color = color;
    }
}

class Circle extends Shape {
    private double radius; // 半径属性

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
	@Override
    public void draw() {
        System.out.println("Drawing a circle with radius " + radius + " and color " + color); // 绘制圆形
    }
}

class Rectangle extends Shape {
    private double width; // 宽度属性
    private double height; // 高度属性

    public Rectangle(String color, double width, double height) {
        super(color);
        this.width = width;
        this.height = height;
    }
	@Override
    public void draw() {
        System.out.println("Drawing a rectangle with width " + width + ", height " + height + " and color " + color); // 绘制矩形
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle("Red", 5.0); // 创建一个红色的半径为5的圆形对象
        circle.draw();

        Shape rectangle = new Rectangle("Blue", 3.0, 4.0); // 创建一个蓝色的宽度为3,高度为4的矩形对象
        rectangle.draw();
    }
}

在上述示例中,Shape 是一个抽象类,它包含一个抽象方法 draw(),并具有一个成员变量 color 和一个具体方法 setColor()CircleRectangle 都是 Shape 的子类,它们都必须实现抽象方法 draw()。在 Main 类中,我们可以创建 CircleRectangle 的对象,并调用它们的 draw() 方法来进行绘制。由于抽象类不能被实例化,我们只能创建其子类的实例,并通过多态性来使用抽象类。

1.2 特点

抽象类(Abstract Class)是一种特殊的类,它不能被实例化,只能被继承。

它主要的特点包括:

  1. 抽象类不能创建对象,如果创建,编译无法通过而报错。只能创建其非抽象子类的对象。

    理解:假设创建了抽象类的对象,调用抽象的方法,而抽象方法没有具体的方法体,没有意义。

  2. 抽象类中,可以有构造方法,是供子类创建对象时,初始化父类成员使用的。

    理解:子类的构造方法中,有默认的super(),需要访问父类构造方法。

  3. 抽象类中,不一定包含抽象方法,但是有抽象方法的类必定是抽象类。

    理解:未包含抽象方法的抽象类,目的就是不想让调用者创建该类对象,通常用于某些特殊的类结构设计。

  4. 抽象类的子类,必须重写抽象父类中所有的抽象方法,否则子类也必须定义成抽象类,编译无法通过而报错。

    理解:假设不重写所有抽象方法,则类中可能包含抽象方法。那么创建对象后,调用抽象的方法,没有意义。

  5. 抽象类存在的意义是为了被子类继承。

    理解:抽象类中已经实现的是模板中确定的成员,抽象类不确定如何实现的定义成抽象方法,交给具体的子类去实现。

  6. 抽象类不能用 final 声明。

    理解:因为抽象类必须被子类继承。

  7. 非抽象方法包含方法体,可以直接使用或重写(Override)。

    理解:抽象类中可以包含非抽象方法,这些方法拥有方法体,可以直接调用使用。同时,子类也可以通过继承抽象类来继承这些非抽象方法,并且可以在子类中重写这些方法,从而实现子类对象对这些方法的调用。

    抽象类主要的作用是用来设计和组织一个类的具体子类,它定义了一个抽象的概念,而不是一个具体的实现。当需要实现该概念时,可以继承抽象类并实现它的抽象方法。

2. 抽象方法

抽象方法是在抽象类中声明但没有具体实现的方法。

它只有方法签名,没有方法体。抽象类中可以包含一个或多个抽象方法。

抽象方法通过使用关键字 abstract 来声明,在方法签名中只指定方法的名称、参数列表和返回类型,不包含具体的方法实现。具体的方法实现由继承抽象类的子类来提供。

2.1 定义格式

使用abstract 关键字修饰方法,该方法就成了抽象方法,抽象方法只包含一个方法名,而没有方法体。

定义格式:

修饰符 abstract 返回值类型 方法名 (参数列表)

例如:

public abstract void run()

2.2 特点

抽象方法的主要特点包括:

  • 抽象方法没有具体的实现,继承抽象类的子类必须实现这些抽象方法,并提供具体的实现逻辑。

  • 抽象方法不能被声明为 private,final,static 或 strictfp,因为这些关键字会和抽象方法的特性相冲突。

下面是一个示例,展示了一个抽象类 Animal 和它的子类 Cat 和 Dog 的使用:

abstract class Animal {
    public abstract void makeSound();  // 抽象方法,动物发出声音

    public void sleep() {
        System.out.println("Animal is sleeping");  // 非抽象方法,动物睡觉
    }
}

class Cat extends Animal {
    public void makeSound() {
        System.out.println("Meow");  // 实现抽象方法,猫发出声音
    }
}

class Dog extends Animal {
    public void makeSound() {
        System.out.println("Woof");  // 实现抽象方法,狗发出声音
    }
}

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.makeSound();  // 输出 "Meow"
        cat.sleep();  // 输出 "Animal is sleeping"

        Dog dog = new Dog();
        dog.makeSound();  // 输出 "Woof"
        dog.sleep();  // 输出 "Animal is sleeping"
    }
}

在上面的例子中,Animal 抽象类声明了一个抽象方法 makeSound(),所有继承 Animal 抽象类的子类都必须实现 makeSound() 方法。在 Cat 子类和 Dog 子类中分别实现了 makeSound() 方法,提供了具体的猫和狗发出声音的逻辑。通过创建 Cat 和 Dog 对象来调用 makeSound() 方法来输出相应的声音。抽象类 Animal 中的 sleep() 方法不是抽象方法,它有具体的实现。

3. abstract关键字

  1. 抽象类 (Abstract Class) :使用 abstract 关键字声明的类就是抽象类,它不能被实例化,只能被继承。

    声明抽象类:

    abstract class ClassName {
        // 抽象类的成员
    }
    
    • 使用 abstract 关键字来修饰类名,表示该类是一个抽象类。

    • 抽象类可以包含成员变量、非抽象方法和抽象方法。

  2. 抽象方法 (Abstract Method) :使用 abstract 关键字声明的方法就是抽象方法,它只有方法头(签名),没有方法体。

    声明抽象方法:

    abstract returnType methodName(parameters);
    
    • 使用 abstract 关键字来修饰方法,表示该方法是一个抽象方法。

    • 在方法的声明中只有方法的返回类型、方法名和参数列表,没有方法体(即没有具体的实现)。

    • 抽象方法必须被声明在抽象类中。

注意】:

  • 对于抽象类来说,它可以包含非抽象方法和抽象方法,但一个类只有包含至少一个抽象方法时才需要被声明为抽象类。

  • 对于抽象方法来说,它不能被声明为 private 或 final,因为私有方法无法被继承和重写,而 final 方法无法被重写。

  • 抽象类和抽象方法都不能被实例化或直接调用,抽象类只能被继承。

  • 抽象方法只有方法头,没有方法体。抽象方法相当于一个约定,必须在子类中实现具体的方法体。

  • 如果一个类继承了抽象类,那么它必须实现抽象类中的所有抽象方法,除非它自己也是抽象类。

  • 如果一个子类继承了抽象类,可以选择性地重写非抽象方法。

文章来源:https://blog.csdn.net/kuxiaoyang/article/details/135584666
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。