Shulou(Shulou.com)06/03 Report--

This article mainly introduces what Java generics are, which can be used for reference. I hope you can learn a lot after reading this article. Let's take a look at it.

Learning goal

What is generics?

Why generics are needed

How to use generics

How to customize generics

Knowledge such as type wildcards

1. What is generics?

Generics are not only a characteristic of Java language, but also a feature of programming language.

Allows programmers to define variable parts when writing code in a strongly typed programming language that must be declared before use.

The collection class in Java supports generics, which looks like this in the code

What is in the code is generics, we pass the type like a parameter, and the data type in the middle of the angle brackets is the data type, which we can call the actual type parameter. Here, the data type of the actual type parameter can only be the reference data type.

So why do you need generics?

two。 Why generics are needed

When we use ArrayList to implement classes, if generics are not specified, IDEA will give a warning, and the code seems to run smoothly. Take a look at the following example:

Import java.util.ArrayList;public class testDemo1 {public static void main (String [] args) {ArrayList arrayList = new ArrayList (); arrayList.add ("Hello"); String str1 = (String) arrayList.get (0); System.out.println ("str=" + str1);}}

Running result:

Str1=Hello

Although no exception occurs at run time, this has two disadvantages:

Cast is required: since there is an Object [] array inside the ArrayList, the Object type is returned when the get () element is used, so it is necessary to cast the type to get the object outside the ArrayList. Other Collection and Map also have this problem if they do not use generics.

Any type of object can be added to the collection, and there is a risk of type unsafety. For example, in the following code, we add both Integer type and String type to the list:

Package com.caq.oop.demo08;import java.util.ArrayList;import java.util.List;public class Test {public static void main (String [] args) {/ / instantiate an empty list List arrayList = new ArrayList (); arrayList.add (123); arrayList.add ("sad"); String str = (String) arrayList.get (0);}}

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

At com.caq.oop.demo08.Test.main (Test.java:12)

Due to our "negligence", the first element of the list is actually an integer, but we force it to be of string type, which doesn't work, so a ClassCastException exception is thrown.

Using generics can solve these problems. Generics have the following advantages:

The number of type conversions can be reduced and the code can be more concise.

The program is more robust: as long as there is no warning at compile time, the runtime will not throw a ClassCastException exception

Improves the readability of the code: when you write a collection, you limit the types that can be stored in the collection.

3. How to use generics 3.1 generics use

In your code, use generics like this:

List list = new ArrayList (); / / Java 7 and later versions, the generic type can be omitted from the constructor: List list = new ArrayList (); foreign currency Barber

Note that the type declared by the variable must be consistent with the type passed to the actual object. Here is an example of an error:

List list = new ArrayList (); List numbers = new ArrayList (Integer); 3.2 definition of generics in the custom generic class 3.2.1 Java source code

Before customizing generic classes, let's take a look at how java.util.ArrayList is defined:

The class name is followed by the definition of generics. E is not a specific type in Java, but a wildcard for Java generics (note that it is uppercase, which actually means Element). It can be understood as a placeholder, defined on the class, and the type is determined when you use it.

There are no restrictions on naming here, but it's best to have some meaning. For example, the generic definition of java.lang.HashMap is HashMap,K for Key,V and Value.

3.2.2 Custom generic class instance 1

Let's customize a generic class. Custom generics can be called by convention and have the meaning of Type. Examples are as follows:

Example demonstration

Package com.caq.List;public class Generic01 {private T abc;// defines generics on a class. Within the class, you can use public T getAbc () {return abc;} public void setAbc (T abc) {this.abc = abc;} public static void main (String [] args) {/ / instantiate the object, specifying the element type as integer Generic01 integerGeneric01 = new Generic01 (). / / call method integerGeneric01.setAbc; System.out.println ("integerGeneric01=" + integerGeneric01.getAbc ()); / / instantiate the object, specifying the element type as long type Generic01 longGeneric01= new Generic01 (); longGeneric01.setAbc (200L); System.out.println ("longGeneric01=" + longGeneric01.getAbc ()) / / instantiate the object, specifying that the element type is double-precision floating-point Generic01 doubleGeneric01= new Generic01 (); doubleGeneric01.setAbc (300.0); System.out.println ("doubleGeneric01=" + doubleGeneric01.getAbc ());}}

Running result:

IntegerGeneric01=100

LongGeneric01=200

DoubleGeneric01=300.0

We also define generics at the definition of the class: Generic01; defines an abc variable of type T inside the class and adds setter and getter methods to it.

Explanation: the use of generic classes is also very simple, in the main method, when you create an object, specify that the type of T is Integer, Long, Double, respectively, and the class can be automatically converted to the corresponding type.

3.2.3 Custom generic class instance 2

Now that we know how to define a class that contains a single generic type, how to define a class that contains multiple generics?

We can look at how the HashMap class is defined. The following is a screenshot of the Java source code:

Referring to the definition of the HashMap class, let's take a look at how to define a class that contains two generics

Package com.caq.List;public class Generic02 {/ / this is the knowledge of defining two generics on the class / / defining key generic type of type K private K key; / / defining value generic type private V value; / / encapsulation of type V, setting and obtaining the value of private generic type public K getKey () {return key through Getter and Setter methods. } public void setKey (K key) {this.key = key;} public V getValue () {return value;} public void setValue (V value) {this.value = value;} public static void main (String [] args) {/ / instantiate the object, specifying the type as integer and the long integer Generic02 integerLongGeneric02 = new Generic02 () / / instantiate the object, specifying floating-point type and string type Generic02 floatStringGeneric02 = new Generic02 (); integerLongGeneric02.setKey (100L); integerLongGeneric02.setValue (200L); System.out.println ("key=" + integerLongGeneric02.getKey ()); System.out.println ("value=" + integerLongGeneric02.getValue ()); floatStringGeneric02.setKey (0.9f) FloatStringGeneric02.setValue ("Barala energy"); System.out.println ("key=" + floatStringGeneric02.getKey ()); System.out.println ("value=" + floatStringGeneric02.getValue ());}}

Running result:

Key=100value=200key=0.9value= Barala energy

3.3 Custom generic methods

Earlier, we knew how to define generic classes, and generics defined on classes can also be used in methods. Let's take a look at how to customize generic methods.

Generic methods are not necessarily written in generic classes. When the caller of a class always cares about a generic method in the class and does not care about other properties, it is no longer necessary to define generics on the entire class.

Set generics directly on the method (generic)

Package com.caq.List;public class Generic03 {public void test (T t) {System.out.println (t);} public static void main (String [] args) {Generic03 generic03 = new Generic03 (); generic03.test ("Monkey"); generic03.test (1); generic03.test (1.00000); generic03.test (1L);}}

Running result:

Monkey11.01

In the example, it is used to define the generic type of the test method, which receives a generic parameter variable and prints it in the method body; it is also easy to call the generic method, instantiating the object in the main method, calling the generic method under the object, and passing in different types of parameters.

4. Subclasses of generic classes

A generic class is also a Java class, which also has inheritance features.

Inheritance of generic classes can be divided into two cases:

Subclass defines the type parameter variables of a generic class

The subclass does not specify the type parameter variables of the generic class.

4.1 explicit type parameter variables

For example, there is a generic interface:

Package com.caq.List;public interface GenericInterface01 {default void show (T t) {}}

The implementation classes for generic interfaces are as follows:

Package com.caq.List;public class GenericInterfaceImple implements GenericInterface01 {@ Override public void show (String s) {System.out.println (s);}}

The subclass implementation makes it clear that the parameter variable of the generic type is of type String. So the override of the method show () also replaces T with the String type.

4.2 ambiguous type parameter variables

When the implementation class is uncertain about the parameter variables of the generic class, the implementation class needs to define the type parameter variables, and when the caller uses the subclass, it also needs to pass the type parameter variables.

Here is another implementation class for the GenericInterface interface:

Package com.caq.List;public class GenericInterfaceImple implements GenericInterface01 {@ Override public void show (T t) {System.out.println (t);}}

Call the show () method of the implementation class in the main method:

Package com.caq.List;public class GenericInterfaceImple implements GenericInterface01 {@ Override public void show (t) {System.out.println (t);} public static void main (String [] args) {GenericInterfaceImple integerGenericInterfaceImple = new GenericInterfaceImple (); integerGenericInterfaceImple.show (100);}} 1005. Type wildcard

Let's first look at an example of generics as method parameters:

Package com.caq.List;/** * traverses and prints every element in the set * traversal is one of the most important operations on the binary tree and is the basis for other operations on the binary tree. Tree traversal is an important operation of tree. * the so-called traversal refers to the access to the information of all nodes in the tree, that is, each node in the tree is visited once and only once. * @ param list Collection to receive * / public class Generic04 {public void printListElement (List list) {for (Object o: list) {System.out.println (o);}

Looking at the above code, the parameter list has a qualified generic type of Object, that is, this method can only accept collections with elements of type Object, and it won't work if we want to pass collections of other element types. For example, if you pass a collection that loads Integer elements, the program will report an error at compile time:

Tips: List in generics is not the parent of List, and they do not satisfy inheritance relationships.

5.1 infinitely fixed wildcards

To solve this problem, use type wildcards, modify the code at the method parameters, and change the middle Object to? You can:

Public void printListElement (List list) {

From here? Is a type wildcard that indicates that any type can be matched, so the caller can pass a list of any generic type.

Example demonstration

Package com.caq.List;import java.util.ArrayList;import java.util.List;public class Generic04 {/ / List can be understood as a list type, which can be an integer list or a string type list. List represents a traversing element representing public void printListElement (List list) {for (Object o: list) {System.out.println (o) }} public static void main (String [] args) {/ / instantiate an integer list List interger = new ArrayList (); / / add elements interger.add (1); interger.add (2); interger.add (2222); / / instantiate object Generic04 generic04 = new Generic04 (); generic04.printListElement (interger) / / instantiate a list of string types ArrayList strings = new ArrayList (); strings.add ("element1"); strings.add ("element2"); strings.add ("element3"); generic04.printListElement (strings);}}

Running result:

one

two

2222

Element1

Element2

Element3

5.2 extends wildcards

Extends wildcards are used to limit the upper limit of generics. What do you mean? Still using the above example as an example, let's look at a new requirement. We want the List collection received by the method to be limited to numeric types (float, integer, double, byte, etc.) and do not want other types to be passed in (such as strings). At this point, you can overwrite the above method definition and set the upper wildcard:

Public void printListElement (List

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.