Ch1 Language Fundamentals
Ch2 Declarations and Access Control
Ch3 Operators and assignments
Ch4 Flow Control, Exceptions, and Assertions
Ch5 Object Orientation, Overloading and Overriding, Constructors, and Return types
Ch6 java.lang-The Math Class, String, and Wrappers
Ch7 Object and Collections
Ch8 Inner Classes
Ch9 Threads

Ch1

Keywords

• Access Modifiers
  • private
  • protected
  • public
• Class Method and Variable Modifiers
  • abstract
  • class
  • extends
  • final
  • implements
  • interface
  • native
  • new
  • static
  • strictfp
  • synchronized
  • transient
  • volatile
• Flow Control
  • break
  • case
  • continue
  • default
  • do
  • else
  • for
  • if
  • instanceof
  • return
  • switch
  • while
• Error Handling
  • catch
  • finally
  • throw
  • throws
  • try
  • assert
• Package Control
  • import
  • package
• Primitives
  • boolean
  • byte
  • char
  • double
  • float
  • int
  • long
  • short
• Variable Keywords
  • super
  • this
• Void Return Type Keyword
  • void
• Unused Reserved Words
  • const
  • goto

Ranges of Primitives Numbers

Default value for Primitive and Reference Types

Literals and Ranges of All Primitive Data Types

• Floating-point literals are always double by default; if you want a float, you must append an F or f.

Ch2

Class Declarations and Modifiers

• default Access can be seen only by classes within the same package.
• public Access can be seen by all classes from all packages.
• stricfp + final / abstract O.K.（class)
• final + abstract Wrong
• stricfp can modify class, method but not variable.
• final Classes the class can't be subclassed
• abstract Classes can never be instantiated（if a single method is abstract, the whole class must be declared abstract）

Method and Variable Declarations and Modifiers

• public Members-all other classes, regardless of the package they belong to
• private Members-only the class where the private member was declared（When a member is declared private, a subclass can't inherit it）（a method marked private cannot be overridden）
• protected and default Members-a default member may be accessed only if the class accessing the member belongs to the same package, whereas a protected member can be accessed by a subclass even if the subclass is in a different package.
• Only final can ever be applied to local variables.
• final Methods:prevents a method from being overridden in a subclass
• final Arguments:must keep the same value
• abstract Methods:contailns no functional code
• abstract + private (Method) Wrong
• abstract methods also cannot be marked as synchronized, strictfp, native, static
• synchronized Methods:The synchronized keyword indicates that a method can be accessed by only one thread at a time.(synchronized can be applied only to method)
• native Methods:can't with abstract and only to methods
• strictfp Methods:modify a class or nonabstract method
• Instance Variables:public private protected final transient
• transient Variables:tell JVM to skip this variable when you attempt to serialize the object declaring it(can be applied only to instance variables)
• volatile Variables:can be applied only to instance variables
• static--Methods Variables Top-level nested classes？？？？？？
• static methods can't be overriden
• 回傳值前之修飾字可調換順序(ex: public static or static public)
• An abstract class can define both an insterface can have only abstract methods
• An implementation class can itself be abstract!

Formatting the Main() Method

• Improper main() method cause a runtime error, not a compiler error.

Determining Access to Class Members

Interface Implementation

• All interface methods must be marked public, must not be static
• All variables must be public, static and final
• interface methods are abstract, they can't be marked final, native, strictfp, synchronized
• An interface can extend one or more other interface
• can't implement another interface or class
• Interface types can be used polymorpfically
• Unless the implementing class is abstract, the implementations for all methods defined in the interface
• 1. A class can implement more than one interface
  2. An interafce can itself extend another interface, but never implement anything

In order to be a legal implementation class, a nonabstract implementation class must do the following:

1. Provide concrete(nonabstract) implementations for all methods from the declared interface
2. Follow all the rules for legal overrides
3. Declare no checked exceptions on implementation methods other than those declared by the interface method
4. Maintain the signature of the interface method, and maintain the same return type(but does not have to declare the exceptions declared in the interface method)

Comparsion of modifiers on variables methods classes

Ch3

instance of Comparison

• An array is always an instance of Object

Equality Operators

• Four types of things can be tested by == : numbers, characters, booleans, reference variables.

Arithmetic Operators

• When you divide by zero with integers, you'll get a runtime exception, but with floating-pint number you won't.
• When floating-point numbers are divided by zero, they return positive or negative infinity, except when the divided is also zero, in which case you get NaN.

Shift Operators

• >> right shift ex:x >> 4 --> x / 2⁴
• << left shift ex:x << 4 --> x * 2⁴
• >>> unsigned right shift
• int x = 2; int y = x >> 34 --> int y = x >> 2(34%32=2)
• long x = 2; long y = x >> 66 --> long y = x >> 2(66%64=2)

Calculating Values from a Truth Table

Short-Circuit Logical operators

• && 兩邊皆true才行,前面false則不執行後面
• | | 兩邊皆false才行,前面true則不執行後面

Logical operators

• & | 不同於Short-Circuit Logical operators 兩邊都要執行過

example about instanceof

interface Face{}
class Bar implements Face{}
class Foo extends Bar{}
................

Ch4

switch Statements

• The default case doesn't have to come at the end of the switch.
• switch statements can evalutae only the byte, short, int, char

for Loop

• The for statement lets you declare and initialize zero, one, or multiple variables of the same type. But only one test expression.

Using break and continue

• continue statements must be inside a loop;break statements must be used inside either a loop or switch statement
• break : causes the program to stop execution of the innermost looping and strat processing the next line of code after the block.
• continue : causes only the current iteration of the innermost loop to cease and the next iteration of the same loop to start if the condition of the loop is met.

Catching an Exception Using try and catch

• the catch blocks must all follow each other, without any other statements or blocks in between.
• Once control jumps to the catch block, it never returns to complete the balance of the try block.
• A finally block encloses code that is always executed at some point after the try block, whether an exception was thrown or not.
• exceptions are always some subclass of java.lang.Exception.
• The handlers for the most specific exceptions must always be placed above those for more general exceptions.
• Runtime exceptions are referred to as unchecked exceptions. All other exceptions, meaning all those that do not derive from java.lang.RuntimeException, are checked exceptions. A checked exception must be caught somewhere in your code.
• Subtypes of Error or RuntimeException are unchecked.

Working with the Assertion Mechanism

• Assertions are typically enabled during testting?????????????????// but disabled during deployment.
• Do not use assert expressions that cause side effects. Assertions aren't guaranted to always run, so you don't want behavior that changes depending on whether assertions are enabled.
• Do use assertions to validate arguments to a private method.
• Do not use assertions to validate command-line arguments.
• Do use assertions, even in public methods, to check for cases that you know are never supposed to happen.

example about boolean

boolean boo = false;
if(boo = true){}
.....

O.K

example about switch

final int one = 1;
int x = 1;
switch(x){
	case one : System.out.print("one");
	......
}

Cause of Early Loop Termination

compare break & continue

for(int i =0; i <= 10; i++){
	if((i % 2) == 0){
		break;
		(continue;)
		System.out.print(i);
	}
}

output:

continue: 1 3 5 7 9

break: nothing

Exception class hierarchy

Legal and Illegal aeesrt Expressions

assert(x == 2)

assert(x = 2)

: "x is " + x

: void

boolean z = true;
assert(z)

int z = 0; 
assert(z)

public int go(){return 1}

: go();

public void go(){}
: go(); 

assert false

assert 1

: new Foo();

: Foo f;

Assertion Command-Line Switches

java -ea
java -enableassertions

java -da
java -disableassertions

java -ea:com.foo.Bar 

java -ea:com.foo..

java -esa -dsa

java -ea -da:com.foo....

Ch5

Overriding and Overloading

• Methods can be overloaded or overridden, but constructors can be only overloaded.
• Overloaded methods and constructors let you use the same method name(or constructor) but with different argument lists.(a different return type)
• Overriding lets you redifine a method in a subclass, when you need new subclass-specific behavior.
• abstract methods are methods you're forced to override.
• Overloaded methods must change the argument list.
• Overloaded methods can change the return type, the access modifier, declare new or broader checked exceptions.
• A method can be overloaded in the same class or in a subclass.
• the reference type (not the object type) determines which overloaded method is invoked.

Instantiation and Constructors

• Every class, including abstract classes, must have a constructor.
• A constructor has no reurn type.
• The first line in a constructor must be a call to super() or a call to this().
• Constructors can use any access modifier(even private!).
• Abstract classes have constructors that are called when a concrete subclass is instantiated.
• Interface do not have constructors.
• If your superclass does not have a no-arg constructor, you must create a constructor and insert a call to super() with arguments matching those of the superclass constructor.
• Constructors cannot be overridden.
• subclass constructors do not have to match the arguments of the superclass constructor. Only the call to super() must match.

Return Types

• An array is a legal return type.
• Byte is a wrapper object, not a primitive.

Difference Between Overloaded and Overridden Methods

Ch6

Using the java.lang.Math Class

• The method sqrt() can return NaN if the argument is NaN or less than zero
• NaN isn't equal to anything, not even itself.

Important Static Math Class Method Signatures

Using Wrappers

• Integer i1 = new Integer(42);
  Integer i1 = new Integer("42");
  Character c1 = new Character('c');

• Integer i2 = Integer.valueOf("101011", 2);

• Integer i2 = new Integer(42);
  byte b = i2.byteValue();

Wrapper Classes and Their Constructor Arguments

Common Wrapper Conversion Methods

(with radix)
parseXxx s n

(with radix)
valueOf s n

(primitive)
toString s

(primitive, radix)
toString s

Key facts to remember about comparing variables

1. The rule is the same for reference variables and primitive variables : == returns true if the two bit patterns are identical.
2. Primitive variables must use ==; they can't use the equals() method.
3. for reference variables, == means that both reference variables are referring to the same object.

Key points about the equals() method

1. equals() is used only to compare objects.
2. equals() returns a boolean, true or false.
3. The StringBuffer class has not overridden equals()
4. The String and wrapper classes are final and have overridden equals()

Ch7

Overriding hashCode() and equals()

• If two objects are equal, their hashcodes must be equal.
• The critical methods in class Object are equals(), finalize(), hashCode(), and toString().
• equals(), hashCode(), and toString() are public (finalize() is protected).
• transient variables aren't appropriate for equals() and hashcode()

Garbage Collection

• All objects in Java live on the heap.

Methods of Class Object Covered on the Exam

The equals() Contract

• For any reference value x , x.equals(x) should return true.
• For any reference value x, y. x.equals(y) should return true iff y.equals(x) return true.
• For any nonull reference value x, x.equals(null) should return false.

finalize()

• For any given object, finalize() will be called only once by the garbage collector.
• Calling finalize() can actually result in saving an object from deletion.

Three meanings for "collection":

• collection-Represents the data strusture in which objects are stored.
• Collection-java.util.Collection-Interface from which Set and List extend.
• Collections-A class that holds static collection utility.

Three basic flavors of collections include Lists, Sets, Maps.

• List of things: Ordered, duplicates allowed, with an index.
• Sets of things: May or may not be oedered and/or sorted, duplicates not allowed.
• Maps of things with keys: May or may not be ordered and/or sorted, duplicate keys not allowed.

Collections

• List : A List cares about the index.The one thing that List has that nonlists don't have is a set of methods related to the index.
• ArrayList : Fast iteration and fast random access.
• Vector : Like a somewhat ArrayList, mainly due to its synchronized methods.
• LinkedList : Good for adding elements to the ends, i.e.,stack and queues.
• HashSet : Assures no duplicates, provides no ondering, no duplicates ; iterates by insertion order or last accessed.???????????????
• TreeSet : No duplicates ; iterates in natural sorted order.
• HashMap : Fastest updates (key/value pairs) ; allow one null key, many null value.
• Hashtable : Like a slower HashMap (as with Vector, due to its synchronized methods). No null values or null keys allowed.
• LinkedHashMap : Faster iterations ; iterates by insertion order or last accessed allowed one null key, many null values.
• TreeMap : A sorted map, in natural order.

Collection Interface Concrete Implemention Classes

Ch8

• Four inner classes
  1. Inner Classes
  2. Method-local Inner Classes
  3. Anonoymous Inner Classes
  4. Static Nested Classes

Inner Classes

• The only way you can access the inner class is through a live instance of the outer class.
• An inner class instance has access to all members of the outer class, even those marked private.

• MyOuter mo = new Myouter();
  Myouter.MyInner inner = mo.new MyInner();

• MyOuter.MyInner inner = new MyOuter().new MyInner();
• Member Modifiers Applied to Inner Classes : final, abstract, public, private, protected, static, strictfp

Method-Local Inner Classes

• A method-local inner class can be instantiated only within the method where the inner class is defined.
• The only modifiers you can apply to a method-local inner class are abstract and final.
• A method-local inner class cannot use variables declared within the method (including parameters)unless those variables are marked final.

example about four inner classes

1. Regular Inner Class

   class MyOuter{
      private int x = 7;
      class MyInner{
         public void seeOuter(){
            System.out.print("shumi");
         }
      }
   }

2. Method-Local Inner Class

   class MyOuter2{
      private String x = "Outer2";
      void doStuff(){
         class MyInner{
            public void seeOuter(){
               System.out.print("shumi");
            }
         }
         MyInner mi = new MyInner();//This must come after the class
         mi.seeOuter();
      }
   }

3. Plain Old Anoymous Inner Classes, Flavor One

   class Popcorn{
      public void pop(){
         System.out.print("popcorn");
      }
   }
   
   class Food{
      Popcorn p = new Popcorn(){
         public void pop(){
            System.out.print("anonymous popcorn")
         }
      };//Don't miss it!!
   }

4. Plain Old Anonymous Inner Classes, Flavor Two

interface Cookable {
    public void cook();
}
class Food {
   Cookable c = new Cookable() {
      public void cook() {
         System.out.print("anonymous cookable implement");
      }
   };
}

5. Argument-Defoned Anonymous Inner Class

class MyWonderfulClass {
   void go() {
      Bar b = new Bar();
      b.doStuff(new Foo() {
         public vid foof() {
            System.out.pront("foofy");
         }
      });
   }
}
interface Foo(){
   void foof();   
}
class Bar{
   void doStuff(Foo f){}
}

6. Static Nested Classes

class BigOuter{
   static class Nested{}
}
class Broom{
   public static void main(String[] args){
      BigOuter.Nested n = new BigOuter.Nested();
   }
}

Ch9

Thread states

Methods and Look Status

Key Thread Methods