How to make type safety with generics?

Question

I have the class

public class ReportItem<ReportType extends Report>{ }

and the class

public abstract class Report implements Iterable<ReportItem>{

    private List<ReportItem<? extends Report> > itemList;

    public void add(ReportItem<? extends Report> item){
        itemList.add(item);
    }

    //Some other staff

}

public class ConcreteReport extends Report{ 
    //Some staff
}

The thing is the method add(ReportItem<? extends Report>) is unsafe in the way I could provide items aren't tied with the current report, but tied with some another and the compiler won't complain.

Is it possible to write the method add in a type-safe way, i.e. we could pass as an argument only that ReportItem<T> where T is the type of a current report.

EpicPandaForce · Accepted Answer · 2015-06-03T10:23:27.387

4

I think you are looking for the following.

public abstract class Report<T extends Report<T>> implements Iterable<ReportItem<T>>{

    private List<ReportItem<T>> itemList;

    public void add(ReportItem<T> item){
        itemList.add(item);
    }

    //Some other stuff

}

public class ConcreteReport extends Report<ConcreteReport> { 
    //Some stuff
}

The way it works is that:

You want to parametrize ReportItem<T> with something that extends from Report
You want to make sure that the list of ReportItem<T> all belong to the same type of Report

In order to bind the T parameter of ReportItem<T> to something that extends from Report, you need to parametrize the Report itself:

public abstract class Report<T> implements Iterable<ReportItem<T>>

you add the bind that it needs to extend from Report

public abstract class Report<T extends Report> implements Iterable<ReportItem<T>>

But you are specifying the bound for the raw type of report, which doesn't work, so you need to provide Report with the type parameter that the report receives, which is T.

public abstract class Report<T extends Report<T>> implements Iterable<ReportItem<T>>

This way you can parametrize the List<ReportItem<T>> with the concrete type that you extend with:

public class ConcreteReport extends Report<ConcreteReport> {

This way the list will be

public List<ReportItem<ConcreteReport>> itemlist;

Which is what you wanted.

And it works! :) I just hope my explanation of it makes sense.

edited Jun 03 '15 at 10:23

answered Jun 03 '15 at 10:03

EpicPandaForce

79,669
27
256
428

2

ReportType is a Type parameter – user3663882 Jun 03 '15 at 10:04
Okay, check now. I think this should be what you want. – EpicPandaForce Jun 03 '15 at 10:10
1

Wokrs perfect now. But the declaration `Report>` looks a little sophisticated. Couldn't you give a little explanation? – user3663882 Jun 03 '15 at 10:17
Sure can, although if it works, don't forget to tick the tick on the top left :D I'll edit it into the post. – EpicPandaForce Jun 03 '15 at 10:18
1

Tahnk for the explanation. Got that. – user3663882 Jun 03 '15 at 13:14
@newacct It says for me for `public abstract class Report implements Iterable>{` that "type parameter `T` is not in bound, should extend `Report`", you should try it in an IDE – EpicPandaForce Jun 03 '15 at 19:20
1

@EpicPandaForce: Oh I forgot, it's needed when you have two types. – newacct Jun 03 '15 at 20:34
@newacct yeah, it's because the `ReportItem` needs `T` to be bound to `Report` – EpicPandaForce Jun 04 '15 at 07:11

How to make type safety with generics?

1 Answers1

Linked