Optimize with a SATA RAID Storage Solution
Range of capacities as low as $1250 per TB. Ideal if you currently rely on servers/disks/JBODs
Last month, we discussed the basic distinction between primitive types and objects in Java. Both the number of primitive types and the relationships between them (particularly conversions between types) are fixed by the language definition. Objects, on the other hand, are of unlimited types and may be related to any number of other types.
Each class definition in a Java program defines a new type of object. This includes all the classes from the Java libraries,
so any given program may be using hundreds or even thousands of different types of objects. A few of these types are specified
by the Java language definition as having certain special usages or handling (such as the use of
java.lang.String concatenation operations). Aside from these few exceptions, however, all the types are treated basically the same by the
Java compiler and the JVM used to execute the program.
If a class definition does not specify (by means of the
extends clause in the class definition header) another class as a parent or superclass, it implicitly extends the
java.lang.Object class. This means that every class ultimately extends
java.lang.Object, either directly or via a sequence of one or more levels of parent classes.
Objects themselves are always instances of classes, and an object's type is the class of which it's an instance. In Java, we never deal directly with objects, though; we work with references to objects. For example, the line:
does not create an
java.awt.Component object; it creates a reference variable of type
java.lang.Component. Even though references have types just as objects do, there is not a precise match between reference and object types --
a reference value may be
null, an object of the same type as the reference, or an object of any subclass (i.e., class descended from) the type of the reference.
In this particular case,
java.awt.Component is an abstract class, so we know that there can never be an object of the same type as our reference, but there can certainly
be objects of subclasses of that reference type.