Question

如何在一个包中调用基类的构造函数，该包具有来自另一个包中派生的访问修饰符？像这样：包含派生类的包：

package MainPack;
import mypack.Checker;
import java.util.Scanner;
public class Start
{
    public static void main(String[] args)
    {
        BeginCheck bc=new BeginCheck();
    }
}
class BeginCheck extends Checker
{   
     BeginCheck()
    {
        System.out.print("Enter a String to Check: ");
        super(new Scanner(System.in).nextLine()); //I want to call it like this
    }
}

包含基类的包：

package mypack;
public class Checker
{
    String s;
    protected Checker()
    {
    }
    protected Checker(String s)
    {
        s=this.s;
    }

}

Answer 1

BeginCheck()
{
    System.out.print("Enter a String to Check: ");
    super(new Scanner(System.in).nextLine()); //I want to call it like this
}

对超级构造函数的调用必须是每个构造函数中的第一行。除非您正在调用默认构造函数，否则您可以省略调用，它将由编译器推断。

BeginCheck() {
    super( new Scanner( System.in ).nextLine() );
}

你真的不应该在构造函数中做User IO。它应保留为仅将对象初始化为可用状态。

Answer 2

首先 - 您不应该使用构造函数来执行I / O.这是一个糟糕的形式。

以下是JLS要求super()调用成为子类中第一个语句的原因示例＆＃39;构造函数。

class Gradient {
    public final Color start;
    public final Color end;

    protected void blendTo(Color c1, Color c2, double BlendStart,
            double blendEnd) {
        // method to draw gradient blend
    }

    public Gradient(Color start, Color end) {
        if (start == null || end == null) {
            throw new IllegalArgumentException("No parameters can be null.");
        }

        this.start = start;
        this.end = end;

        blendTo(this.start, this.end, 0.0, 1.0);
    }
}

class ThreeGradient extends Gradient {
    public final Color middle;

    // This is invalid Java code
    public ThreeGradient(Color start, Color end, Color middle) {
        this.middle = middle;

        blendTo(this.start, this.middle, 0.0, 0.5); // If this were valid, it
                                                    // would attempt to use
        blendTo(this.middle, this.end, 0.5, 1.0);   // this.start and this.end
                                                    // before initialization.
        super(start, end);
    }
}

您可以看到ThreeGradient取决于其内部Gradient内的数据，因为它应该能够实现。如果其父Gradient未初始化，则无法正常运行。这是一个假设的讨论，因为Java中不允许这样做。

使用super关键字从不同的包调用基类的受保护构造函数

2 个答案: