Misc

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 $;

Comments

• 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

Final

• 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;
}

Transient

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

Volatile

• 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.

e.g.

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.
}

Shadowing

• 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() {
       foo(20);
  }
  
  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;
  }

}