CODEWITHSUNDEEP
java
user1505713
user1505713

Reputation: 607

Polymorphism: Least cumbersome way to assign data fields?

I'm currently taking a Java course and have a question about polymorphism.

Given

public class A {

    private int a1;

    public A(){}
    public A(int a1) { this.a1 = a1;}

}

class B extends A {

    private int b1;

    public B() {}
    public B(int b1, int a1) {

    super(a1);
    this.b1 = b1;


    }
}

class C extends B {

    private int c1;

    public C(){}
    public C(int c1, int b1, int a1) {

    super(b1, a1);
    this.c1 = c1;

    }

}

What would be the best way to assign to fields a1, b1, and c1, all in one swoop? My first guess would be to make an instance of C and call its three-arg constructor.

But what happens when each class contains 10s or 100s of data fields? Wouldn't this approach mean calling constructors with huge numbers of arguments, like

C(arg1, arg2, ..., arg100), setting k of C's fields, then making a call to

B(arg1, arg2, ..., arg100-k), and so on,

all the way up to the top? Is there a better way to proceed?

Upvotes: 2

Views: 48

Answers (3)

ehargitt
ehargitt

Reputation: 91

What you're suggesting would work if you set the class fields to public. Class C will have a1 and c1, but won't be able to access them due to them being private.

Upvotes: -1

Hiro2k
Hiro2k

Reputation: 5587

Not in this particular case because the fields in the parent classes are declared private.

If they were protected then you could set all 3 of them from the class C constructor. However this breaks encapsulation because if the constructor for B did something else after the value was assigned you'd have to duplicate that logic in C in order to not violate it's contract, and as you can imagine that gets very messy when you have more constructors or parent classes in the type tree.

Having multiple calls chained in the manner you proposed is the safest way at the cost of having to call all those constructors up the chain. I'd recommend profiling your code to see if this is actually a problem and not just a premature optimization.

Upvotes: 0

Tassos Bassoukos
Tassos Bassoukos

Reputation: 16152

Having so many parameters is a definite code smell; in all probability you want to split the object up into smaller self-contained objects and/or or collections.

On the other hand, there is the Builder pattern, where you use a helper class to set all the parameters and it constructs the object for you, possibly sanity-checking that all required fields are set and there are no conflicts.

Upvotes: 4

Related Questions