1) In Java, the class designer can guarantee initialization of every object by providing a constructor. If a class has a constructor, Java automatically calls that constructor when an object is created, before users can even get their hands on it. So initialization is guaranteed. The name of the constructor is the same as the name of the class. A constructor that takes no arguments is called the default constructor.
2) The constructor is an unusual type of method because it has no return value. This is distinctly different from a void return value, in which the method returns nothing but you still have the option to make it return something else. Constructors return nothing and you don’t have an option (the new expression does return a reference to the newly created object, but the constructor itself has no return value).
3) Method overloading is essential to allow the same method name to be used with different argument types. And although method overloading is a must for constructors, it’s a general convenience and can be used with any method. Each overloaded method must take a unique list of argument types. You cannot use return value types to distinguish overloaded methods.
4) If you have a data type that is smaller than the argument in the method, that data type is promoted. char produces a slightly different effect, since if it doesn’t find an exact char match, it is promoted to int. (byte->short->int->long->float->double; char->int->long->float->double ) If your argument is wider, then you must perform a narrowing conversion with a cast. If you don’t do this, the compiler will issue an error message.
5) If you create a class that has no constructors, the compiler will automatically create a default constructor for you. However, if you define any constructors (with or without arguments), the compiler will not synthesize one for you.
6) To allow you to write the code in a convenient object-oriented syntax in which you “send a message to an object,” the compiler does some undercover work for you. There’s a secret first argument passed to the method, and that argument is the reference to the object that’s being manipulated. The this keyword—which can be used only inside a non-static method—produces the reference to the object that the method has been called for.
7) If you’re calling a method of your class from within another method of your class, you don’t need to use this. You simply call the method. The current this reference is automatically used for the other method. The this keyword is used only for those special cases in which you need to explicitly use the reference to the current object. For example, it’s often used in return statements when you want to return the reference to the current object. The this keyword is also useful for passing the current object to another method. When the name of the method argument and the name of the member variable are the same, you can use this to identify the member variable.
8) When you write several constructors for a class, there are times when you’d like to call one constructor from another to avoid duplicating code. You can make such a call by using the this keyword. In a constructor, the this keyword takes on a different meaning when you give it an argument list. It makes an explicit call to the constructor that matches that argument list. Thus you have a straightforward way to call other constructors. while you can call one constructor using this, you cannot call two. In addition, the constructor call must be the first thing you do, or you’ll get a compiler error message. And the compiler won’t let you call a constructor from inside any method other than a constructor.
9) When the garbage collector is ready to release the storage used for your object, it will first call finalize( ), and only on the next garbage-collection pass will it reclaim the object’s memory. So if you choose to use finalize( ), it gives you the ability to perform some important cleanup at the time of garbage collection.
10) Your objects might not get garbage collected and garbage collection is not destruction and is only about memory. If your program completes and the garbage collector never gets around to releasing the storage for any of your objects, that storage will be returned to the operating system en masse as the program exits.
11) If your object contains other objects, you don't need to expicitly release those objects in finalize() and the garbage collector takes care of the release of all object memory regardless of how the object is created.
12) Remember that neither garbage collection nor finalization is guaranteed. If the JVM isn’t close to running out of memory, then it might not waste time recovering memory through garbage collection. You need to do your own clean up (such as release memories allocated by calling native c/c++ codes or release database connections ) explicitly ( not in finalize() ).
13) finalize( ) can be used to eventually discover the termination condition (all the necessary clean up has been done before the object gets released), even if it isn’t always called. If one of the finalizations happens to reveal the bug, then you discover the problem, which is all you really care about. You should generally assume that the base-class version of finalize( ) will also be doing something important, and call it using super.
// Using finalize() to detect an object that
// hasn’t been properly cleaned up.
class Book {
boolean checkedOut = false;
Book(boolean checkOut) {
checkedOut = checkOut;
}
void checkIn() {
checkedOut = false;
}
protected void finalize() {
if(checkedOut)
System.out.println("Error: checked out");
// Normally, you’ll also do this:
// super.finalize(); // Call the base-class version
}
}
14) System.gc( ) is used to force finalization, but it just suggests the JVM to do so and cannot guarantee the garbage collector to start up.
15) It turns out that the garbage collector can have a significant impact on increasing the speed of object creation. For some JVMs, allocating storage for heap objects in Java can be nearly as fast as creating storage on the stack in other languages. In some JVMs, the Java heap is quite different; it’s more like a conveyor belt that moves forward every time you allocate a new object. This means that object storage allocation is remarkably rapid. The “heap pointer” is simply moved forward into virgin territory, so it’s effectively the same as C++’s stack allocation. The trick is that the garbage collector steps in, and while it collects the garbage it compacts all the objects in the heap so that you’ve effectively moved the “heap pointer” closer to the beginning of the conveyor belt and farther away from a page fault. The garbage collector rearranges things and makes it possible for the high-speed, infinite-free-heap model to be used while allocating storage.
16) A simple but slow garbage-collection technique is called reference counting (It's never been used in any JVMs). This means that each object contains a reference counter, and every time a reference is attached to that object, the reference count is increased. Every time a reference goes out of scope or is set to null, the reference count is decreased. The garbage collector moves through the entire list of objects, and when it finds one with a reference count of zero it releases that storage (however, reference counting schemes often release an object as soon as the count goes to zero). The one drawback is that if objects circularly refer to each other they can have nonzero reference counts while still being garbage. Locating such self-referential groups requires significant extra work for the garbage collector.
17) In faster schemes, garbage collection is based on the idea that any non-dead object must ultimately be traceable back to a reference that lives either on the stack or in static storage. The chain might go through several layers of objects. Thus, if you start in the stack and in the static storage area and walk through all the references, you’ll find all the live objects. For each reference that you find, you must trace into the object that it points to and then follow all the references in that object, tracing into the objects they point to, etc., until you’ve moved through the entire Web that originated with the reference on the stack or in static storage. Each object that you move through must still be alive. Note that there is no problem with detached self-referential groups—these are simply not found, and are therefore automatically garbaged.
18) The JVM uses an adaptive garbage-collection scheme, and what it does with the live objects that it locates depends on the variant currently being used. One of these variants is stop-and-copy. This means that the program is first stopped (this is not a background collection scheme). Then, each live object is copied from one heap to another, leaving behind all the garbage. In addition, as the objects are copied into the new heap, they are packed end-to-end, thus compacting the new heap (and allowing new storage to simply be reeled off the end).
19) Once your program becomes stable, it might be generating little or no garbage. Despite that, a copy collector will still copy all the memory from one place to another, which is wasteful. To prevent this, some JVMs detect that no new garbage is being generated and switch to a different scheme (this is the “adaptive” part). This other scheme is called mark-and-sweep, and it’s what earlier versions of Sun’s JVM used all the time. For general use, mark-and-sweep is fairly slow, but when you know you’re generating little or no garbage, it’s fast. Mark-and-sweep follows the same logic of starting from the stack and static storage, and tracing through all the references to find live objects. However, each time it finds a live object, that object is marked by setting a flag in it, but the object isn’t collected yet. Only when the marking process is finished does the sweep occur. During the sweep, the dead objects are released. However, no copying happens, so if the collector chooses to compact a fragmented heap, it does so by shuffling objects around.
20) A JIT compiler partially or fully converts a program into native machine code so that it doesn’t need to be interpreted by the JVM and thus runs much faster. When a class must be loaded (typically, the first time you want to create an object of that class), the .class file is located, and the bytecodes for that class are brought into memory. At this point, one approach is to simply JIT compile all the code, but this has two drawbacks: It takes a little more time, which, compounded throughout the life of the program, can add up; and it increases the size of the executable (bytecodes are significantly more compact than expanded JIT code), and this might cause paging, which definitely slows down a program. An alternative approach is lazy evaluation, which means that the code is not JIT compiled until necessary. Thus, code that never gets executed might never be JIT compiled. The Java HotSpot technologies in recent JDKs take a similar approach by increasingly optimizing a piece of code each time it is executed, so the more the code is executed, the faster it gets.
21) Java guarantees that variables are properly initialized before they are used. In the case of a method’s local variables, this guarantee comes in the form of a compile-time error. If a primitive is a field in a class, each primitive field of a class is guaranteed to get an initial value. When you define an object reference inside a class without initializing it to a new object, that reference is given a special value of null. One direct way to initialize a member variable is simply to assign the value at the point you define the variable in the class. It has the limitation that every object of the class will get these same initialization values. The constructor can be used to perform initialization, but it dosen't preclude the automatic initialization above, which happens before the constructor is entered.
23) Within a class, the order of initialization is determined by the order that the variables are defined within the class. The variable definitions may be scattered throughout and in
between method definitions, but the variables are initialized before any methods can be called—even the constructor.
24) There’s only a single piece of storage for a static, regardless of how many objects are created. You can’t apply the static keyword to local variables, so it only applies to fields. If a field is a static primitive and you don’t initialize it, it gets the standard initial value for its type. If it’s a reference to an object, the default initialization value is null.
25) The static initialization occurs only if it’s necessary. They are initialized only when the first object of the class is created or the first static access occurs ( when the class is referenced). After that, the static objects are not reinitialized. The order of initialization is statics first, if they haven’t already been initialized by a previous object creation, and then the non-static objects.
26) To summarize the process of creating an object:
a) Even though it doesn’t explicitly use the static keyword, the constructor is actually a static method. So the first time an object of the class is created, or the first time a static method or static field of the class is accessed, the Java interpreter must locate the corresponding .class file, which it does by searching through the classpath.
b) As .class file is loaded (creating a Class object), all of its static initializers are run. Thus, static initialization takes place only once, as the Class object is loaded for the first time.
c) When you create a new object of the class, the construction process for that object first allocates enough storage for the object on the heap.
d) This storage is wiped to zero, automatically setting all the primitives in that object to their default values (zero for numbers and the equivalent for boolean and char) and the references to null.
e) Any initializations that occur at the point of field definition are executed.
f) Constructors are executed. This might actually involve a fair amount of activity, especially when inheritance is involved.
27) Java allows you to group other static initializations inside a special “static clause” (sometimes called a static block) in a class. It looks like this:
static {initilization of static field}
Java also provides a similar syntax, called instance initialization, for initializing non-static variables for each object. It looks like this :
{ initilization of non-static filed}
This syntax is necessary to support the initialization of anonymous inner classes and it also allows you to guarantee that certain operations occur regardless of which explicit constructor is called.
28) An array is simply a sequence of either objects or primitives that are all the same type and are packaged together under one identifier name. Arrays are defined and used with the square-brackets indexing operator [ ]. To define an array reference, you simply follow your type name with empty square brackets. (i.e. int[] a ) You can also put the square brackets after the identifier to produce exactly the same meaning. (i.e.in a[])
29) The compiler doesn’t allow you to tell it how big the array is when defining the array reference. All that you have at this point is a reference to an array (you’ve allocated enough storage for that reference), and there’s been no space allocated for the array object itself. To create storage for the array, you must write an initialization expression. For arrays, initialization can appear anywhere in your code, but you can also use a special kind of initialization expression that must occur at the point where the array is created. This special initialization is a set of values surrounded by curly braces.(i.e. int[] a1 = { 1, 2, 3, 4, 5, }; ) The final comma in the list of initializers is optional.
30) All arrays have an intrinsic member (whether they’re arrays of objects or arrays of primitives) that you can query—but not change—to tell you how many elements there are in the array. This member is length. Arrays start counting from element zero, the largest element you can index is length - 1. If you go out of bounds, you will encounter a runtime error.
31) If you don’t know what are the elements you’re going to need in your array while you’re writing the program, you can simply use new to create the elements in the array. (i.e. int[] a = new int[5] ) The array creation is actually happening at run time. And it's also possible to initilize the array elemets in the same statements. But you cann't assign the array size in this way.( i.e. a = new int[]{1,2,3,4,};)
32) The default behavior of printing a reference of an object (if you don’t define a toString( ) method for your class) is to print the class name + "@" + the address of the object.
33) You can use Object[] as the argument to produce effect of variable argument lists before Java SE5. In Java SE5, you can now use ellipses to define a variable argument list.(i.e. f(Object... a) ) With varargs, you no longer have to explicitly write out the array syntax—the compiler will actually fill it in for you when you specify varargs.(you'll be able to use foreach syntax for the varargs,because it's actually converted to an Array.) It’s possible to pass zero arguments to a vararg list. If you already have an array it will accept that as the variable argument list.
34) An apparently small addition in Java SE5 is the enum keyword, which makes your life much easier when you need to group together and use a set of enumerated types. Because the instances of enumerated types are constants, they are in all capital letters by convention (if there are multiple words in a name, they are separated by underscores. i.e. public enum Status {UNKNOWN, OK, FAILED, POWER_EMERGENCY}). To use an enum, you create a reference of that type and assign it to an instance. ( i.e. Status a = Status.OK )
35) The compiler automatically adds useful features when you create an enum. For example, it creates a toString( ) so that you can easily display the name of an enum instance. The compiler also creates an ordinal( ) method to indicate the declaration order of a particular enum constant, and a static values( ) method that produces an array of values of the enum constants in the order that they were declared. An especially nice feature is the way that enums can be used inside switch statements.