Generics Types generic study notes
8 types of text? (Class literals) as a runtime type mark (Type token)
In 1.5, java.lang.class is a generic, that is, one type parameter T. If string.class, the type is Class
Collection
The SELECT method above is suitable for all classes. This eliminates the type conversion.
Note 10: Class is a very useful technique as a running mark. This technology is widely used in the new Annotation API.
Original: This Technique of Using Class Literals As Run Time Type Tokens Is A Very Useful Trick To Know. It is buy extensively in the New Apis for manipulating annotations.
9 Tongcaver more role
Look at the example below
Public Interface Sink
Due to the call, the compiler cannot determine what type of
Public Static
At this time, another wildcard type is introduced: Lower Bound: Super t>.
Public Static
Note 11: The lower limit wildcard? Super T indicates that an unknown type is a super type of t, as if EXTENDS T indicates that the unknown type is the subtype of t.
Original: The solution is to use a form of lower bounded wildcard The syntax super T denotes an unkmown type that is supertype of T. it is the twin of the bounded wildcard we use extends T to denote an unknown type that is a.?? Subtype OF T.
An example will be held after the article is a method of comparing the elements in Collection. For example, in the Treeset, a Compare should be provided to compare the order of elements in the TreeSet. And accepted in the constructor.
Public Interface Comparator
We provide Compare
TREESET (COMPARATOR Super e> c);
Similarly, in the MAX method in the Collection, a maximum is returned. These elements must implement the Comparable interface. COLLECTION.MAX (Comparable
// T must be a public static
Note 12: General, if your API uses only the type parameter T as a parameter, it should take advantage of the lower limit wildcard; the opposite, if your API returns T, you should use the upper limit wildcard to give your client more convenient.
Original:. In general if you have an API that only uses a type parameter T as an argument, its uses should take advantage of lower bounded wildcard Conversely, if the API only returns T, you'll give your clients more flexibility by using upper Bounded Wildcards.
Wildcard capture, Wildcard Capture
The following example should have been clearly unforgettable:
Set > Unknownset = new hashset
Since unknownset is an unknown type, no actual type cannot be accepted. Such as String. Consider the following code:
Class Collections {
It seems that this code should not be allowed, but it is legal. This is because the wildcard capture principle.
Note 13: This situation is very frequent, and there is a special rule that allows such code to appear, which proves to be secure: wildcard capture, allowing the compiler to determine the unknown wildcard type as a model method of the type parameter. Wildcard capture only allows those type parameters that appear in the method parameter list.
Original: Because this situation arises relatively frequently, there is a special rule that allows such code under very specific circumstances in which the code can be proven to be safe This rule, known as wildcard capture, allows the compiler to infer the unknown type of. A Wildcard As a Type Argument to a Generic Method. Wildcard Capture Is Only Allowed If The Type Parameter Being Inferred Only Appers Once in The Methods Argument List.10 Converting Old Codes to Vale
This is called generifying. If you want to convert the old code to the model, please consider how to modify it carefully. Such as java.util.collection:
public interface Collection {public boolean containsAll (Collection c); public boolean addAll (Collection c);} public interface Collection
This is a type of security, but it is not compatible with an old code. Because the norm code can only accept the e-type Collectioni.
It must be considered that addall can add any subtypes of e. ContainSall also can be able to accept different types, and more.
Section 9 mentioned the max method.
Public Static
This exists a problem, that is, the old code is unable to match:
Public Static Comparable Max (Collection COLL); // New Public Static Object Max (Collection Coll); // Old
By explicitly declaring a superclass, you can force them to consistent. And, we know that MAX only reads from his input Colelction, so it is suitable for any subclass of T, modified as follows:
PUBLIC Static
This situation is relatively rare, but if you design a library, you should be prepared to seriously consider converting them.
Note 14: When converting a set of existing APIs, you must determine that the model API will not excessively restriction, and continue to support the original API. .
Original: When converting existing APIs, you should think carefully to make certain that the generic API is not unduly restrictive and continue to support the original contract of the API Another problem is the need to be careful: covariant return value (covariant returns) . That is, the return value of the refine subclass method. The old code is as follows:
Public class foo {public foo create) {} // factory method} public class bar extends foo {public foo create () {} // actually created BAR}
Consider the advantage of return value coordination:
Public class foo {public foo create) {} // factory method} public class bar extends foo {public bar create () {} // actually created BAR}
Note 13: This feature is not directly supported by JVM, but supported by the compiler.
Original: The JVM Does Not Directly Support overriding of methods with diffrer. This feature is supported by the compiler.
Here I quote a paragraph of my friend udoo as a summary: http://udoo.51.net
The important part of Java 1.5 is generics. The birth of Java Generics is probably related to .NET's persecution, the previous multiple versions have never seen such a large change.
In this strong type of language in Java, Type Casting is a very difficult thing. The compiler can solve some of the compile time, encounter this problem at runtime, is a potential hidden danger. Reflection technology is an important means of solving the flexible configuration of the application, but can only know which class is at runtime, there may be Casting issues.
The purpose of Template technology in C is to provide fast, easy to use toolbox, STL is the technology that C programming must be mastered. Java generics looks very like C template, but through this article we know, Java Generics is more important to type inspection, you can go to the mandatory type conversion that it seems difficult to guess, probably only the program writer, the most clear, this is here what type. Using Java Generics, the program may be more read, which also reduces the risk of running moments, but several concepts and technologies mentioned here are not easy to understand (there are several incorrect errors in the text). THESERVERSIDE.COM has a debate on whether this technology is required, no matter what, give us a means, it is necessary to use it.
After spent 3 days, I spent 1 week before I finished. It's really laborious. Thank you all the way you have been supporting. Any questions are welcome to come to me discussion.
Copyright Notice: This article is completed by ice cloud, started 9CBS, the author retains Chinese copyright. No commercial use is not permitted without permission. Welcome to the reprint, but please keep the article and copyright statement complete. For contact, please send an email: Icecloud (at) sina.com