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
Instancemethods require an instance before they can be invoked, whereas
classmethods do not.
Instancemethods use dynamic (late) binding, whereas
classmethods use static (early) binding.
When the Java virtual machine invokes a class method, it selects the method to invoke based on the type of the object reference, which is always known at compile-time. On the other hand, when the virtual machine invokes an instance method, it selects the method to invoke based on the actual class of the object, which may only be known at run time.
The JVM uses two different instructions, shown in the following table, to invoke these two different kinds of methods: invokevirtual for
instance methods, and invokestatic for
||pop objectref and args, invoke method at constant pool index|
||pop args, invoke static method at constant pool index|
invokestatic, refer to a constant pool entry that initially contains a symbolic reference. (See my earlier column, "The Java class file lifestyle," for a description of constant pool.) The symbolic reference is a bundle of information that uniquely identifies a method, including the class name, method name, and method descriptor. (A method descriptor is the method's return type and the number and types of its arguments.) The first time the Java virtual machine encounters a particular invoke instruction, the symbolic reference must be resolved.
To resolve a symbolic reference, the JVM locates the method being referred to symbolically and replaces the symbolic reference with a direct reference. A direct reference, such as a pointer or offset, allows the virtual machine to invoke the method more quickly if the reference is ever used again in the future.
For example, upon encountering an
invokevirtual instruction, the Java virtual machine forms an index into the constant pool of the current class from the
indexbyte2 operands that follow the
invokevirtual opcode. The constant pool entry contains a symbolic reference to the method to invoke. The process of resolving symbolic
references in the constant pool is how the JVM performs dynamic linking.
The objectref and args (or just args, in the case of a class method) must be pushed onto the calling method's operand stack by the bytecode instructions that precede the invoke instruction.