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

This article mainly introduces "Why not to use the original ecological type in the new code". In the daily operation, I believe that many people have doubts about why not to use the original ecological type in the new code. The editor consulted all kinds of materials and sorted out the simple and easy-to-use operation methods. I hope it will be helpful to answer the doubt of "Why not use the original ecological type in the new code"! Next, please follow the editor to study!

Generics (Generic) have been added to the Java1.5 distribution. Before generics appear, every object read by the collection must be converted, and if an object of the wrong type is accidentally inserted, the conversion processing at run time will report an error. After the emergence of generics, we can tell the compiler which object types are acceptable for each collection through generics, let the compiler automatically convert the element insertion of the collection, and tell us at compile time whether we have inserted objects of the wrong type.

Some generic technical terms

Generic class or generic interface: a class or interface that has one or more type parameters (type parameter) in a declaration, collectively referred to as generics. After eg,jdk1.5, the List interface has only a single type parameter E, which represents the element type of the list, so its interface name should be List, but people often call it List for short.

A parameterized type (parameterized type) in the form of the name of the class or interface + angle brackets () enclosing the list of actual type parameters for generic form parameters.

Each generic defines a primitive type (raw type) of the class, that is, the generic name without any actual type parameters. The original ecological type of eg,List is List. The primitive type is equivalent to removing generic information from the type declaration.

Generics: early detection of errors at compile time

Using generics for coding has two benefits:

Advantage 1: let you find errors early at compile time when writing code, and help locate the error location advantage 2: collections use generics, eliminating the need for manual conversion when traversing elements from the collection (the compiler does the implicit conversion for us and ensures that the process does not fail, regardless of whether we use a for-each loop or not)

Let's make it clear through an example, and the code is as follows:

/ * * @ exception ClassCastException * / private static void testGenericeBeforejdk5 () {Collection stamps = new ArrayList (); stamps.add (new Coin ()); for (Iterator I = stamps.iterator (); i.hasNext ();) {Stamp next = (Stamp) i.next (); / / ClassCastException}} private static void testGenericeAfterjdk5 () {Collection stamps = new ArrayList (); stamps.add (new Coin ()) / / the compiler tells us the error} / / in the two test inner class static class Stamp {} static class Coin {} testGenericeBeforejdk5 () methods, we hope that the stamps collection will only hold Stamp class elements, but we still accidentally put a coin into this collection when coding. Then the program does not tell the programmer about the problem at compile time, but when the code is actually executed, an exception occurs. Exception in thread "main" java.lang.ClassCastException: effectivejava.no23.TestGeneric$Coin cannot be cast to effectivejava.no23.TestGeneric$Stamp at effectivejava.no23.TestGeneric.testGenericeBeforejdk5 (TestGeneric.java:26) at effectivejava.no23.TestGeneric.main (TestGeneric.java:14)

In the testGenericeAfterjdk5 () method, we use generics to define the parameter types of the collection. Through this declaration, the compiler knows that the stamps collection should contain only Stamp instances and gives a guarantee. Therefore, when we accidentally put an coin instance into the stamps collection during code development, the compiler will remind us in time and generate a compilation error message to tell the programmer exactly where the error is.

Error: (20,28) java: incompatible types: effectivejava.no23.TestGeneric.Coin cannot be converted to effectivejava.no23.TestGeneric.Stamp

By comparison, we can also find that collections use generics, and manual conversions are no longer required when traversing elements from the collection.

The difference between primitive types and generic types

First, the use of original ecological types will lose the security and other declarative advantages of generics.

Why do we continue to allow the use of original ecological types? Since the development of the Java platform, there has been a large amount of Java code that does not use generics, and it is believed that all of this code is legal and interoperable with generic code, which has led to the decision to support original ecological types for this "Migration Compatibility" requirement.

Second, there is a difference between the original ecological type List and the parametric type List.

The primitive type List evades generics checking, while List explicitly tells the compiler that it can hold any type of object. Eg,List can be passed to List, but not to List. Generics have rules for subtyping. List is a subtype of the original ecological type List, but not a subtype of List.

Here is an example to interpret the difference between the two:

The private static void testSubTyping () {List strings = new ArrayList (); unsafeAdd (strings, new Integer); String s = strings.get (0); / / exception while run the method;} / * methods use primitive ecotypes, so they can be compiled. The * / private static void unsafeAdd (List list, Object o) {list.add (0);} / * method uses List instead of the original ecological type, so the compilation will not pass. * / private static void unsafeAddV2 (List list, Object o) {list.add (0);}

Conclusion: using primitive types such as List will lose type safety, but using parameterized types such as List will not.

Scenarios where generics are not recommended

Do not use primitive types in new code. There are two small exceptions to this rule because generic information can be erased by the compiler at run time.

Primitive types must be used in class text (class literal), and parameterized types are not allowed in the specification (but array types and primitive types are allowed) [JLS,15.8.2]

ClassLiteral:

TypeName {[]}. Class

NumericType {[]}. Class

Boolean {[]}. Class

Void. Class

A class literal is an expression consisting of the name of a class, interface, array, or primitive type, or the pseudo-type void, followed by a'. And the token class.

The https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.8.2instanceof operator is invalid and illegal for the parameterized type of unrestricted wildcard. In this case, angle brackets () and question marks (?) are superfluous because the generic information is erased during operation.

Private static void testInstanceOfInvalidOnGeneric (Object o) {if (o instanceof Set) {/ / once it is determined that o is a Set, it must be converted to the wildcard type Set instead of the original ecological type Set. This avoids runtime exceptions in subsequent code. Set set = (Set) o;}}

Summary

The parameterized type of the entry in which the glossary term example is involved List23 the actual type parameter String23

Generics

List

twenty-three

Formal type parameter

E

twenty-three

Infinite wildcard type parameter

List

23 parameters of original ecological type

List

twenty-three

Restricted type parameter

List

twenty-six

Recursive type restriction

List

twenty-seven

Restricted wildcard type parameter

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.