1.3       Enumerations

• An enum can be declared outside or inside a class but not in a method
• An enum declared outside a class must not be marked static, final, abstract, protected or private
• An enum can implement any interface
• Enums can contain constructors, methods, variables and constant class bodies
• Enum constructors can never be invoked directly in code
• MyEnum.values() returns an array of MyEnum’s values

2       OBJECT ORIENTATION

2.1     Overriding

• Appear in subclasses
• Have the same name as a superclass method
• Have the same parameter list as a superclass method
• Have the same return type as a superclass method
• The throws clause of the overriding method may only include exceptions that can be thrown by the superclass method, including its subclasses
• The access modifier for the overriding method may not be more restrictive than the access modifier of the superclass method:
• if the superclass method is public, the overriding method must be public
• if the superclass method is protected, the overriding method may be protected or public
• if the superclass method is package, the overriding method may be package, protected, or public
• if the superclass methods is private, it is not inherited and overriding is not an issue

2.2     Overloading

• Overloaded methods must change the argument list
• Overloaded methods can change the return type
• Overloaded methods can change the access modifier
• Overloaded methods can declare new or broader checked exceptions

2.3     Coupling

• Coupling refers to the degree to which one class knows about or uses members of another class
• Loose coupling is the desirable state of having classes that are well encapsulated, minimize references to each other, and limit the breadth of API usage
• Tight coupling is the undesirable state of having classes that break the rules of loose coupling

2.4     Cohesion

• Cohesion refers to the degree in which a class has a single, well-defined role or responsibility
• High cohesion is the desirable state of a class whose members support a single, well-focused role or responsibility
• Low cohesion is the undesirable state of a class whose members support multiple, unfocused roles or responsibilities

3       ASSIGMENTS

3.1     Initialization rules

• Init blocks execute in the order they appear
• Static init blocks run once, when the class is first loaded
• Instance init blocks run every time a class instance is created
• Instance init blocks run after the constructor’s call to super()

3.2     Boxing

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

4       OPERATORS

4.1     Bit Shift Operators

5       FLOW CONTROLS

5.1      Exceptions

5.2     Assertions

5.2.1    Identifier vs. Keyword

• To use assert as identifier compile code with:
• javac -source 1.3 *.java
• To use assert as keyword compile code with:
• javac -source 1.4/1.5/5/1.6/6 *.java

5.2.2    Assertion Rules

• Don’t use assertions to validate arguments to a public method
• Don’t use assertions to validate command-line arguments
• Don’t use assert expressions that can cause side effects
• Do use assertions to validate arguments to a private method
• Do use assertions, even in public methods, to check for cases that you know are never, ever supposed to happen

6       STRINGS,  I/O,  FORMATTING,  PARSING

6.1      String

• intern() - when the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned. It follows that for any two strings s and t,s.intern() == t.intern() is true if and only if s.equals(t) is true.
• substring(start, end) - returns a new string that is a substring of this string [start, end)

6.2     StringBuffer & StringBuilder

• StringBuilder & StrignBuffer are identical in functionality but StringBuilder isn’t thread safe
• substring(start, end) - returns a new string that is a substring of this string [start, end)
• equals() – is not overridden; it doesn’t compare values

6.3     Console

  1 //Get a Console
  2 java.io.Console c = System.console();
  3            
  4 //Read string
  5 String input1 = c.readLine();
  6 String input2 = c.readLine("%s", "input string");
  7            
  8 //Read password
  9 char password[];
 10 password = c.readPassword();
 11 password = c.readPassword("%s", "input password");

• If a superclass implements Serializable, then its subclasses do automatically
• If a superclass doesn’t implement Serializable, then when a subclass object is deserialized, the superclass constructor will be invoked, along with its super constructor(s)
• If a class has object reference to another class that doesn’t implement Serializable the runtime exception will be thrown – java.io.NotSerializableException
• Serialization is not for Statics

6.5     Dates, Numbers, Currency

6.6      Regular expressions

6.7      Tokenizing

6.8     Formatting

7       GENERICS & COLLECTIONS

7.1     Class hierarchy for collections

7.2     Collections details

8       INNER CLASSES

8.1     Class-Local Inner Class

8.1.1    Instantiating

  1 //Example#1
  2 MyOuter mo = new MyOuter();
  3 MyOuter.MyInner inner = mo.new MyInner();
  4            
  5 //Example#2
  6 MyOuter.MyInner inner = new MyOuter().new MyInner();

• final  
• abstract      
• public
• private
• protected
• strictfp
• static – for static nested class(not inner)

8.2     Method-Local Inner Class

8.2.1    Instantiating

• A method-local inner class can be instantiated only within the method where the inner class is defined
• The inner class object can’t use the local variables of the method the inner class is in
• A local class declared in a static method has access to only static members of the enclosing class

  1 public class MyOuter {
  2    int b = 9;
  3    static int s = 9;
  4 
  5    [static] public void myFunc() {
  6       int a = 0;
  7      
  8       class MyInner {
  9          int add(int value) {
 10             value += a;       // Illegal use of local variable 'a'
 11             value += b;       // Legal use of member variable 'b'
 12             [value += s];     // Legal use of static variable 's'
 13             return value;
 14          }
 15       }
 16            
 17       MyInner mi = new MyInner();
 18       mi.add(5);
 19    }
 20 }

8.2.2    Member modifiers

• The same rules apply to method-local inner classes as to local variable declarations, i.e. you can mark a method-local inner class as abstract or final, but never both at the same time

8.3     Anonymous

8.3.1    Instantiating

• Inner class declared without any class name at all
• A semicolon is required after declaration of anonymous class
• Polymorphism is in play when anonymous inner class are involved

  1 class MyOuter {
  2       void myFunc() {
  3             System.out.println("MyOuter");
  4       }
  5 }
  6 
  7 class MainClass {
  8       MyOuter mo = new MyOuter() {
  9             void myFunc() {
 10                   System.out.println("Anonymous Class");
 11             }
 12       }; // WATCH OUT about semicolon!
 13      
 14       public void doIt() {
 15             mo.myFunc();      // Legal, MyOuter has a 'myFunc()'
 16             mo.newFunc();     // Not legal! MyOuter doesn't have a 'newFunc()'
 17       }
 18 }

8.4     Static Nested Class

8.4.1    Instantiating

• The static nested class can be accessed without having an instance of the outer class
• The static nested class doesn’t have access to the instance variables and non-static methods of the outer class

  1 class Outer {
  2       static abstract class Nested {
  3             abstract void doIt();
  4       }
  5 }
  6 
  7 class Runing {
  8       static int a = 0;
  9       int b = 0;
 10      
 11       public static void main(String[] args) {
 12             Outer.Nested on = new Outer.Nested() {
 13                   @Override
 14                   void doIt() {
 15                         System.out.println(a);  //OK
 16                         System.out.println(b);  //Not legal!
 17                        
 18                   }
 19             };
 20       }
 21 }

9.1     Thread states

9.2     Class Thread

9.3     Synchronization and Locks

• Only methods (or blocks) can be synchronized, not variables or classes
• Each object has just one lock
• Not all methods in a class need to be synchronized
• Once a thread acquires the lock on an object, no other thread can enter any of the synchronized methods in that class
• If a class has both synchronized and non-synchronized methods, multiple threads can still access the class’s non-synchronized methods
• If a thread goes to sleep, it holds any locks it has – it doesn’t release them
• A thread can acquire more than one lock
• Static methods can be synchronized

10    DEVELOPMENT

10.1  Java & Javac 

10.2 Basic search algorithm

• They both have the same list of places they search, to look for classes
• They both search through this list of directories in the same order
• As soon as they find the class they are looking for, they stop searching for that class. In the case that their search lists contain two or more files with the same name, the first file found will be the file that is used
• The first place they look is in the directories that contain the class that come standard with J2SE
• The second place they look is in the directories defined by classpaths
• Classpaths should be thought of as "class search paths." They are lists of directories in which classes might be found
• There are two places where classpaths can be declared:
• A classpath can be declared as an operating system environment variable. The classpath declared here is used by default, whenever java or javac are invoked
• A classpath can be declared as a command-line option for either java or javac. Classpaths declared as command-line options override the classpath declared as an environment variable, but they parsist only for the length of the invocation

10.3  Jar archive

10.4   Javadoc

10.5   Annotation

  1 // use a deprecated method and tell compiler not to generate a warning
  2 @SuppressWarnings("deprecation")
  3 void useDeprecatedMethod() {
  4      objectOne.deprecatedMethod(); //deprecationwarning - suppressed
  5 }