Thinking in Java——笔记(14)

Type Information

---

The need for RTTI

• Because it is a dynamically bound method, the proper behavior will occur even though it is called through a generic reference.
• That’s what RTTI means: At run time, the type of an object is identified.
• You want the bulk of your code to know as little as possible about specific types of objects, and to just deal with the general representation of a family of objects.
• With RTTI, you can ask a reference the exact type that it’s referring to, and thus select and isolate special cases.

The Class object

• How type information is represented at run time? This is accomplished through a special kind of object called the Class object, which contains information about the class.
• Java performs its RTTI using the Class object, even if you’re doing something like a cast.
• Each time you write and compile a new class, a single Class object is also created.
• This happens when the program makes the first reference to a static member of that class.
• The constructor is also a static method of a class. Therefore, creating a new object of that class using the new operator also counts as a reference to a static member of the class.
• A Java program isn’t completely loaded before it begins, but instead pieces of it are loaded when necessary.
• Once the Class object for that type is in memory, it is used to create all objects of that type.
• Each Class object is loaded only when it’s needed, and the static initialization is performed upon class loading.
• Anytime you want to use type information at run time, you must first get a reference to the appropriate Class object.
• With the Class object you can find out just about everything you want to know about a type.
• You can discover an object’s entire class hierarchy at run time.
• The newlnstance( ) method of Class is a way to implement a "virtual constructor".

Class Literals

• There’s a standard field called TYPE that exists for each of the primitive wrapper classes. The TYPE field produces a reference to the Class object for the associated primitive type.
• Creating a reference to a Class object using ".class" doesn’t automatically initialize the Class object.
• Effectively, initialization is "as lazy as possible."
• Class.forName( ) initializes the class immediately in order to produce the Class reference.

Generic class references

• A Class reference really does indicate the exact type of what it’s pointing to: an object of the class Class.
• To constrain the type of Class object that the Class reference is pointing to, using the generic syntax.
• The ordinary class reference can be reassigned to any other Class object, whereas the generic class reference can only be assigned to its declared type.
• Integer is inherited from Number. But the **Integer Class **object is not a subclass of the Number Class object.
• The benefit of Class<?> is that it indicates that you aren’t just using a non-specific class reference by accident, or out of ignorance.
• In order to create a Class reference that is constrained to a type or any subtype, you combine the wildcard with the extends keyword to create a bound.
• The reason for adding the generic syntax to Class references is only to provide compile-time type checking.
• In any event, because of the vagueness, the return value of up.newlnstance( ) is not a precise type, but just an Object.

New cast syntax

• The cast( ) method takes the argument object and casts it to the type of the Class reference.
• The new casting syntax is useful for situations where you can’t just use an ordinary cast.

Checking before a cast

• It won’t allow you to perform a downcast assignment without using an explicit cast, to tell it that you have extra information that allows you to know that it is a particular type.
• The keyword instanceof tells you if an object is an instance of a particular type.
• It’s important to use instanceof before a downcast when you don’t have other information that tells you the type of the object.
• There’s a rather narrow restriction on instanceof: You can compare it to a named type only, and not to a Class object.

A dynamic instanceof

• The isInstance( ) method has eliminated the need for the instanceof expressions.

Registered factories

• The only way to reuse the name Factory as seen above is by qualifying typeinfo.factory.Factory.

instanceof vs. Class equivalence

• **instanceof **and islnstance( ) produce exactly the same results, as do equals( ) and ==.
• If you compare the actual Class objects using ==, there is no concern with inheritance—it’s either the exact type or it isn’t.

Reflection: runtime class information

• The type must be known at compile time in order for you to detect it using RTTI and to do something useful with the information. the compiler must know about all the classes you’re working with.
• Suppose you’re given a reference to an object that’s not in your program space. In fact, the class of the object isn’t even available to your program at compile time.
• This design-time configuration requires that any component be instantiable, that it exposes parts of itself, and that it allows its properties to be read and modified.
• Reflection provides the mechanism to detect the available methods and produce the method names.
• Another compelling motivation for discovering class information at run time is to provide the ability to create and execute objects on remote platforms, across a network.
• Objects of these types are created by the JVM at run time to represent the corresponding member in the unknown class.
• The class information for anonymous objects can be completely determined at run time, and nothing need be known at compile time.
• The JVM will simply look at the object and see that it belongs to a particular class (just like ordinary RTTI). Before anything can be done with it, the Class object must be loaded.
• The true difference between RTTI and reflection is that with RTTI, the compiler opens and examines the .class file at compile time.
• With reflection, the .class file is unavailable at compile time.

A class method extractor

• Reflection is in the language to support other Java features, such as object serialization and JavaBeans.
• There are times when it’s quite useful to dynamically extract information about a class.
• There is enough support to actually set up and make a method call on an object that’s totally unknown at compile time.

Dynamic proxies

• A proxy typically acts as a go-between.
• A proxy can be helpful anytime you’d like to separate extra operations into a different place than the "real object," and especially when you want to easily change from not using the extra operations to using them, and vice versa.
• All calls made on a dynamic proxy are redirected to a single invocation handler, which has the job of discovering what the call is and deciding what to do about it.
• The constructor for the invocation handler is usually given the reference to the "real" object so that it can forward requests once it performs its intermediary task.

Null Objects

• It is useful to introduce the idea of a Null Object that will accept messages for the object that it’s "standing in" for, but will return values indicating that no "real" object is actually there.
• The place where Null Objects seem to be most useful is "closer to the data," with objects that represent entities in the problem space.
• In general, the Null Object will be a Singleton, so here it is created as a static final instance.
• If you are working with interfaces instead of concrete classes, it’s possible to use a DynamicProxy to automatically create the Null Objects.

Mock Objects & Stubs

• Both Mock Object and Stub pretend to be live objects that deliver real information, rather than being a more intelligent placeholder for null, as Null Object is.

Interfaces and type information

• The fact that you always have a back door into a class may allow you to solve certain types of problems that could otherwise be difficult or impossible, and the benefits of reflection in general are undeniable.