Java 中抽象类中的构造函数

2024年9月10日 | 阅读 9 分钟

Java 中的抽象类是指不能直接实例化的类。它的目的是作为基类，其他类可以从中继承和扩展。抽象类的一个重要特性是它能够定义构造函数，构造函数是特殊的函数，在创建类对象时调用。

定义抽象类中的构造函数时应遵循的规则

抽象类可以有构造函数，但不能直接实例化。构造函数在创建具体子类时使用。
抽象类中可以有一个或多个抽象方法，这表示这些方法没有被类实现。要实例化一个具有抽象方法的抽象类的子类，必须实现这些方法。这意味着，如果子类需要成为一个具体的类并能够被实例化，那么在抽象类中声明的每个抽象方法都需要有一个实现。换句话说，抽象类留下的功能必须由子类来填充。
当子类扩展带有构造函数的抽象类时，子类需要使用 `super` 关键字调用超类中的某个构造函数。因为超类构造函数初始化对象的状态并设置任何必要的资源。如果子类没有调用超类中的某个构造函数，对象将不会被正确初始化，并且将无法有效地/正确地运行。
与任何其他类一样，可以在抽象类中定义多个构造函数。但是，每个构造函数都必须使用不同的参数列表进行定义。这允许子类根据其具体需求选择要调用的构造函数。

使用抽象类实现的构造函数类型

有三种类型的构造函数：

默认构造函数
参数化构造函数
复制构造函数

1. 默认构造函数： 如果类中没有定义其他构造函数，Java 会自动创建该构造函数。它没有参数，除了为类字段初始化默认值之外，不执行任何操作。

算法

步骤 1： 定义一个名为“Shape”的抽象类。

步骤 2： 将两个整数变量“x”和“y”声明为受保护 (protected)。

步骤 3： 创建 Shape 类的默认构造函数，并将“x”和“y”设置为 0。

步骤 4： 现在创建一个名为“getArea()”的方法，这是一个抽象方法，它将返回一个 double 值。

步骤 5： 然后创建两个非抽象方法“printPosition()”和“setPosition(int x, int y)”，它们属于 Shape 类。

步骤 6： `setPosition` 方法设置 x 和 y 的值。

步骤 7： `printPosition` 方法打印 x 和 y 的值。

步骤 8： 定义一个扩展 Shape 类的 Circle 类。

步骤 9： 在 Circle 类中声明一个名为“radius”的 double 变量，并将其声明为受保护 (protected)。

步骤 10： 为 Circle 类定义一个构造函数，该构造函数接受一个 double 值作为半径。

步骤 11： 为 Circle 类实现 getArea 方法，该方法计算圆的面积。

步骤 12： 定义一个扩展 Shape 类的 Square 类。

步骤 13： 在 Square 类中声明一个名为“side”的 double 变量，并将其声明为受保护 (protected)。

步骤 14： 为 Square 类定义一个构造函数，该构造函数接受一个 double 值作为边长。

步骤 15： 为 Square 类实现 getArea 方法，该方法计算正方形的面积。

步骤 16： 定义一个 Main 类。

步骤 17： 在 Main 类中定义 main 函数。

步骤 18： 创建一个 Circle 对象和一个 Square 对象。

步骤 19： 为 Circle 和 Square 对象调用 setPosition 方法。

步骤 20： 为 Circle 和 Square 对象调用 getArea 方法并打印结果。

步骤 21： 为 Circle 和 Square 对象调用 printPosition 方法并打印结果。

实施

以上步骤的实现如下：

文件名： DefaultMain.java

import java.util.*;
abstract class Shape {
    protected int x;
    protected int y;

    // default constructor
    public Shape() {
        // initialize default values for fields
        x = 0;
        y = 0;
    }

    // abstract method to calculate area
    public abstract double getArea();

    // other methods
    public void setPosition(int x,int y)
    {
        this.x=x;
        this.y=y;
    }

    public void printPosition() {
        System.out.println("The Position: ("+x + ", "+ y +")");
    }
}

class Circle extends Shape {
    protected double radius;

    // constructor
    public Circle(double radius) {
        this.radius=radius;
    }

    // implementation of getArea() for Circle
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class Square extends Shape {
    protected double side;

    // constructor
    public Square(double side) {
        this.side = side;
    }

    // implementation of getArea() for Square
    public double getArea() {
        return side * side;
    }
}

public class DefaultMain {
    public static void main(String args []) {
        // create a Circle object
        Circle circle = new Circle(5);
        circle.setPosition(2,3);

        // print the area and position of the Circle object
        System.out.println("Area of a circle is: "+circle.getArea());
        circle.printPosition();

        // create a Square object
        Square square = new Square(4);
        square.setPosition(5, 7);

        // print the area and position of the Square object
        System.out.println("Area of a square is: "+square.getArea());
        square.printPosition();
    }
}

输出

Area of a circle is: 78.53981633974483
The Position:(2, 3)
Area of a square is: 16.0
The Position:(5, 7)

2. 参数化构造函数： 创建对象时，此类型的构造函数允许您向其传递参数。当您希望使用值初始化对象时，它很有用。参数化构造函数定义了一个或多个参数，并且在创建对象时，传递给构造函数的值用于初始化对象的相应字段。

算法

步骤 1： 定义一个抽象类 Shape。

步骤 2： 添加两个名为 x 和 y 的 int 类型受保护 (protected) 实例变量。

步骤 3： 创建一个参数化构造函数，该构造函数初始化实例变量 x 和 y，并接受两个 int 类型的参数 x 和 y。

步骤 4： 定义一个抽象类 Shape。

步骤 5： 添加两个名为 x 和 y 的 int 类型受保护 (protected) 实例变量。

步骤 6： 创建一个参数化构造函数，该构造函数初始化实例变量 x 和 y，并接受两个 int 类型的参数 x 和 y。

步骤 7： 定义一个扩展 Shape 的 Circle 类。

步骤 8： 添加一个名为 radius 的 double 类型受保护 (protected) 实例变量。

步骤 9： 定义一个参数化构造函数，该构造函数接受三个 int 类型参数 x、y 和 double 类型 radius，并使用 super() 关键字初始化 x、y 和 radius 实例变量。

步骤 10： 通过计算 Circle 的面积来实现抽象方法 getArea()。

步骤 11： 定义一个扩展 Shape 的 Square 类。

步骤 12： 添加一个名为 side 的 double 类型受保护 (protected) 实例变量。

步骤 13： 定义一个参数化构造函数，该构造函数接受三个 int 类型参数 x、y 和 double 类型 side，并使用 super() 关键字初始化 x、y 和 side 实例变量。

步骤 14： 通过计算 Square 的面积来实现抽象方法 getArea()。

步骤 15： 定义一个 Main 类。

步骤 16： 定义一个名为 main() 的静态方法，它是程序的入口点。

步骤 17： 使用参数化构造函数创建一个 Circle 对象。

步骤 18： 分别使用 getArea() 和 printPosition() 方法打印 Circle 对象的面积和位置。

步骤 19： 使用参数化构造函数创建一个 Square 对象。

步骤 20： 分别使用 getArea() 和 printPosition() 方法打印 Square 对象的面积和位置。

步骤 21： 程序结束。

实施

上面提到的步骤的实现如下

文件名： ParameterizedMain.java

import java.util.*;
abstract class Shape {
    protected int x;
    protected int y;

    // parameterized constructor
    public Shape(int x,int y) {
        this.x=x;
        this.y=y;
    }

    // abstract method to calculate area
    public abstract double getArea();

    // other methods
    public void setPosition(int x,int y) {
        this.x=x;
        this.y=y;
    }

    public void printPosition() {
        System.out.println("The position: ("+ x+", " +y+")");
    }
}

class Circle extends Shape {
    protected double radius;

    // parameterized constructor
    public Circle(int x,int y,double radius) {
        super(x,y);
        this.radius=radius;
    }

    // implementation of getArea() for Circle
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class Square extends Shape {
    protected double side;

    // parameterized constructor
    public Square(int x,int y,double side) {
        super(x, y);
        this.side = side;
    }

    // implementation of getArea() for Square
    public double getArea() {
        return side * side;
    }
}

public class ParameterizedMain {
    public static void main(String args []) {
        // create a Circle object with parameterized constructor
        Circle circle = new Circle(2, 3, 5);

        // print the area and position of the Circle object
        System.out.println("Area of circle is: "+circle.getArea());
        circle.printPosition();

        // create a Square object with parameterized constructor
        Square square = new Square(5, 7, 4);

        // print the area and position of the Square object
        System.out.println("Area of square is:" +square.getArea());
        square.printPosition();
    }
}

输出

Area of circle is: 78.53981633974483
The position: (2, 3)
Area of square is:16.0
The position: (5, 7)

3. 复制构造函数： 复制构造函数用于创建一个具有与现有对象相同值的新对象（即，对象已提前创建）。当我们想创建一个现有对象副本的新对象时，它很有用。复制构造函数仅用一个参数或一个参数进行定义，该参数是同一类的对象。然后，构造函数创建一个具有与参数对象相同值的新对象。

算法

步骤 1： 声明一个带有实例变量和默认构造函数的抽象类。

步骤 2： 定义一个带有同一类类型参数的复制构造函数。

步骤 3： 在复制构造函数中，使用 super 关键字调用超类复制构造函数，将实例变量从参数对象复制到新对象。

步骤 4： 将子类中任何其他实例变量的值分配给新对象。

步骤 5： 实现用于计算面积的抽象方法。

步骤 6： 根据需要定义任何其他方法。

步骤 7： 在 main 函数中，创建一个类的对象。

步骤 8：根据需要设置位置和任何其他实例变量。

步骤 9： 使用复制构造函数创建一个新对象，并将原始对象作为参数传递。

步骤 10： 打印原始对象和复制对象的面积和位置。

实施

上面步骤的实现如下

文件名： CopyMain.java

import java.util.*;
abstract class Shape {
    protected int x;
    protected int y;

    // copy constructor
    public Shape(Shape other) {
        this.x=other.x;
        this.y=other.y;
    }

    // default constructor
    public Shape() {
        // initialize default values for fields
        x=0;
        y=0;
    }

    // abstract method to calculate area
    public abstract double getArea();

    // other methods
    public void setPosition(int x,int y) {
        this.x =x;
        this.y =y;
    }

    public void printPosition() {
        System.out.println("Position: (" +x+ ", " +y+ ")");
    }
}

class Circle extends Shape {
    protected double radius;

    // copy constructor
    public Circle(Circle other) {
        super(other);
        this.radius =other.radius;
    }

    // constructor
    public Circle(double radius) {
        this.radius =radius;
    }

    // implementation of getArea() for Circle
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class Square extends Shape {
    protected double side;

    // copy constructor
    public Square(Square other) {
        super(other);
        this.side =other.side;
    }

    // constructor
    public Square(double side) {
        this.side=side;
    }

    // implementation of getArea() for Square
    public double getArea() {
        return side * side;
    }
}

public class CopyMain {
    public static void main(String[] args) {
        // create a Circle object
        Circle circle1 = new Circle(5);
        circle1.setPosition(2,3);

        // create a copy of the Circle object using the copy constructor
        Circle circle2 = new Circle(circle1);

        // print the area and position of the original and copied Circle objects
        System.out.println("Original Area of circle: " +circle1.getArea());
        circle1.printPosition();
        System.out.println("Copied Area of circle: "+circle2.getArea());
        circle2.printPosition();

        // create a Square object
        Square square1 =new Square(4);
        square1.setPosition(5,7);

        // create a copy of the Square object using the copy constructor
        Square square2 = new Square(square1);

        // print the area and position of the original and copied Square objects
        System.out.println("Original Area of square: "+square1.getArea());
        square1.printPosition();
        System.out.println("Copied Area of square: "+square2.getArea());
        square2.printPosition();
    }
}

输出

Original Area of circle: 78.53981633974483
Position: (2, 3)
Copied Area of circle: 78.53981633974483
Position: (2, 3)
Original Area of square: 16.0
Position: (5, 7)
Copied Area of square: 16.0
Position: (5, 7)

下一个主题Java 中类对象数量的计算

Java 中抽象类中的构造函数

定义抽象类中的构造函数时应遵循的规则

使用抽象类实现的构造函数类型

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中抽象类中的构造函数

定义抽象类中的构造函数时应遵循的规则

使用抽象类实现的构造函数类型

相关帖子

Exam Seating Arrangement in Java

Java 中不同类型的递归

Java IP 地址 (IPv4) 正则表达式示例

JapaneseChronology prolepticYear() method in Java with Example

Session Tracking in Java

Java 中的 java.util.function.DoublePredicate 接口及示例

Merge Sort in Java

Java Editors

Java 中的 FloatBuffer rewind() 方法及示例

Java 中的注释类型

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器