An issue with Generic type parameters and Inheritance

Question

Couldn't concretize the title, sorry for that.

For example, we have a Parent class and a Child class:

package test;

public class Parent {
}

package test;

public class Child extends Parent {
}

And a class that can contain Parent's child in its field called a:

package test;

public class Holder<A extends Parent> {
    public A a;
}

Let's create an instance of that class and try to assign a value to a:

package test;

public class Main {
    public static void main(String[] main) {
        Holder<Child> holder = new Holder<>();
        holder.a = new Child();
    }
}

So far, so good. But let's say we want to move this assignation to a Holder's constructor:

package test;

public class Holder<A extends Parent> {
    public A a;

    public Holder() {
        a = new Child();
    }
}

Now we're getting an error: Error:(7, 13) java: incompatible types: test.Child cannot be converted to A.

So, my question is, why doesn't the compiler see that A is a Parent's child? Even if we set <A extends Parent>. And why we can assign values outside of the class, but can't inside of it? Can I somehow fix this problem?

I know we can replace A with Parent and remove that type parameter or pass new Child() to constructor's parameters in Main, but it's because I'm giving a simplified example of the problem.

Keep in mind, that the type A in A extends Parent can be a different sub class like OtherChild. Then the assignment OtherChild a = new Child(); will not work, they are different classes (and they don't extend from each other). — Progman
– Progman, Commented Mar 19, 2022 at 12:32
The expression A extends Parent means that A is of an unknown type. The only constraint is that it must extend Parent. But that could also be true for other classe, e.g. class Brother extends Parent {}. — Seelenvirtuose
– Seelenvirtuose, Commented Mar 19, 2022 at 12:36
public A a; and public Parent a; are not the same thing. Like all generic type arguments, A is always a specific, exact type. That type might be Parent itself, or that type might be Child, or that type might be something else entirely. So you cannot safely assume that a can hold a Child instance, when A might be restricted to an entirely different type. — VGR
– VGR, Commented Mar 19, 2022 at 12:43

Alexander Ivanchenko · Accepted Answer · 2022-03-20 15:07:07Z

Bounded generic type parameters like A extends Something are not writable (as well upper-bounded wild cards ? extends Something). Any attempt to assign anything to the variable a apart from other variable of type A and null will fail.

In order to understand why, let's consider the following code:

public class Parent {}
public class Child extends Parent {}
public class GrandChild extends Child {}

public class Holder<A extends Parent> {
    public A a;

    public void setA(A a) {
        this.a = a;
    }
}

A in the Holder class is just a place-holder for the type that will be provided at runtime. It's a way to tell the compiler that we don't know for now what the type is. But it will be a particular type that has a Parent class in its inheritance chain. The compiler will take that information into account while checking whether the operations done on the variable a are safe.

In the code below, the compiler will disallow to assign an object of Child as a value for a, because it's incompatible with a type GrandChild (that happens to be the actual type for A). Only instances of GrandChild and its subtype can be assigned without issues.

public static void main(String[] args) {
    Holder<GrandChild> grandChildHolder = new Holder<>();

    grandChildHolder.setA(new GrandChild()); // no issues
    grandChildHolder.setA(new Child()); // compilation error
}

Similarly, the following assignments inside the Holder class will not succeed because type A will be known only Holder class will get instantiated. And compile doesn't possess information whether it'll be Child, GrandChild, etc., therefore it will not consider these operations to be safe.

public class Holder<A extends Parent> {
    public A a;
    // instance initialither block (runs when Holder object is being created)
    { 
        a = new Child(); // compilation error - type A could be a GrandChild
        a = new GrandChild(); // compilation error - type A could potentially be represented by class incompatible with GrandChild

        a = null; // no issues because null is a valid value for any type
    }

    public void setA(A a) {
        this.a = a;
    }
}

Upper-bounded generic parameters like A extends Parent are useful when want to make a class or method to be able to work with objects of different types and the same time impose a certain restriction on a range of the valid types in order to access the behavior of the Parent class (let's assume there are some like work(), goShoping(), etc.).

If you declare the holder without extends clause, just Holder<A> only methods of the Object class (hashCode(), equals(), toString()) will be accessible with variables and parameters of type A.

Also, clause extends Parent will allow the compiler to spot attempts to introduce an invalid type parameter:

Holder<String> stringHolder; // error: 
// type argument String is not within the bounds of type A

Abra · Accepted Answer · 2022-03-19 12:50:12Z

1

A is a [type] parameter. It's not an actual type. Like most classes, you could initialize the member via a parameter in the method constructor.

public class Main {

    public static void main(String[] args) {
        new Holder<Child>(new Child());
    }
}

class Parent {
    
}

class Child extends Parent {
    
}

class Holder<A extends Parent> {
    public A a;

    public Holder(A a) {
        this.a = a;
    }
}

answered Mar 19, 2022 at 12:50

Abra

21k14 gold badges102 silver badges74 bronze badges

Collectives™ on Stack Overflow

An issue with Generic type parameters and Inheritance

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related