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

This article mainly introduces the example analysis of generics and wildcards in Java, which is very detailed and has a certain reference value. Friends who are interested must read it!

Aside from the topic: generics and wildcards are two difficult grammars in Java grammar. The main purpose of learning generics and wildcards is to be able to understand the source code.

1. Generics 1.1 usage of generics 1.1.1 concept of generics

There is a saying on "Java programming ideas": general classes and methods can only use specific types: either basic types or custom classes. If you want to write code that can be applied to many types of code, this rigid limitation will be a great constraint on the code. So generics have been introduced since Java5. What does this generics mean? Because general classes and methods can only use one specific type, the code is greatly constrained, such as a method of finding the maximum of three numbers, assuming that the type of the parameter list in the method is Integer, and you have no problem finding a maximum value from the three integer data. the program runs perfectly, but when you want to find the maximum of the three floating point numbers This program cannot be compiled, so you can choose to write another overloaded method to implement the parameter list and the implementation function based on Double again, which can also solve the problem, but have you ever thought about a problem? what should I do if there are 10, 000 or even 1 million types that require the largest of the three objects? This is impossible. In order to solve the problem of this type, generics are introduced. Generics implement the concept of parameterized types, so that code can apply multiple types. Generic means "applicable to many types". Using generics, you can pass types as "parameters" to classes, interfaces, and methods, so that classes and methods can have the broadest expressive power, without having to create another type because of a different parameter.

Note: any basic type cannot be used as a type parameter.

1.1.2 generic classes

To understand generics through a piece of code, let's first look at the following code for generics that do not use code:

/ * No generics * / class A {} class Print {private An a; public Print (An a) {setA (a); System.out.println (this.a);} public void setA (AA) {this.a = a;} public A getA () {return this.a }} public class Generic {public static void main (String [] args) {Print print = new Print (new A ());}}

/ / output:A@1b6d3586

There is no problem with creating a class without using generics, but the reusability of this class is not good. It can only hold objects of class A, not objects of any other class. We don't want to write a new class for every type we encounter, which is unrealistic. When we learn about classes, we know that the Object class is the parent of all classes, so the Object class can accept all type references, and we can let the Print class hold objects of type Object.

/ * use Object class * / class B {} class Print1 {private Object b; public Print1 (Object b) {setB (b); System.out.println (this.b);} public void print (Object b) {setB (b); System.out.println (this.b);} public void setB (Object b) {this.b = b }} public class Generic1 {public static void main (String [] args) {Print1 print1 = new Print1 (new B ()); / / print type B int I = 2022; print1.print (I); / / print integer type print1.print ("this is a string object!") ; / / print string type}}

/ / output:

/ / B@1b6d3586

/ / 2022

/ / this is a string object!

Print1 can receive and print any type, but this is not the result we want. If you think about it, if you implement a sequential table class, which is implemented through an array, if this array can receive any type, it will be very confusing. When you take out the data, you can not be sure what type of data is taken out, and the data taken out is the Object class, and you need to carry out forced type conversion. Can that specify what type of object the class holds and the compiler can check the correctness of the type. Generics achieve this goal perfectly. Let's rewrite the above code into generic classes, so we first need to know the syntax of generics. The syntax for creating generic classes is as follows:

Class class name {

Permission modifies generic parameter variable name; / / generic member variable

Permission modifier return value type method name (parameter list) {} / parameter list and return value type can be generic

}

For example:

Class Print2 {private T c; public void print (TC) {setC (c); System.out.println (this.c);} public void setC (TC) {this.c = c;}}

The syntax for using generic classes is as follows:

Generic class variable name; / / define a generic class reference

New generic class (constructor argument); / / instantiate a generic class object

For example:

Print2 print3 = new Print2 ()

Implement a class using generics and use it:

/ * use generics * / class C {} class Print2 {private T c; public void print (TC) {setC (c); System.out.println (this.c);} public void setC (TC) {this.c = c;}} public class Generic2 {public static void main (String [] args) {Print2 print2 = new Print2 () / / print C type print2.print (new C ()); Print2 print3 = new Print2 (); / / print integer type print3.print (2022); Print2 print4 = new Print2 (); / / print string type print4.print ("this is a string object!") ;}}

/ * *

* output:

* C@1b6d3586

* 2022

* this is a string object!

, /

The representative placeholder after the class name indicates that the current class is a generic class.

[specification] Type parameters are generally represented by an uppercase letter, and the common names are:

E stands for Element

K stands for Key

V stands for Value

N stands for Number

T stands for Type

S, U, V, etc.-second, third, fourth type

/ / A generic class class ClassName {}

When using a generic class, you specify the type held by the object of this class, then the object can only receive objects of that type, pass in objects of other types, the compiler will report an error, and when receiving the return value of a generic method in a generic class, you do not need to do a cast (downward conversion), while using the Object class requires a cast.

1.1.3 Type derivation

When using a generic class, you can derive the type parameters required to instantiate the generic class from the types passed in to the generic type. In other words, when defining a generic object, the type must be specified in the preceding angle brackets, but not when instantiated later. Such as:

Print2 print3 = new Print2 (); / / 1.2nude types can be omitted from the angle brackets.

It's easy to understand that a naked type is a generic class. If you don't specify the type held by the generic object, such a type is the naked type. For example:

Public static void main (String [] args) {Print2 print2 = new Print2 (); print2.print (2022); print2.print ("string");}

/ / output:

/ / 2022

/ / string

We don't want to use naked types ourselves. Naked types are compatible with the mechanisms retained by older versions of API.

1.3 erasure mechanism 1.3.1 about generic arrays

Before we introduce the erasure mechanism of generics, let's take a look at generic arrays. Let's come to the conclusion that generic arrays are not allowed to be instantiated in Java. If you have to build a generic array, the correct approach can only be achieved through reflection. Of course, there is a "shortcut" to create a generic array without reflection. The code created is as follows:

1. Created by shortcuts, there are no mistakes in most cases.

Public class MyArrayList {public T [] elem; private int usedSize; public MyArrayList (int capacity) {this.elem = (T []) new Object [capacity];}}

two。 Created by reflection, it is now only given to the code, and exactly why we do this will introduce reflection later.

Public class MyArrayList {public T [] elem; private int usedSize; public MyArrayList (Class clazz, int capacity) {this.elem = (T []) Array.newInstance (clazz, capacity);} 1.3.2 compilation and erasure of generics

Let's first implement a simple generic sequence table, do not consider the expansion problem, only a simple add and delete operation, let's take a look at the construction method part of the compiled disassembly.

Import java.lang.reflect.Array;public class MyArrayList {public T [] elem; private int usedSize; public MyArrayList (int capacity) {this.elem = (T []) new Object [capacity];} public MyArrayList (Class clazz, int capacity) {this.elem = (T []) Array.newInstance (clazz, capacity);}}

We find that all generic placeholders T have been erased and replaced with Object, which indicates that the generic mechanism of Java is implemented at compile time, while the implementation of generic mechanism is implemented through an erasure mechanism like this, and type checking is completed during compilation.

We print different types of MyArrayList classes to see if the generics mechanism doesn't show up at run time, and if so, the printed types should all be MyArrayList.

Public static void main (String [] args) {MyArrayList list1 = new MyArrayList (10); MyArrayList list2 = new MyArrayList (10); System.out.println (list1); System.out.println (list2);}

/ * *

* output:

* MyArrayList@1b6d3586

* MyArrayList@4554617c

, /

We find that the type of printing is the same, all MyArrayList, so we can draw a conclusion that generics occur at compile time, type checking of generics is completed at compile time, generics are implemented through erasure mechanism, placeholders behind the class are erased and other placeholders are replaced with Object. Of course, this is when the generic parameter does not specify an upper bound, and if there is an upper bound, the placeholder will be erased to the type or interface of the upper bound, but no upper bound is specified. The upper bound defaults to Object, what is the generic upper bound. Shh, we'll talk about it later.

According to the erasure mechanism, you can also explain why the generic array cannot be instantiated in Java, because the placeholder in front of the generic array will be erased into Object, which actually creates an Object array, and the Object array can put any type, which leads to data instantiation is not safe, because you are not sure that all the elements stored in the array are of your expected type, so for security, Java does not allow instantiation of generic arrays.

1.4 Upper bound of generics 1.4.1 Upper bounds of generics

When defining a generic class, it is sometimes necessary to make certain constraints on the type variables passed in, which can be constrained by type boundaries.

Class generic class name {

...

}

For example, Number is the parent of related numeric types such as Integer,Float,Double.

Public class MyArrayList {}

Then the MyArrayList generic class can only specify the subclasses that hold the Number class and Number, which constrains the generic type parameters, which is the upper bound of the generic class. When the generic class is constrained by the type boundary, it can only specify that the generic class holds the type boundary class and its subclasses.

MyArrayList list1 = new MyArrayList (10); / / correct MyArrayList list2 = new MyArrayList (10); / / correct MyArrayList list3 = new MyArrayList (10); / / error, because String is not a special generics upper bound of Number subclass 1.4.2

Suppose you need to design a generic class that can find the largest element in the array.

Class MaxVal {public T max (T [] data) {T max = data [0]; for (int I = 0; I

< data.length; i++) { if (max.compareTo(data[i]) < 0) max = data[i]; } return max; }} 由于引用类型的比较需要使用Comparable接口来判断大小，所以所传入的类需要实现Comparable接口，上面这个泛型的类型参数的上界是一个特殊的上界，表示所传入的类型必须实现Comparable接口，不过实现了Comparable接口的类，那也就是Comparable的子类了，综上，像这样类似需要通过实现某一个接口来达到预期功能的类型，使用泛型时需指定泛型的上界，并且该传入的类型必须实现该上界接口。 1.4.3泛型方法 有泛型类，那么就一定有泛型接口，泛型方法，其中泛型接口与泛型类的创建和使用是一样的，所以我们重点介绍泛型方法的创建与使用。 创建泛型方法的基本语法： 方法限定符 返回值类型 方法名称(形参列表) { ... } 例如上面实现求数组中最大元素泛型版的方法如下： class MaxVal { public T max(T[] data) { T max = data[0]; for (int i = 0; i < data.length; i++) { if (max.compareTo(data[i]) < 0) max = data[i]; } return max; }} 对于非static修饰的静态方法， 可以省略，上述代码可以变成： class MaxVal { public T max(T[] data) { T max = data[0]; for (int i = 0; i < data.length; i++) { if (max.compareTo(data[i]) < 0) max = data[i]; } return max; }} 但是，如果是一个static修饰的静态方法，不可以省略，因为静态方法不依赖与对象，它的使用不用实例化对象，所以必须有单独的类型参数列表来指定持有的对象类型。 class MaxVal { public static T max(T[] data) { T max = data[0]; for (int i = 0; i < data.length; i++) { if (max.compareTo(data[i]) < 0) max = data[i]; } return max; }}1.4.4类型推导 和泛型类一样，泛型方法也有类型推导的机制，如果不使用类型推导，那么泛型方法是这么使用的： 使用类型推导图中画圆圈部分可以省略。

There is no parent-child relationship in generic classes as follows:

Public class MyArrayList {.} / / MyArrayList is not the parent type of MyArrayList / / MyArrayList is not the parent type of MyArrayList

But there is a subclass relationship between the two classes using wildcards.

two。 Wildcard 2.1 the concept of wildcards

? Is a wildcard, with the use of generics, unlike generics, generic T is a certain type, after passing in type arguments, it is determined, and wildcards are more like a stipulation, specifying a range, indicating which parameters you can pass. There is only one? in the angle brackets of a generic class name, which restricts the type passed in by the generic class to Object, which is equivalent to no restriction, but the element can only be received using an Object reference because the specific type cannot be determined, so it is also called an unbounded wildcard.

/ / print sequence table public static void printList1 (ArrayList list) {for (T x:list) {System.out.println (x);}} / / print sequence table public static void printList2 (ArrayList list) {for (Object x:list) {System.out.println (x);}} using wildcards

Using generic T can determine that the incoming type is T type, so use variables of T type to receive, while wildcards? If no boundary is set, the default upper bound is that Object has no lower bound. To ensure security, you can only use variables of type Object to receive.

Wildcards are used to solve the problem that generics cannot be covariant, which means that if Student is a subclass of Person, then List should also be a subclass of List. However, generics do not support such parent-child relationships.

2.2 Upper bounds of wildcards

Wildcards also have upper bounds, and you can restrict that the type passed in must be an upper bound class or a subclass of this class.

Basic syntax:

It's MyArrayList. It's MyArrayList.

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.