Assignments, initialization and jvm etc.

Stack and Heap:

  • Local variables (method variables) live in the stack.
  • Objects and their instance variables live on the heap.
  • Literals and primitive casting
  • Integer literals can be decimal, octal (e.g. 013) or hexadecimal (e.g. 0x3d).
  • Literals for long and in L or l.
  • Float literals and in F or f, double literals end in a digit Dor d.
  • The Boolean literals are tree and false
  • Literals for chars are a single character in side single quotes: ‘d’.

Scope:

  • Scope refer to life time of a variable.
  • There are four basic scopes.
  • Static variables live basically as their class lives.
  • Instance variables liv as long as their object lives.
  • Local variables live as long as their method is on the stach, however, if their method invokes another method, they are temporarily unavailable.
  • Stack variables (e.g. in for or an if) live until the block completes.

Basic Assignments:

  • Literal integers are logically ints.
  • Integer expressions always result in a int-sized result, never smaller.
  • Floating point numbers are implicitly double (64 bits).
  • Narrowing a primitive truncates the high order bits
  • Compound assignments e.g.(+=) perform atomic cast.
  • A reference variable holds the bits that are used to refer to an object.
  • Reference variable can refer to sub class of the declared type but not super class.
  • When creating a new objet, e.g. Button b = new Button() the three things happen:
    1. Make a reference variable b with type Button.
    2. Create a new button object
    3. Assign the Button object to the reference variable b using a variable or array element that is uninitialized an unassigned.
  • When an array of objects is instantiated, objects within the array are not instantiated automatically, but all the references get the default value of null.
  • When an array of primitives is instantiated, elements gets default values.
  • Instance variables are always initialized with default value.
  • Local/ automatic/ method variables are never give a default value. If you attempt to use one before initializing it, you will get a compiler error.

Passing variables into methods:

  • Methods can take primitives and/or object reference as arguments.
  • Method arguments are always copies.
  • Method arguments are never actual objects(they can be reference to objects)
  • A primitive argument Is an unattached copy of the original object.
  • A reference argument is another copy of a reference to the original object.
  • Shadowing occurs when two variables with different scopes share same name, this leads to hard-to-find bugs, and hard-to answer exam questions.

Arrays declaration Construction and Initialization:

  • Arrays can hold primitives or objects, but the arrays itself objects.
  • When you declare an array the brackets can left or right of the name.
  • It’s never legal to include the size of the array in the declaration.
  • You must include the size of the array when you construct it (using now) unless you are creating an anonymous array.
  • Elements in an array of objects are not automatically created, although primitive array elements are given default values.
  • You will get a NullPointerException if you try to use an array element in an object array, if that element does not refer to a real object Arrays are indexed beginning with zero.
  • An ArrayIdexOutofBoundsexception occurs of you use a bad index value.
  • Arrays have a length variable whose value is the number of array elements.
  • The last index you can access is always one less than the length of the array.
  • Multi-dimensional arrays are just arrays of arrays.
  • The dimensions in a multidimensional array can have different lengths.
  • An array of primitives can accept any value that can be promoted implicitly to the array declare type; e.g. a byte variable can go in an int array.
  • An array of objects can hold any object that passes IS-A( or instance of) test for the declared type of the array. For example if Horse extends Animal, then a Horse object can go inti an Animal array.
  • If you assign an array to a previously declared array reference, the array youa re ssigning must be the same dimension as the reference you are assigning to
  • You can assign an array of one type to previously declared reference of ine of its subtypes, for example a Honda array can be assigned to an array declared a stype Car(asumming Honda extends Car).

Initialization Blocks:

  • Static initializer blocks run once, when class is first loaded.
  • Instance initialization blocks run every time a new instance ois created. They run after all super- constructors and before the constructor’s code has run.
  • If multiple init blocks exist in a class, they a=follow the rules startd above and thery run int ehe order in which they appear int eh source file.

Using Wrappers:

  • The wrapper class correlates to the primitive types.
  • Wrappers have two main functions
  • With wrappers primitives so that they can be handled like objects
  • To provide utility methods for primitives (usually conversions)
  • The three most important method families are
  • xxxValue()takes no arguments, returns a primitive.
  • parseXXX() takes a String returns a primitive, throws NPE.
  • valueOf() takes a String, returns a warped object, throws NPE wrapper constructors can take a String or a primitive, except or Character which can only take a char.
  • Radix refers to bases (typically) other than 10, octal is radix=8, hex= 16.

Boxing:

  • As of Java 5, boxing allows you convert primitives to wrappers to convert wraps to primitives automatically.
  • Using == with wrappers created through boxing is tricky, those with the same small values
    (typically lower than 127) will be == larger values will not be ==.

Advanced Overloading:

  • Primitive widening uses the “smallest” method argument possible.
  • Used individually, being and var-args are compatible with overloading.
  • You CANNOT widen form one wrapper type to another ( IS-A fails).
  • You can box then widen. (An int can become an Object, via an Integer).
  • You can combine var-args with either widening or boxing.

Garbage collection:

  • In java, garbage collection (GC) provides automated memory management.
  • The purpose of GC is two delete objects that can’t be reached.
  • Only the JVM decides when to run the GC, you can only suggest it.
  • You can’t know the GC algorithm for sure.
  • Objects must be considered eligible before they can be garbage collected.
  • An object eligible when no live thread can reach it.
  • To reach an object, you must have an live, reachable reference of that object
  • Java applications can run out of memory.
  • Island of objects can be GC’ed, even though they refer to each other.
  • Request garbage collection with System.gc () or Runtime.getRuntime().gc().
  • Class object has a finalize () method.
  • The finalize method is guaranteed to run once and only once before the garbage collector deletes an object.
  • The garbage collector makes no guarantee finalize () method never run.
  • You can initialize an object for GC from within the finalize ().

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s