Enrol to start learning
Reading is open to everyone. Enrolling is free, and it is what unlocks the audio lessons, practice tests and progress tracking.
15.10. Wildcards in Generics
Learn content
Interactive Audio Lesson
Unlock the classroom podcast
The transcript is free to read. A free account plays the conversation back.
Let's start with unbounded wildcards, denoted by <?>. Can anyone tell me when we would use an unbounded wildcard?
Is it for when we're not really sure what type we're going to deal with?
Exactly! It provides flexibility when you don't need to specify a type. It allows any type of object. For example, a method that accepts a List<?> can be called with any type of list.
Could we use it if we need to process a collection regardless of type?
Yes, that's right! For example, you might want to print all elements in a list regardless of their type. You can iterate through a List<?> safely.
Could you give a coding example of that?
Sure! Here’s a simple method that takes in a List<?> and prints out its elements: public void printList(List<?> list) { for (Object obj : list) System.out.println(obj); }.
So to recap, unbounded wildcards allow for flexibility with any type. Great job, everyone!
Unlock the classroom podcast
The transcript is free to read. A free account plays the conversation back.
Next, let's discuss upper bounded wildcards, which use the syntax <? extends T>. Can anyone explain what that means?
It sounds like we're specifying a maximum type. We can only use it for types that are T or its subtypes?
Correct! This is particularly useful when you want to read items of a certain type. For instance, if you have a method that works with List<? extends Number>, what kinds of lists can we pass?
We could pass a List<Integer> or a List<Double>?
Exactly! You can read Number or its subtypes, which is beneficial for operations like computations. Can anyone think of a scenario where this might be helpful?
Maybe in a method that calculates the average of numbers, regardless of the specific number type!
Perfect example! Upper bounded wildcards work when we are producing elements. Just remember: Producer Extends!
Unlock the classroom podcast
The transcript is free to read. A free account plays the conversation back.
Now, let's delve into lower bounded wildcards using <? super T>. What do you think this means, and when would we use it?
It seems like we're allowing only writing types that are T or any supertype of T?
Exactly! This is what we use when we need to add elements. For example, if we have List<? super Integer>, which types can this list accept?
It could accept List<Number> or List<Object> because they are supertypes of Integer!
Exactly! This is great for scenarios where we want to add certain types to a collection safely. Can anyone think of a use case?
We might be adding items to a collection that only accepts certain types, like adding objects to a list during runtime?
Spot on! So always remember: Consumer Super for lower bounded wildcards. Great work, class!
Unlock the classroom podcast
The transcript is free to read. A free account plays the conversation back.
To wrap up our discussion on wildcards, let’s summarize the PECS rule. Who can explain what PECS stands for?
Producer Extends, Consumer Super!
Exactly! It is a mnemonic to help us remember when to use upper and lower bounded wildcards. If you're producing (reading), you use extends, and if you're consuming (writing), you use super.
So if I want to create a method that reads from a structure, I should consider upper bounded wildcards?
That’s correct! Likewise, when you’re adding items, think lower bounded. Can anyone give me an example of when to use each?
Reading a list of numbers would be upper, and adding to a list of objects would be lower!
Very well done! Understanding the PECS rule will greatly improve your ability to use generics in Java.
Overview
Short Summary
This section covers the concept of wildcards in Java generics, detailing their types and uses for type safety.
Medium Summary
Wildcards in Java generics allow for flexibility in type specification. They include unbounded, upper-bounded, and lower-bounded wildcards, each having distinct purposes. Understanding these wildcards is crucial for developer efficiency and avoiding casting errors.
Detailed Summary
Wildcards in Generics
Generics in Java allow for type-safe code and enhance code reusability. Wildcards are a way to specify a type in generics when the exact type is unknown, providing three main types:
-
Unbounded Wildcards (
<?>): Useful when the type is not specified. It allows for flexibility when you do not require any specific type constraints. For instance, a method could accept any type ofList<?>. -
Upper Bounded Wildcards (
<? extends T>): This form allows reading from a structure that can be of typeTor any subtype ofT. It is beneficial when you want to ensure that you can retrieve elements of a certain type or its subtypes. For example, a method parameter ofList<? extends Number>can acceptList<Integer>orList<Double>. -
Lower Bounded Wildcards (
<? super T>): This wildcard is for writing to a structure that can be of typeTor any supertype ofT. This is useful when you need to add elements of a specific type safely. For instance, a parameter ofList<? super Integer>will accept a list ofIntegeror any supertype, such asNumberorObject.
Additionally, the PECS rule succinctly encapsulates how to know which wildcard to use: Producer Extends, Consumer Super. This principle helps clarify when to use upper or lower bounded wildcards based on whether you are producing or consuming elements from a collection.
Reference YouTube Videos
Audio Book
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountUsed when the exact type is unknown.
Detailed Explanation
Unbounded wildcards are indicated by the symbol ?. They are used in generics when you do not know the exact type of the generic parameter. Instead of specifying a particular type, you can use ? to represent any type. This can be useful in scenarios where a method may operate on a variety of object types without needing to know the specifics of those types.
Examples & Analogies
Imagine a box that can store anything, like a mystery box at a gift exchange. You don't know what's inside until you open it, but it could be any item that fits. Similarly, using ? in generics allows methods to accept any type of data without restrictions.
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountAllows reading items of type T or its subtypes.
Detailed Explanation
Upper bounded wildcards are represented as <? extends T>. This type of wildcard is used when you want to read items of a certain type T and all of its subtypes. It ensures that any method that utilizes this wildcard can safely read objects of type T or its derived classes, providing flexibility without sacrificing type safety.
Examples & Analogies
Think of a library section dedicated to fiction. You can borrow any book that falls under fiction—whether it's a mystery novel, a romance, or a science fiction story—as long as it belongs to that genre. Here, the ? extends T lets you borrow any book that is a type of fiction or its subclasses.
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountAllows writing items of type T or its supertypes.
Detailed Explanation
Lower bounded wildcards are denoted by <? super T>. They are used when you want to write items to a collection that are of a type T and any of its supertypes. This allows you to safely add elements derived from type T to a collection without specifying the exact collection type, ensuring compatibility with all parent types.
Examples & Analogies
Imagine a factory producing different types of vehicles: cars, trucks, and motorcycles. The assembly line can accept vehicles of any type that is a car or above. If you send in a car, it can fit into the category of vehicles produced. In this case, ? super T lets you add any specific type of vehicle to a collection of vehicle types.
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free account• Producer – extends • Consumer – super
Detailed Explanation
The PECS rule is a mnemonic to understand when to use upper bounded (extends) and lower bounded (super) wildcards. 'Producer' types are those that produce values (read operations) and should use extends because they need to allow reading from a type and its subtypes. Conversely, 'Consumer' types are those that consume values (write operations) and should use super to write to the collection, ensuring that it can accept the base type and its supertypes.
Examples & Analogies
Imagine a bakery which only sells bread. When a customer (producer) comes in looking for different types of bread rolls, the bakery can offer several kinds—these rolls are produced from the dough. So, it extends to be diverse. On the flip side, when someone wants to donate bread ingredients (consumer) to the bakery, it can only accept flour, yeast, or their mixtures (souped-up versions), thus it accepts any product 'above' the base type itself.
--
Key concepts
Core takeaways and short definitions to help you quickly recall the key ideas from this section.
- Unbounded Wildcards:
Allows for any type, denoted as
<?>.
- Upper Bounded Wildcards:
Represented as
<? extends T>, useful for reading items of type T or its subtypes.
- Lower Bounded Wildcards:
Denoted as
<? super T>, designed for writing items of type T or its supertypes.
- PECS Rule:
A mnemonic for remembering when to use upper or lower bounded wildcards based on production or consumption.
Examples
Step-by-step examples to apply the section's ideas and test your understanding.
Example of Unbounded Wildcard: public void process(List<?> list) allows processing any type of list.
Example of Upper Bounded Wildcard: public void printNumbers(List<? extends Number> numbers) accepts lists of Numbers, Integers, or Doubles.
Example of Lower Bounded Wildcard: public void addToList(List<? super Integer> list) allows adding integers to any list that can hold Integer or its super types.
Memory aids
Imagine a library where books of different genres are organized. When you want to borrow books (read), you can pick any genre (unbounded). But if you want to donate books (write), you must ensure they fit a category (lower bounded) or can cater to all readers (upper bounded).
PECS: Producers Extend, Consumers Super - where producers crave reading, and consumers crave writing.
Flash Cards
Glossary
Unbounded Wildcard
A wildcard in generics represented as <?> that allows any type and provides flexibility.
Upper Bounded Wildcard
A wildcard represented as <? extends T> that allows reading items of type T or its subtypes.
Lower Bounded Wildcard
A wildcard denoted as <? super T> that allows writing items of type T or its supertypes.
PECS Rule
A mnemonic for deciding between upper and lower bounded wildcards: Producer Extends, Consumer Super.