java - 为什么我需要抽象类中的构造函数？

Question

我目前正在学习 Java 教程，其中向我介绍了抽象类并使用 J-Unit 进行测试。

我有 2 个文件，AthleteTest 和 BikerTest，其中 BikerTest 扩展了 AthleteTest。AthleteTest 包含我的不同测试的常用方法和变量，而 BikerTest 包含细节。

运动员测试

import static org.junit.Assert.*;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;


public abstract class AthleteTest 
{
    private Athlete a1;
    private Athlete a2;
    protected String _name = "Test Athlete";
    protected int _age = 32;
    protected int _racerId = 987654;

    public abstract Athlete getAthlete();
    public abstract Athlete getExplicitAthlete();

    public AthleteTest()
    {
        a1 = getAthlete();
        a2 = getExplicitAthlete();
    }

    @Before
    public void setUp() throws Exception {
    }

    @After
    public void tearDown() throws Exception {
    }

    @Test
    public void testConstructors()
    {
        assertNotNull("Default Runner could not be created", a1);
        assertNotNull("Explicit Runner could not be created", a2);
        assertEquals("Name not set correctly on a2"
                        , _name
                        , a2.getName());
        assertEquals("Age not set correctly on a2"
                        , _age
                        , a2.getAge());
        assertEquals("RacerID not set correctly on a2"
                        , _racerId
                        , a2.getRacerId());
    }

    @Test
    public void testGetSetName()
    {
        a1.setName(_name);
        assertEquals("The name could not be set as expected"
                        , _name
                        , a1.getName());
    }

    @Test
    public void testGetSetAge()
    {
        a1.setAge(_age);
        assertEquals("The age could not be set as expected"
                        , _age
                        , a1.getAge());
    }

    @Test
    public void testGetSetRacerId()
    {
        a1.setRacerId(_racerId);
        assertEquals("The racerId could not be set as expected"
                        , _racerId
                        , a1.getRacerId());
    }

    public abstract void testPerformRaceActivity();

    @Test
    public void testToString()
    {
        a1.setName(_name);
        a1.setAge(_age);
        a1.setRacerId(_racerId);
        String rts = a1.toString();
        assertTrue("To String does not contain name"
                    , rts.contains(_name));
        assertTrue("To String does not contain age"
                    , rts.contains(String.format("%d", _age)));
        assertTrue("To String does not contain racer id"
                    , rts.contains(String.format("%d", _racerId)));
        String rc = a1.getClass().toString();
        assertTrue("To String does not contain class"
                    , rts.contains(rc));

    }

}

自行车测试

import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;


public class BikerTest extends AthleteTest
{
    private Biker r;
    private String raceActivity = "Biking";
    private boolean usesClips = false;

    @Override
    public Athlete getAthlete() {
        return new Biker();
    }

    @Override
    public Athlete getExplicitAthlete() {
        return new Biker(_name,_age,_racerId,usesClips);
    }


    @Before
    public void setUp()
    {
        r = new Biker();
    }

    @After
    public void tearDown()
    {
        r = null;
    }

    @Test
    public void testConstructors()
    {
        super.testConstructors();
        Biker r2 = new Biker(_name, _age, _racerId, usesClips);
        assertNotNull("Explicit Biker could not be created", r2);
        assertEquals("Name not set correctly on R2"
                        , _name
                        , r2.getName());
        assertEquals("Age not set correctly on R2"
                        , _age
                        , r2.getAge());
        assertEquals("RacerID not set correctly on R2"
                        , _racerId
                        , r2.getRacerId());
        assertEquals("UsesClips not set correctly on R2"
                , usesClips
                , r2.getUsingClips());
    }


    @Test
    public void testGetSetUsingClips()
    {
        r.setUsingClips(usesClips);
        assertEquals("The clips could not be set as expected"
                        , usesClips
                        , r.getUsingClips());
    }

    @Test
    public void testPerformRaceActivity()
    {
        String pra = r.performRaceActivity();
        assertTrue("Perform race activity did not contain activity"
                        , pra.contains(raceActivity));
    }

    @Test
    public void testToString()
    {
        super.testToString();
        r.setName(_name);
        r.setAge(_age);
        r.setRacerId(_racerId);
        r.setUsingClips(usesClips);
        String rts = r.toString();
        assertTrue("To String does not contain using clips"
                , rts.contains(String.format("%b", usesClips)));
        assertTrue("To string does not contain performRaceActivity"
                    , rts.contains(raceActivity));

    }



}

现在，虽然我的文件和代码正在运行(它取自所提供的示例)，但我无法弄清楚为什么它会运行，因为教程没有详细介绍如何执行测试。

QN1为什么在抽象类 AthleteTest 中需要构造函数？我的理解是，因为它是抽象的，所以不会被实例化，因此不需要构造函数，因为构造函数仅在类被实例化时发挥作用。

QN2测试是如何完成的；测试顺序是什么样的？例如，当我运行 BikerTest 时，虽然我重写了 GetAthlete 和 GetExplicitAthlete 类，但我实际上并没有运行代码中的方法。然而，为什么当我运行代码时，方法却运行了。默认情况下，JUnit 是否只运行所有方法？

QN3当我运行 BikerTest 时，父类(super class) AthleteTest 是如何实例化和工作的？例如，在 BikerTest 中，我调用了 super - 这是 AthleteTest。AthleteTest 是在我调用 super 时实例化/创建的 - 结果对象存储在 a1 和 a2 中，或者它是在某时某处创建的还有吗？

提前感谢您提供的任何澄清和解释!

Answer 1

Why do i need a constructor in the abstract class AthleteTest?My understanding is that because it is abstract, it will not be instantiated

没错。抽象类不能被实例化。虽然，这并不意味着抽象类不能有构造函数。如果您不向类添加构造函数，编译器将为您添加一个默认的无参数构造函数。对于抽象类也是如此。此外，Java 中的每个构造函数都有一个隐式 super() 调用，因为它在第一行调用父类的构造函数(包括编译器添加的默认构造函数)。在您的示例中，BikerTest 没有显式构造函数。因此，编译器会将以下构造函数添加到 BikerTest 类:

public BikerTest() {
    super();
}

只要您运行 BikerTest JUnit 类，JUnit 就会创建一个 BikerTest 类的实例，并且BikerTest 构造函数中的 super() 调用将导致调用 AthleteTest 类的构造函数。

For example,when i run BikerTest, while i override the GetAthlete and GetExplicitAthlete classes, i do not actually run the methods in the code.Yet why is it when i run the code, the methods are run

如前所述，BikerTest 中的 super() 调用导致调用 AtheleteTest 类的无参数构造函数。 AtheleteTest 类调用 getAthlete() 和 getExplicitAthlete() 方法。虽然这些方法是抽象的，但它们已在 BikerTest 类中被覆盖。 BikerTest 类中的方法将被调用，因为创建的对象属于 BikerTest

类

How is the superclass AthleteTest instantiated and work when i run BikerTest? For example, in BikerTest, i made calls to super - which is AthleteTest.Is AthleteTest instantiated/ created at the point when i make a call to super - and the resulting object is stored in a1 & a2, or is it created somewhen and somewhere else?

没有。使用 super 调用方法或使用 super 访问字段不会导致父类(super class)被实例化(无论它是否是抽象的)。 r 变量在 setUp 方法中分配了一个对象，这是 JUnit 在运行任何测试之前调用的第一个方法。 a1 和 a2 变量在 BikerTest 被实例化并且 AtheleteTest 无参数构造函数被调用时被分配一个对象(如前所述)