How to create a subtype like relationship between two generic classes when the classes are generic related

Hello, everyone , I am Q！

It's like this ......

The screenshot of the conversation is as follows ：

Yes Q The explanation of , Are you with “ Ma Xiaotiao ” There are also questions ？ Please look

We all know that java in , As long as it is type compatible , You can assign objects of one type to objects of another type . For example, you can put a Integer Objects of type are assigned to Object Object of type , because Object yes Integer Superclass of .

Object someObject = new Object();
Integer someInteger = new Integer(10);
someObject = someInteger; //OK

In object orientation , We call it is a The relationship between . because Integer yes Object A seed of , So it is allowed to be assigned .

Again because Integer It's also Number A seed of , So the code below is also valid ：

public void someMethod(Number n) { /* ... */ }

someMethod(new Integer(10));   // OK
someMethod(new Double(10.1));   // OK

Of course, the same is true of generics , When executing a generic type call , take Number Pass as its type parameter , If the parameter is Number Subtypes of , Then any subsequent add call :

Box<Number> box = new Box<Number>();
box.add(new Integer(10));   // OK
box.add(new Double(10.1));  // OK

Now let's look at the following code ：

public void boxTest(Box<Number> n) { /* ... */ }

What type of parameters does the method receive ？

Through this method , You must know that its parameter type is Box<Number>, But let's think about a problem ： Do you think Box<Integer> and Box<Double> Can parameters of type be passed in ？

The answer is no Of .

Even though Integer yes Number Subtypes of , but Box<Integer> and Box<Double> No Box<Number> Subclasses of , Their parent objects are Object. This is what the dialogue at the beginning of the text means .

So here comes the question , When the generics of a class are related , How to create a subtype like relationship between two generic classes ？ For example, how to make Box<Integer> and Box<Double> Become with Box<Number> About ？

In order to understand this problem , Let's first understand how objects of the same type are subtyped .

By analyzing the source code, we can find that ：ArrayList<E> Realized List<E>,List<E> Inherited Collection<E>, therefore ArrayList<String> yes List<String> Subtypes of , List<String> yes Collection<String> Subtypes of . So when we pass parameters ,ArrayList<String> The type can give List<E> perhaps Collection<E> Delivered .

As long as you don't change the type parameter , The subtype relationship between types will remain .

If we want to define our own list interface PayloadList, Make generic types P The optional value of is associated with each element , It can be defined as follows ：

interface PayloadList<E,P> extends List<E> {
  void setPayload(int index, P val);
  ...
}

be PayloadList<String,String>、PayloadList<String,Integer>、PayloadList<String,Exception> All are List<String> Subtypes of .

Summary ： It can be subtyped by inheriting generic classes or implementing interfaces .

Understand the problem of subtype , We go back to “ How to create a subtype like relationship between two generic classes “ The problem of .

Generic classes or interfaces do not become relevant simply because of the relationship between their types , If you want to achieve the relevant , We can use wildcard To create relationships between generic classes or interfaces .

Box<Integer> and Box<Number> The parent object of is actually Box<?>

To create relationships between these classes , So that the code can pass Box<Integer> visit Box<Number> Methods , You can use the upper limit wildcard :

Box<? extends Integer> initBox = new Box<>();
Box<? extends Number> numberBox = initBox;
// OK. Box<? extends Integer> is a subtype of Box<? extends Number>

because Integer yes Number Subtypes of ,numberBox The generics of are Number Object subclasses , So in intBox and numberBox There is a relationship between .

The picture is for use ceiling and Lower limit The relationship between several classes declared by wildcards .