Java中的父/子构造函数

Question

I keep getting this error required:boolean; found:no arguments; reason:actual and formal arguments lists differ in length;

I know why this is, because my constructor in my superclass and subclass don't match...but i dont want to make changes to them if possible because it'll ruin the rest of my other classes and if i do need to make changes i'd rather just make changes to the LowRights class. Could someone point me in the right direction?

public class LowRights extends SecurityRights
{
    private String name;

    public LowRights(String n){
        this.name = n;
        boolean right = getRight(); // Added
        setRight(false); // Added
    }

    public boolean setRight(boolean right){
        return right;
    }

    public String getName(){
        return name;
    }

    public static void main(String[] a){
    LowRights s= new LowRights("Lisa");
    System.out.print(s.getName() +" "+s.getSecret());                
  }

}

This is my super class:

public class SecurityRights
{
private boolean right;
private boolean canreadSecret;
String SECRET="the secret is 42";



public SecurityRights(boolean r)
{
 r = right;
 if (r) canreadSecret=true; else canreadSecret=false;
}

boolean getRight(){
 return right;
}

boolean canReadSecret(){
 return canreadSecret;
}

String getSecret(){
 if (canreadSecret) return SECRET; else return "access denied";
}

}

Answer 1

You need for sure make one change. Easier will be to add as the first instruction in your child class this:

super(false);

or:

super(true);

depending in what makes sense for you.

By the way, in your parent's constructor you have this:

r = right;

but it should be:

right = r;

Otherwise, you are discarding the value passed in the constructor.

Answer 2

In a child-class constructor, a call to a parent-class constructor is always the first line. Even if you don't write it, it's there. So your code actually looks like this:

public LowRights(String n){
        super(); //implied no-args parent-class constructor
        this.name = n;
        boolean right = getRight(); // Added
        setRight(false); // Added
}

The problem is that your parent-class doesn't have a no-args constructor. You have to give it a boolean. How you determine that boolean is up to you. This would pass in false:

public LowRights(String n){
        super(false); //calls the parent-class constructor
        this.name = n;
        boolean right = getRight(); // Added
        setRight(false); // Added
}

This is just a generic example, because a lot of your code doesn't make sense. Your parent-class constructor doesn't actually set the value of the right boolean, for example.

Answer 3

According to documentation :

If a constructor does not explicitly invoke a superclass constructor, the Java compiler automatically inserts a call to the no-argument constructor of the superclass. If the super class does not have a no-argument constructor, you will get a compile-time error. Object does have such a constructor, so if Object is the only superclass, there is no problem.

The less impact way would be defining a default value to right attribute on super class:

public SecurityRights() {
    this(true);
}

Answer 4

LowRights needs to call super(right); or SecurityRights needs to add another constructor.

Child classes need to call thier parent constructors.

Answer 5

public LowRights(String n) {
    super(false) 
    ... <your sub class constructor code>
}

Answer 6

The error occurs, because the constructor LowRights(String n) calls the default constructor of SecurityRights (Java adds super() as the first line of the constructor if it is not specified what parent constructor to call). But there is no default constructor in SecurityRights. Default constructor is a constructor without arguments: SecurityRights(). So you can add the default constructor to the SecurityRights class or to specify what constructor has to be called in LowRights: super(true).

Answer 7

each class when is being created always calls constructor of its superclass,
in your example

 public LowRights(String n){
            this.name = n;
...}

you were actually calling default constructor super() which doesn't exist in your superclass

so you need to add call to existing constructor, and as you want to set right to be false, add call super(false) then this line setRight(false); is not needed anymore

Answer 8

Java adds super() as first line of every constructor if no superclass constructor was added explicitly (every class in Java silently inherits from Object class and it has only one, no-arg constructor).

SecurityRights class does not offer no-arg constructor - thats why you're getting this error.

You can either add no-arg constructor to SecurityRights class or add superconstructor call with boolean argument to LowRights(String n) constructor.

public LowRights(String n) {
   super(true) 
   ...
}