From Suhrid.net Wiki
Revision as of 11:27, 6 September 2011 by Suhridk (talk | contribs) (→‎Final, Transient, Volatile)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to navigationJump to search

Legal Identifiers

  • Can be composed of characters, numbers, currency-symbols and connecting chars such as underscore.
  • Definition of characters are interpreted according to the charset.
  • NO special chars such as #, :, ;, @, -, etc...
  • Must start with letter, currency char, underscore but CANNOT start with a digit !
  • Java identifiers are case-sensitive.

Illegal identifiers:

  • int 23age;
  • String em@iladd;
  • List all-accounts;

These are legal!:

  • int __;
  • String $;


  • Comment start sequences like //, /*. /** are ignored within comment blocks.
  • So trying to nest multiple-line comments will result in an error
/* This is the foo algorithm
   /* which takes foo's and sort's bars */

Final, Transient, Volatile


  • Variables marked as final and once initialized, cannot be reinitialized.
  • Marking primitives as final is equivalent to making them a constant.
  • For object references, final only prevents the reference from being assigned to another object.
  • The object however can still be modified.
  • There are no final objects, only final references.
  • A local final variable must be initialized before it is used. If the variable is never used (blank final) then it wont cause a compiler error.
  • Final variables can be passed to non-final arguments
public static void main(String[] args) {
		final int x = 5;
		System.out.println(go(x)); //6
		System.out.println(x); //5
private static int go(int y) {
		return ++y;


  • Applies only to instance variables.
  • Tells the JVM to skip this variable when serializing the object it is part of.


  • Applies only to instance variables.
  • Tells the JVM that a thread accessing the variable must synchronize its private cache copy of the variable with the master copy in main memory.
  • This is rarely used. Synchronization is used, rather than volatile to keep data thread-safe.

Local variables

  • No access modifier is applicable to local variables.
  • The only modifier that can be applied to local variables is final.
  • Local variables are not automatically initialized, unlike instance and static variables.
  • Compiler will complain when uninitialized local variable is first USED. If you don't try to use an uninitialized variable, it will be OK.
  • Compiler can however detect in very simple conditional cases, that a local variable will be initialized, but will complain in complex cases.


private void foo() {
   int i;
   System.out.println("i : " + i); //Compiler error

   if(true) {
      i = 10;
   } else {
      i = 20;
   System.out.println("i : " + i); //OK. Compiler can figure out i will be definitely initialized.

   int j;
   boolean b = true;
   if(b) {
     j = 10;
   System.out.println("j : " + j); //Compiler error - can't figure out if j will be initialized or not.


  • The more local variable will always mask the instance level variable with the same name.
  • "this" can be used to qualify the variable.
class Bar {
  private int i = 10;

  public void go() {
  private void foo(int i) {
        System.out.println(i); //local i - shadows instance i. Will print 20;
        System.out.println(this.i); //Refers to instance i, will print 10;