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

Classes and Interfaces

Class Modifiers

Regular Classes:

• Access Modifiers: public and default only
• Non access: strictfp, abstract and final only
• Adding any other modifier will result in a compiler error.

• A final class cannot be overriden (e.g. String)
• An abstract class cannot be instantiated (e.g. DateFormat)

Class Members

• Members can use all the access modifiers: public, private, default(package), protected
• Private members are not inherited.
• This means private members can be redeclared in subclasses.
• Instance level variables cannot be synchronized, abstract, strictfp, native.

Protected

• Only accessible through inheritance in the subclass.
• The subclass cannot use a reference to super to access the protected member.

package pkg1;

public class Foo {
  protected String str = "Hello";
}

package pkg2;

public class Bar extends Foo {
  public void go() {
     Foo f = new Foo();
     String s = f.str; //Won't work ! Compiler error
     System.out.println(str); //Will work - through inheritance
  }
}

package pkg2;

public class Fubar {
   public void goo() {
        Bar b = new Bar();
        System.out.println(b.str); //wont'w work - str only accessible through inheritance
   }
}

Abstract Methods

As they go against the logic of overriding :

• abstract methods cannot be static.
• abstract methods cannot be private.

Constructors

• NO return type.
• Can have all the access modifiers.
• Can't be marked as abstract or final or static.

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 final variable can only be initialized once, either via an initializer or an assignment statement. If a final instance variable is not assigned a value - there will be a compiler error !
• It need not be initialized at the point of declaration: this is called a 'blank final' variable.
• A blank final instance variable of a class must be definitely assigned at the end of every constructor of the class in which it is declared or an instance initializer block can be used.
• Similarly, a blank final static variable must be definitely assigned in a static initializer of the class in which it is declared.
• Instance Init Blocks or constructors cannot assign values to final static variables - this will be a compiler error.
• 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.

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.

Assignments

Watch out!

float f = 2;  //This is legal. 2 is an int which fits in a float.
float f = 2.0; //Illegal. 2.0 is a double which by default won't fit in a float.

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

}