Thinking in Java

Java

Write above:
I wrote the notes in the view of a CPP programmer, 
which is quick for catching the differences.
Any error plz point out.

Introduction to Objects

The hidden implementation

• explicitly
  
  • public
    the following element is available to everyone.
  • private
    no one can access the following element except you.
  • protected
    it acts like private, with the exception that an inheriting class has access to protected members, but not private members.
• implicitly
  
  • friendly (package access)
    classes can access the members of other classes in the same package (library component), but outside of the package those same members appear to be private.

The singly rooted hierarchy

• In Java (as with virtually all other OOP languages except for C++) the answer is yes,
  and the name of this ultimate base class is simply Object.
• A singly rooted hierarchy makes it much easier to implement a garbage collector, which is one of the fundamental improvements of Java over C++.

Containers

Java, the library has different types of containers for different needs:

• several different kinds of List classes (to hold sequences),
• Maps (also known as associative arrays, to associate objects with other objects),
• Sets (to hold one of each type of object),
  and more components such as queues, trees, stacks, etc.

Parameterized types (generics)

One of the big changes in Java SE5 is the addition of parameterized types, called generics in Java。

ArrayList<Shape> shapes = new ArrayList<Shape>(); 

Exception handling: dealing with errors

• Java’s exception handling stands out among programming languages,
  because in Java, exception handling was wired in from the beginning and you’re forced to use it.
• It is the single acceptable way to report errors.
• If you don’t write your code to properly handle exceptions, you’ll get a compile-time error message.
• This guaranteed consistency can sometimes make error handling much easier.

Concurrent programming

Java’s concurrency is built into the language, and Java SE5 has added significant additional library support.

Java and the Internet

History

• The submission passes through the Common Gateway Interface (CGI) provided on all Web servers.
• The text within the submission tells CGI what to do with it.
• The most common action is to run a program located on the server in a directory that’s typically called “cgi-bin.” (If you watch the address window at the top of your browser when you push a button on a Web page, you can sometimes see “cgi-bin” within all the gobbledygook there.)
• These programs can be written in most languages.
• Perl has been a common choice because it is designed for text manipulation and is interpreted, so it can be installed on any server regardless of processor or operating system.
• However, Python (www.Python.org) has been making inroads because of its greater power and simplicity.

Client-side programming

Plug-ins and Scripting languages.

Serve-side programming

• Traditionally, server-side programming has been performed using Perl, Python, C++, or some other language to create CGI programs, but more sophisticated systems have since appeared. These include Java-based Web servers that allow you to perform all your server-side programming in Java by writing what are called servlets.
• Servlets and their offspring, JSPs, are two of the most compelling reasons that companies that develop Web sites are moving to Java, especially because they eliminate the problems of dealing with differently abled browsers.

Analysis and design

• what to do (a plan, estimate your time and double it with 10% more)
• how to do (a design, UML)
• begin to do
• revision

Everything Is an Object

You manipulate objects with references

A safer practice, then, is always to initialize a reference when you create it:

String s = "asdf";

You must create all the objects

Where storage lives

1. Registers.
2. The stack.
3. The heap.
4. Constant storage.
5. Non-RAM storage.

Special case: primitive types

// The “wrapper” classes allow you to make a non-primitive object on the heap
// to represent a primitive type. 
Character ch = new Character(‘x’); 
// Java SE5 autoboxing will automatically convert from a primitive to a wrapper type:
Character ch = ‘x’;
// and back:
char c = ch; 

High-precision numbers

BigInteger and BigDecimal

Arrays in Java

• When you create an array of objects, you are really creating an array of references,
  and each of those references is automatically initialized to a special value with its own keyword: null.
  When Java sees null, it recognizes that the reference in question isn’t pointing to an object.
• You can also create an array of primitives. Again, the compiler guarantees initialization
  because it zeroes the memory for that array.

You never need to destroy an object

Scoping

In C, C++, and Java, scope is determined by the placement of curly braces {}

int x = 12;
// Only x available
{
  int q = 96;
  // Both x & q available
  // You cannot do the following, even though it is legal in C and C++: 
  int x = 96; // Illegal 
}
  // Only x available
  // q is "out of scope"
}

Scope of objects

{
  String s = new String("a string");
} // End of scope

• This is where a bit of magic happens.
• Java has a garbage collector, which looks at all the objects that were created with new and figures out which ones are not being referenced anymore.

Creating new data types: class

Fields and methods

class DataOnly {
  int i;
  double d;
  boolean b;
} 
DataOnly data = new DataOnly(); 
data.i = 47;
data.d = 1.1;
data.b = false; 

Default values for primitive members

When a primitive data type is a member of a class, it is guaranteed to get a default value if you do not initialize it:

This guarantee doesn’t apply to local variables those that are not fields of a class.

int x;

• Then x will get some arbitrary value (as in C and C++);
• You are responsible for assigning an appropriate value before you use x.
• If you forget, Java definitely improves on C++: You get a compile-time error telling you the variable might not have been initialized.
• (Many C++ compilers will warn you about uninitialized variables, but in Java these are errors.)

Your first Java program

// HelloDate.java
import java.util.*;
public class HelloDate {
  public static void main(String[] args) {
    System.out.println("Hello, it’s: ");
    System.out.println(new Date());
  }
} 

• Since java.lang is implicitly included in every Java code file, these classes are automatically available.
• java.util.Date is in the util library and that you must import java.util.* in order to use Date.

Compiling and running

javac HelloDate.java 
java HelloDate 

Comments and embedded documentation

/* This is a comment
 * that continues
 * across lines
 */
// Remember, however, that everything inside the /* and */ is ignored, 
// so there’s no difference in saying:
/* This is a comment that
continues across lines */
// This is a one-line comment 

Comment documentation

//: object/Documentation1.java
/** A class comment */
public class Documentation1 {
 /** A field comment */
 public int i;
 /** A method comment */
 public void f() {}
} ///:~ 
//: object/Documentation2.java
/**
* <pre>
* System.out.println(new Date());
* </pre>
*/
///:~ 
@see classname
@see fully-qualified-classname
@see fully-qualified-classname#method-name 
{@link package.class#member label} 
{@docRoot}
{@inheritDoc} 
@version version-information
@author author-information 
@since version-information
@param parameter-name description 
@return description 
@throws fully-qualified-class-name description 
@deprecated 

Coding style

class AllTheColorsOfTheRainbow {
  int anIntegerRepresentingColors;
  void changeTheHueOfTheColor(int newHue) {
    // ...
  }
  // ...
} 

Operators

Precedence

Assignment

Aliasing during method calls

Mathematical operators

Unary minus and plus operators

Auto increment and decrement

Relational operators

Logical operators

Short-circuiting

Literals

• Exponential notation
  float f4 = 1e-43f;

Bitwise operators

Shift operators

• The left-shift operator (<<) inserts zeroes at the lower-order bits.
• The signed right shift (>>) uses sign extension:
  If the value is positive, zeroes are inserted at the higher-order bits;
  if the value is negative, ones are inserted at the higher-order bits.
• The unsigned right shift (>>>) uses zero extension:
  Regardless of the sign, zeroes are inserted at the higher-order bits.

Ternary if-else operator

String operator + and +=

Casting operators

Truncation and rounding

• Casting from a float or double to an integral value always truncates the number.
• If instead you want the result to be rounded, use the round( ) methods in java.lang.Math.

Promotion

• You’ll discover that if you perform any mathematical or bitwise operations on primitive data types that are smaller than an int (that is, char, byte, or short), those values will be
  promoted to int before performing the operations, and the resulting value will be of type int.
• In general, the largest data type in an expression is the one that determines the size of the result of that expression.

Java has no “sizeof”

Controlling Execution

if-else

Iteration

• do-while
• for

Foreach syntax

• Java SE5 introduces a new and more succinct for syntax, for use with arrays and container.
• It is the same as range-based for in cpp11.

return

break and continue

The infamous “goto”

label1:
outer-iteration {
  inner-iteration {
  //...
  break; // (1)
  //...
  continue; // (2)
  //...
  continue label1; // (3)
  //...
  break label1; // (4)
  }
} 

1. A plain continue goes to the top of the innermost loop and continues.
2. A labeled continue goes to the label and reenters the loop right after that label.
3. A break “drops out of the bottom” of the loop.
4. A labeled break drops out of the bottom of the end of the loop denoted by the label.

switch

switch(integral-selector) {
  case integral-value1 : statement; break;
  case integral-value2 : statement; break;
  case integral-value3 : statement; break;
  case integral-value4 : statement; break;
  case integral-value5 : statement; break;
  // ...
  default: statement;
} 

• This is the conventional way to build a switch statement, but the break is optional.
• If it is missing, the code for the following case statements executes until a break is encountered.
• Although you don’t usually want this kind of behavior, it can be useful to an experienced programmer.

Initialization & Cleanup

Guaranteed initialization with the constructor

Method overloading

Default constructors

The this keyword

The this keyword which can be used only inside a non-static method produces the reference to the object that the method has been called for.

Calling constructors from constructors

The meaning of static

• It means that there is no this for that particular method.
• You cannot call non-static methods from inside static methods (although the reverse is possible).
• You can call a static method for the class itself, without any object.

Cleanup: finalization and garbage collection

• The garbage collector only knows how to release memory allocated with new, so it won’t know how to release the object’s “special” memory.
• To handle this case, Java provides a method called finalize() that you can define for your class.
• When the garbage collector is ready to release the storage used for your object, it will first call finalize(), and only on the next garbage-collection pass will it reclaim the object’s memory.

• So if you choose to use finalize(), it gives you the ability to perform some important cleanup at the time of garbage collection.

  1. Your objects might not get garbage collected.
  2. Garbage collection is not destruction.
  3. Garbage collection is only about memory.

You must perform cleanup

• You should never call finalize() directly, so that’s not a solution.
• If you want some kind of cleanup performed other than storage release, you must still explicitly call an appropriate method in Java, which is the equivalent of a C++ destructor without the convenience.

The termination condition

finalizie() can be used as the verification of the termination condition of an object.

How a garbage collector works

Adaptive generational stop-and-copy mark-and-sweep.

Member initialization

Specifying initialization

public class InitialValues2 {
  boolean bool = true;
  char ch = ‘x’;
  byte b = 47;
  short s = 0xff;
  int i = 999;
  long lng = 1;
  float f = 3.14f;
  double d = 3.14159;
}

Constructor initialization

Order of initialization

• The order of initialization is determined by the order that the variables are defined within the class.
• The automatic initialization happens before the constructor is entered.

static data initialization

To summarize the process of creating an object, consider a class called Dog:

1. Even though it doesn’t explicitly use the static keyword, the constructor is actually a static method.
   So the first time an object of type Dog is created, or the first time a static method or static field of class Dog is accessed, the Java interpreter must locate Dog.class, which it does by searching through the classpath.
2. As Dog.class is loaded (creating a Class object, which you’ll learn about later), all of its static initializers are run.
   Thus, static initialization takes place only once, as the Class object is loaded for the first time.
3. When you create a new Dog(), the construction process for a Dog object first allocates enough storage for a Dog object on the heap.
4. This storage is wiped to zero, automatically setting all the primitives in that Dog object to their default values (zero for numbers and the equivalent for boolean and char) and the references to null.
5. Any initializations that occur at the point of field definition are executed.
6. Constructors are executed.

Explicit static initialization

public class Spoon {
  static int i;
  static {
    i = 47;
  }
}

Non-static instance initialization

public class Mugs {
  Mug mug1;
  Mug mug2;
  {
    mug1 = new Mug(1);
    mug2 = new Mug(2);
    print("mug1 & mug2 initialized");
  } 
}

Array initialization

int[] a = { 1, 2, 3, 4, 5 }; 

Variable argument lists

In Java SE5, however, this long-requested feature was finally added, so you can now use
ellipses to define a variable argument list.

public class NewVarArgs {
  static void printArray(Object... args) {
    for(Object obj : args)
    System.out.print(obj + " ");
    System.out.println();
  } 
}

Enumerated types

public enum Spiciness {
  NOT, MILD, MEDIUM, HOT, FLAMING
} 
public class EnumOrder {
  public static void main(String[] args) {
  for(Spiciness s : Spiciness.values())
    System.out.println(s + ", ordinal " + s.ordinal());
  }
} 
/* Output:
NOT, ordinal 0
MILD, ordinal 1
MEDIUM, ordinal 2
HOT, ordinal 3
FLAMING, ordinal 4 
*/

Access Control

package: the library unit

Code organization

Creating unique package names

Using imports to change behavior

Java access specifiers

• package access
• public: interface access
• private: you can’t touch that!
• protected: inheritance access

Interface and implementation

Reusing Classes

Composition syntax

class WaterSource {
  private String s;
  WaterSource() {
    System.out.println("WaterSource()");
    s = "Constructed";
  }
  public String toString() { return s; }
} 

Inheritance syntax

class Art {
  Art() { print("Art constructor"); }
}
class Drawing extends Art {
  Drawing() { print("Drawing constructor"); }
}
public class Cartoon extends Drawing {
  public Cartoon() { print("Cartoon constructor"); }
  public static void main(String[] args) {
    Cartoon x = new Cartoon();
  }
} 
/* Output:
Art constructor
Drawing constructor
Cartoon constructor 
*/

Constructors with arguments

• If you want to call a base-class constructor that has an argument,
• you must explicitly write the calls to the base-class constructor using
  the super keyword and the appropriate argument list.

class Game {
  Game(int i) {
    print("Game constructor");
  }
}
class BoardGame extends Game {
  BoardGame(int i) {
    super(i);
    print("BoardGame constructor");
  }
}
public class Chess extends BoardGame {
  Chess() {
    super(11);
    print("Chess constructor");
  }
  public static void main(String[] args) {
    Chess x = new Chess();
  }
} 
/* Output:
Game constructor
BoardGame constructor
Chess constructor 
*/

Delegation

public class SpaceShipDelegation { 
  private String name;
  private SpaceShipControls controls = new SpaceShipControls();
  public SpaceShipDelegation(String name) {
    this.name = name;
  }
  // Delegated methods:
  public void back(int velocity) {
    controls.back(velocity);
  }
  public void down(int velocity) {
    controls.down(velocity);
  }
  public void forward(int velocity) {
    controls.forward(velocity);
  }
  public void left(int velocity) {
    controls.left(velocity);
  }
  public void right(int velocity) {
    controls.right(velocity);
  }
  public void turboBoost() {
    controls.turboBoost();
  }
  public void up(int velocity) {
    controls.up(velocity);
  }
}

Guaranteeing proper cleanup

• If you want cleanup to take place, make your own cleanup methods and don’t use on finalize().

• In general, you should follow the same form that is imposed by a C++ compiler on its destructors:
  First perform all of the cleanup work specific to your class, in the reverse order of creation. (In general, this requires that base-class elements still be viable.)
  Then call the base-class cleanup method.

Name hiding

• If a Java base class has a method name that’s overloaded several times, redefining that method name in the derived class will not hide any of the base-class versions (unlike C++).
• Thus overloading works regardless of whether the method was defined at this level or in a base class.
• Java SE5 has added the @Override annotation, which is not a keyword but can be used as if it were.
• The compiler will produce an error message if you accidentally overload instead of overriding when using @Override.

Choosing composition vs. inheritance

protected

It is the same as C++, but provide package access.

Upcasting

The final keyword

final data

1. It can be a compile-time constant that won’t ever change.
2. It can be a value initialized at run time that you don’t want changed.

final arguments

final methods

1. To prevent any inheriting class from changing its meaning.
2. To allow the compiler to turn any calls to that method into inline calls.
3. With Java SE5/6, you should let the compiler and JVM handle efficiency issues and make a method final only if you want to explicitly prevent overriding.

final and private

• Any private methods in a class are implicitly final. Because you can’t access a private method, you can’t override it.
• You can add the final specifier to a private method, but it doesn’t give that method any extra meaning (such as polymorphism).

final classes

• When you say that an entire class is final (by preceding its definition with the final keyword), you state that you don’t want to inherit from this class or allow anyone else to do so.
• In other words, for some reason the design of your class is such that there is never a need to make any changes, or for safety or security reasons you don’t want subclassing.

Initialization and class loading

• In more traditional languages, programs are loaded all at once as part of the startup process.
  This is followed by initialization, and then the program begins. The process of initialization in these languages must be carefully controlled so that the order of initialization of statics doesn’t cause trouble.
  C++, for example, has problems if one static expects another static to be valid before the second one has been initialized.
• In general, you can say that “class code is loaded at the point of first use.”
  This is usually when the first object of that class is constructed, but loading also occurs when a static field or static method is accessed.
  (The constructor is also a static method even though the static keyword is not explicit. So to be precise, a class is first loaded when any one of its static members is accessed.)

Polymorphism

Method-call binding

• All method binding in Java uses late binding unless the method is static or final (private methods are implicitly final).
• In most cases it won’t make any overall performance difference in your program, so it’s best to only use final as a design decision, and not as an attempt to improve performance.

Pitfall: “overriding” private methods

Pitfall: fields and static methods

• Only ordinary method calls can be polymorphic.
  Fields can't be, i.e., the access will be resolved at compile time.
• If a method is static, it doesn’t behave polymorphically.

Behavior of polymorphic methods inside constructors

• Do as little as possible to set the object into a good state.
• Don’t call any other methods in this class.” The only safe methods to call inside a constructor are those that are final in the base class. (This also applies to private methods, which are automatically final.)

Covariant return types

Java SE5 adds covariant return types, which means that an overridden method in a derived class can return a type derived from the type returned by the base-class method.

Designing with inheritance

A general guideline is “Use inheritance to express differences in behavior, and fields to
express variations in state.”

Substitution vs. extension

"is-a" vs "is-like-a"

Downcasting and runtime type information

• It looks like you’re just performing an ordinary parenthesized cast, at run time this cast is checked to ensure that it is in fact the type you think it is.
• If it isn’t, you get a ClassCastException.
• This act of checking types at run time is called runtime type identification (RTTI)

Interfaces

Abstract classes and methods

abstract class Instrument {
  // You can create an abstract class with no abstract methods
}

Interfaces

interface Instrument { // Automatically public 
  // Compile-time constant:
  int VALUE = 5; // static & final
  // Cannot have method definitions:
  void play(Note n); // Automatically public
  void adjust();
}
class Wind implements Instrument {
  public void play(Note n) {} // Must be public
  public String toString() {}
  public void adjust() {}

Complete decoupling

public interface Processor {
  String name();
  Object process(Object input);
}
// Strategy pattern
public class Apply {
  public static void process(Processor p, Object s) {
    print("Using Processor " + p.name());
    print(p.process(s));
  }
} 
// If you cannot modify the class, use Adapter pattern
public class Filter {
  public String name() {
    return getClass().getSimpleName();
  }
  public Waveform process(Waveform input) { return input; }
}
class FilterAdapter implements Processor {
  Filter filter;
  public FilterAdapter(Filter filter) {
    this.filter = filter;
  }
  public String name() { return filter.name(); }
  public Waveform process(Object input) {
    return filter.process((Waveform)input); // Delegation
  }
}
public class FilterProcessor {
  public static void main(String[] args) {
    Waveform w = new Waveform();
    Apply.process(new FilterAdapter(new Filter(), w);
  }
}

Extending an interface with inheritance

interface Monster {
  void menace();
}
interface DangerousMonster extends Monster {
  void destroy();
}
class DragonZilla implements DangerousMonster {
  public void menace() {}
  public void destroy() {}
}

Initializing fields in interfaces

public interface RandVals {
  Random RAND = new Random(47);
  int RANDOM_INT = RAND.nextInt(10);
  long RANDOM_LONG = RAND.nextLong() * 10;
  float RANDOM_FLOAT = RAND.nextLong() * 10;
  double RANDOM_DOUBLE = RAND.nextDouble() * 10;
}

Nesting interfaces

• In particular, notice that when you implement an interface, you are not required to implement any interfaces nested within.
• Also, private interfaces cannot be implemented outside of their defining classes.

Interfaces and factories

Factory Method design pattern

interface Game { boolean move(); }
interface GameFactory { Game getGame(); }
class Checkers implements Game {
  private int moves = 0;
  private static final int MOVES = 3;
  public boolean move() {
    print("Checkers move " + moves);
    return ++moves != MOVES;
  }
}
class CheckersFactory implements GameFactory {
  public Game getGame() { return new Checkers(); }
} 
public class Games {
  public static void playGame(GameFactory factory) {
  Game s = factory.getGame();
  while(s.move());
} 

Summary

• It is tempting to decide that interfaces are good, and therefore you should always choose
  interfaces over concrete classes.
• Of course, almost anytime you create a class, you could instead create an interface and a factory
• An appropriate guideline is to prefer classes to interfaces. Start with classes, and if it becomes clear that interfaces are necessary, then refactor.

Inner Classes

Creating inner classes

The link to the outer class

public class Sequence {
  private Object[] items;
  private int next = 0;
  public Sequence(int size) { items = new Object[size]; }
  public void add(Object x) {
    if(next < items.length)
    items[next++] = x;
  }
  private class SequenceSelector implements Selector {
    private int i = 0;
    public boolean end() { return i == items.length; }
    public Object current() { return items[i]; }
    public void next() { if(i < items.length) i++; }
  }
  public Selector selector() {
    return new SequenceSelector();
} 

Using .this and .new

public class DotThis {
  public class Inner {
  public DotThis outer() {
    return DotThis.this;
    // A plain "this" would be Inner’s "this"
  }
} 
public class DotNew {
  public class Inner {}
  public static void main(String[] args) {
    DotNew dn = new DotNew();
    DotNew.Inner dni = dn.new Inner();
  }
}

Inner classes and upcasting

With interface, it can hide the implementation.

Inner classes in methods and scopes

Anonymous inner classes

public class Wrapping {
  private int i;
  public Wrapping(int x) { i = x; }
  public int value() { return i; }
}
public class Parcel8 { 
  public Wrapping wrapping(int x) {
    final int y = 47;
    // Base constructor call:
    return new Wrapping(x) { // Pass constructor argument.
      public int value() {
        return super.value() * y;
      }
    }
  }; // Semicolon required
} 

Factory Method revisited

interface Game { boolean move(); }
interface GameFactory { Game getGame(); }
class Checkers implements Game {
  private int moves = 0;
  private static final int MOVES = 3;
  public boolean move() {
    print("Checkers move " + moves);
    return ++moves != MOVES;
  }
  private static GameFactory factory = new GameFactory() {
    public Game getGame() { return new Checkers(); }
  };
  public static GameFactory gameFactory() {
    return factory;
  }
}
public class Games {
  public static void playGame(GameFactory factory) {
  Game s = factory.getGame();
  while(s.move());
} 

Nested classes

1. A static inner class is called a nested class
2. You don’t need an outer-class object in order to create an object of a nested class.
3. You can’t access a non-static outer-class object from an object of a nested class

Classes inside interfaces

Reaching outward from a multiply nested class

Why inner classes?

1. The inner class can have multiple instances, each with its own state information that is independent of the information in the outer-class object.
2. In a single outer class you can have several inner classes, each of which implements the same interface or inherits from the same class in a different way.
3. The point of creation of the inner-class object is not tied to the creation of the outerclass object.
4. There is no potentially confusing "is-a" relationship with the inner class; it’s a separate entity.

Closures & callbacks

interface Incrementable {
  void increment();
}
// If your class must implement increment() in
// some other way, you only can use an inner class:
class Callee2 extends MyIncrement {
  private int i = 0;
  public void increment() {
    super.increment();
    i++;
    print(i);
  }
  private class Closure implements Incrementable {
    public void increment() {
      // Specify outer-class method, otherwise
      // you’d get an infinite recursion:
      Callee2.this.increment();
    }
  }
  Incrementable getCallbackReference() {
    return new Closure();
  }
}
class Caller {
  private Incrementable callbackReference;
  Caller(Incrementable cbh) { callbackReference = cbh; }
  void go() { callbackReference.increment(); }
} 

Inner classes & control frameworks

public class GreenhouseControls extends Controller { 
  private boolean light = false;
  public class LightOn extends Event {
    public LightOn(long delayTime) { super(delayTime); }
    public void action() {
      light = true;
    }
    public String toString() { return "Light is on"; }
  }
  public class LightOff extends Event {
    public LightOff(long delayTime) { super(delayTime); }
    public void action() {
      light = false;
    }
  public String toString() { return "Light is off"; }
} 

Inheriting from inner classes

class WithInner {
  class Inner {}
}
public class InheritInner extends WithInner.Inner {
  //! InheritInner() {} // Won’t compile
  InheritInner(WithInner wi) {
    wi.super();
  }
  public static void main(String[] args) {
    WithInner wi = new WithInner();
    InheritInner ii = new InheritInner(wi);
  }
}

Can inner classes be overridden?

class Egg2 {
  protected class Yolk {
    public Yolk() { print("Egg2.Yolk()"); }
    public void f() { print("Egg2.Yolk.f()");}
  }
  private Yolk y = new Yolk();
  public Egg2() { print("New Egg2()"); }
  public void insertYolk(Yolk yy) { y = yy; }
  public void g() { y.f(); }
}
public class BigEgg2 extends Egg2 {
  public class Yolk extends Egg2.Yolk {
    public Yolk() { print("BigEgg2.Yolk()"); }
    public void f() { print("BigEgg2.Yolk.f()"); }
  }
  public BigEgg2() { insertYolk(new Yolk()); }
  public static void main(String[] args) {
    Egg2 e2 = new BigEgg2();
    e2.g();
  }
}

Local inner classes

Inner-class identifiers

• The names of inner-class files/classes have a strict formula: the name of the enclosing class, followed by a $, followed by the name of the inner class.
• If inner classes are anonymous, the compiler simply starts generating numbers as inner-class identifiers. If inner classes are nested within inner classes, their names are simply appended after a $ and the outer-class identifier(s).

Holding Your Objects

Generics and type-safe containers

Adding groups of elements

List

• ArrayList
• LinkedList

Iterator

• Collection.iterator()
• next()
• hasNext()
• remove()

ListIterator

• hasPrevious()
• previous()

Stack

Set

Set<Integer> intset = new HashSet<Integer>(); 
SortedSet<Integer> intset = new TreeSet<Integer>(); 

Map

• HashMap
• LinkedHashMap

Queue

PriorityQueue

Collection vs. Iterator

Producing an Iterator is the least-coupled way of connecting a sequence to a method that consumes that sequence, and puts far fewer constraints on the sequence class than does implementing Collection.

public class CollectionSequence
extends AbstractCollection<Pet> {
  private Pet[] pets = Pets.createArray(8);
  public int size() { return pets.length; }
  public Iterator<Pet> iterator() {
    return new Iterator<Pet>() {
      private int index = 0;
      public boolean hasNext() {
        return index < pets.length;
      }
      public Pet next() { return pets[index++]; }
      public void remove() { // Not implemented
        throw new UnsupportedOperationException();
      }
    };
  }
} 

class PetSequence {
  protected Pet[] pets = Pets.createArray(8);
}
public class NonCollectionSequence extends PetSequence {
  public Iterator<Pet> iterator() {
    return new Iterator<Pet>() {
      private int index = 0;
      public boolean hasNext() {
        return index < pets.length;
      }
      public Pet next() { return pets[index++]; }
      public void remove() { // Not implemented
        throw new UnsupportedOperationException();
      }
    };
  }
}

Foreach and iterators

Java SE5 introduced a new interface called Iterable which contains an iterator() method to produce an Iterator, and the Iterable interface is what foreach uses to move through a sequence. So if you create any class that implements Iterable, you can use it in a foreach statement.

The Adapter Method idiom

class ReversibleArrayList<T> extends ArrayList<T> {
  public ReversibleArrayList(Collection<T> c) { super(c); }
    public Iterable<T> reversed() {
      return new Iterable<T>() {
        public Iterator<T> iterator() {
          return new Iterator<T>() {
            int current = size() - 1;
          public boolean hasNext() { return current > -1; }
          public T next() { return get(current--); }
          public void remove() { // Not implemented
            throw new UnsupportedOperationException();
          }
        };
      }
    };
  }
} 
ReversibleArrayList<String> ral =
  new ReversibleArrayList<String>(
    Arrays.asList("To be or not to be".split(" "))); 
for(String s : ral.reversed())
  System.out.print(s + " "); 

Error Handling with Exceptions

Catching an exception

The try block and exception handler

try {
  // Code that might generate exceptions
} catch(Type1 id1)|{
  // Handle exceptions of Type1
} catch(Type2 id2) {
  // Handle exceptions of Type2
} catch(Type3 id3) {
  // Handle exceptions of Type3
}

The stack trace

Maybe the best practice for logging stacktrace of log4j2 in some version.

logger.info("{}", e.toString(), e);

Performing cleanup with finally

try {
  // The guarded region: Dangerous activities
  // that might throw A, B, or C
} catch(A a1) {
  // Handler for situation A
} catch(B b1) {
  // Handler for situation B
} catch(C c1) {
  // Handler for situation C
} finally {
  // Activities that happen every time
} 

Constructors

Exception chaining and converting checked to unchecked exceptions

try {
  // ... to do something useful
} catch(IDontKnowWhatToDoWithThisCheckedException e) {
  throw new RuntimeException(e);
}

You can also use e.getCause() to extract the originating exceptions.

Exception guidelines

1. Handle problems at the appropriate level. (Avoid catching exceptions unless you know what to do with them.)
2. Fix the problem and call the method that caused the exception again.
3. Patch things up and continue without retrying the method.
4. Calculate some alternative result instead of what the method was supposed to produce.

Strings

Immutable Strings

Overloading ‘+’ vs. StringBuilder

• StringBuilder was introduced in Java SE5.
• Prior to this, Java used StringBuffer, which ensured thread safety (see the Concurrency chapter) and so was significantly more expensive. Thus, string operations in Java SE5/6 should be faster.
• You can assume that you should just use Strings everywhere and that the compiler will
  make everything efficient.

Unintended recursion

public class InfiniteRecursion {
  public String toString() {
    return " InfiniteRecursion address: " + this + "\n";
  } 
}

Formatting output

System.out.format("Row 1: [%d %f]\n", x, y);
// A nostalgic way
System.out.printf("Row 1: [%d %f]\n", x, y); 
Formatter formatter = new Formatter(System.out);
formatter.format("%s The Turtle is at (%d,%d)\n", name, x, y); 
// It can come in handy when you only need to call format() once.
String.format("%s The Turtle is at (%d,%d)\n", name, x, y);

Regular expressions

java.util.regex.*

Basics

• In other languages, \\ means "I want to insert a plain old (literal) backslash in the regular expression. Don’t give it any special meaning."
• In Java, \\ means "I’m inserting a regular expression backslash, so that the following character has special meaning."
• For example, if you want to indicate a digit, your regular expression string will be \\d. * If you want to insert a literal backslash, you say \\\\.
• However, things like newlines and tabs just use a single backslash: \n\t.

Creating regular expressions

Quantifiers

Pattern and Matcher

Replace operations

Regular expressions and Java I/O

Scanning with regular expressions

StringTokenizer

Efficiency?

• Before regular expressions (in J2SE1.4) or the Scanner class (in Java SE5), the way to split a string into parts was to "tokenize" it with StringTokenizer.
• With regular expressions or Scanner objects, you can also split a string into parts using more complex patterns—something that’s difficult with StringTokenizer.
• It seems safe to say that the StringTokenizer is obsolete.

Type Information

The need for RTTI

The Class object

• What if you have a special programming problem that’s easiest to solve if you know the
  exact type of a generic reference?
• For example, suppose you want to allow your users to highlight all the shapes of any particular type by turning them a special color.

The Class object

// Static method
Class.forName(String)
// Fully qualified name
getName()
// Fully qualified name (introduced in Java SE5) 
getCanonicalName() 
getSimpleName()
getInterfaces()
islnterface()
getSuperClass()

Class literals

Generic class references

Class intClass = int.class;
Class<Integer> genericIntClass = int.class;
genericIntClass = Integer.class; // Same thing
Class<Number> genericNumberClass = int.class; 
// The wildcard symbol is ‘?’, and it indicates "anything."
Class<?> intClass = int.class;
Class<? extends Number> bounded = int.class;

public class FilledList<T> {
  private Class<T> type;
  public FilledList(Class<T> type) { this.type = type; }
  public List<T> create(int nElements) {
    List<T> result = new ArrayList<T>();
    try {
      for(int i = 0; i < nElements; i++)
      result.add(type.newInstance());
    } catch(Exception e) {
      throw new RuntimeException(e);
    }
    return result;
  }
  public static void main(String[] args) {
    FilledList<CountedInteger> fl =
    new FilledList<CountedInteger>(CountedInteger.class);
    System.out.println(fl.create(15));
  }
} 

New cast syntax

// Java SE5 introduces the two below.
Class.cast()
Class.asSubclass()

Checking before a cast

Using class literals

A dynamic instanceof

Class.isisInstance vs keyword instanceof

Registered factories

class Part {
  public String toString() {
    return getClass().getSimpleName();
  }
  static List<Factory<? extends Part>> partFactories =
    new ArrayList<Factory<? extends Part>>();
  static {
    // Collections.addAll() gives an "unchecked generic
    // array creation ... for varargs parameter" warning.
    partFactories.add(new FuelFilter.Factory());
    // ...
  }
  private static Random rand = new Random(47);
  public static Part createRandom() {
    int n = rand.nextInt(partFactories.size());
    return partFactories.get(n).create();
  }
} 
class Filter extends Part {}
class FuelFilter extends Filter {
  // Create a Class Factory for each specific type:
  public static class Factory
  implements typeinfo.factory.Factory<FuelFilter> {
    public FuelFilter create() { return new FuelFilter(); }
  }
} 

instanceof vs. Class equivalence

Reflection: runtime class information

A class method extractor

Class.getMethods()

Dynamic proxies

// Proxy Pattern
class RealObject implements Interface {
  public void doSomething() { print("doSomething"); }
  public void somethingElse(String arg) {
    print("somethingElse " + arg);
  }
}
class SimpleProxy implements Interface {
  private Interface proxied;
  public SimpleProxy(Interface proxied) {
    this.proxied = proxied;
  }
  public void doSomething() {
    print("SimpleProxy doSomething");
    proxied.doSomething();
  }
  public void somethingElse(String arg) {
    print("SimpleProxy somethingElse " + arg);
    proxied.somethingElse(arg);
  }
}
class SimpleProxyDemo {
  public static void consumer(Interface iface) {
    iface.doSomething();
    iface.somethingElse("bonobo");
  }
  public static void main(String[] args) {
    consumer(new RealObject());
    consumer(new SimpleProxy(new RealObject()));
  }
}

class DynamicProxyHandler implements InvocationHandler {
  private Object proxied;
  public DynamicProxyHandler(Object proxied) {
    this.proxied = proxied;
  }
  public Object
  invoke(Object proxy, Method method, Object[] args)
  throws Throwable {
    System.out.println("**** proxy: " + proxy.getClass() +
      ", method: " + method + ", args: " + args);
    if(args != null)
      for(Object arg : args)
        System.out.println(" " + arg);
    return method.invoke(proxied, args);
  }
}
class SimpleDynamicProxy {
  public static void consumer(Interface iface) {
    iface.doSomething();
    iface.somethingElse("bonobo");
  }
  public static void main(String[] args) {
    RealObject real = new RealObject();
    consumer(real);
    // Insert a proxy and call again:
    Interface proxy = (Interface)Proxy.newProxyInstance(
      Interface.class.getClassLoader(),
      new Class[]{ Interface.class },
      new DynamicProxyHandler(real));
    consumer(proxy);
  }
}

Null Objects

public interface Null {} 
class Person {
  public final String first;
  public final String last;
  public final String address;
  // etc.
  public Person(String first, String last, String address){
    this.first = first;
    this.last = last;
    this.address = address;
  }
  public String toString() {
    return "Person: " + first + " " + last + " " + address;
  }
  public static class NullPerson
  extends Person implements Null {
    private NullPerson() { super("None", "None", "None"); }
    public String toString() { return "NullPerson"; }
  }
  public static final Person NULL = new NullPerson();
}

Mock Objects & Stubs

A Stub is a sophisticated object that does lots of things.
You usually create lots of small, simple Mock Objects if you need to do many things.

Interfaces and type information

• It’s possible to reach in and call all of the methods using reflection, even private methods.

  static void callHiddenMethod(Object a, String methodName)
  throws Exception {
    Method g = a.getClass().getDeclaredMethod(methodName);
    g.setAccessible(true);
    g.invoke(a);
  } 

• You may think that you can prevent this by only distributing compiled code, but that’s no
  solution.
  All you must do is run javap, which is the decompiler that comes with the JDK. javap -private Class

Summary

The intent of OOP is to use polymorphic method calls everywhere you can, and RTTI only when you must.

• For example, consider a class hierarchy representing musical instruments.
• Suppose you want to clear the spit valves of all the appropriate instruments in your orchestra.
• One option is to put a clearSpitValve() method in the base class Instrument, but this is confusing because it implies that Percussion, Stringed and Electronic instruments also have spit valves.
• RTTI provides a much more reasonable solution because you can place the method in the specific class where it’s appropriate (Wind, in this case).
• At the same time, you may discover that there’s a more sensible solution—here, a preparelnstrument() method in the base class.

Generics

Arrays

Containers in Depth

I/O

Enumerated Types

Annotations

Concurrency

• This is one of the strongest arguments for studying concurrency: If you ignore it, you’re likely to get bitten.
• With concurrency, you’re on your own, and only by being both suspicious and aggressive can you write multithreaded code in Java that will be reliable.
• The problems that you solve with concurrency can be roughly classified as "speed" and
  "design manageability".

The many faces of concurrency

Faster execution

Improving code design

Some types of problems, such as gui, simulation, are difficult to solve without support for concurrency.

Basic threading

• A thread is a single sequential flow of control within a process.
• A single process can thus have multiple concurrently executing tasks, but you program as if each task has the CPU to itself.
• An underlying mechanism divides up the CPU time for you, but in general, you don’t need to think about it.

Using Executors

Executors are the preferred method for starting tasks in Java SE5/6.
Runnable ExecutorService.execute()

// A CachedThreadPool will generally create as many threads as it needs,
// then will stop creating new threads as it recycles the old ones, 
// so it’s a reasonable first choice as an Executor. 
Executors.newCachedThreadPool()
// You limit the number of threads.
Executors.newFixedThreadPool()
// A SingleThreadExecutor is like a FixedThreadPool with a size of one thread.
Executors.newSingleThreadExecutor()

Producing return values from tasks

Callable Future<> = ExecutorService.submit()

The overloaded Executors.callable() method takes a Runnable and produces a
Callable.
ExecutorService has some invoke methods that run collections of Callable objects.

Sleeping

// Old-style:
// Thread.sleep(100);
// Java SE5/6-style:
TimeUnit.MILLISECONDS.sleep(100); 

yield() and sleep() allows the thread scheduler to switch to another thread.

Priority

• Thread.currentThread().setPriority(priority)
• Although the JDK has 10 priority levels, this doesn’t map well to many operating systems.
• The only portable approach is to stick to MAX_PRIORITY, NORM_PRIORITY, and MIN_PRIORITY when you’re adjusting priority levels.
• yeild() give a hint to the threadscheduling mechanism that you’ve done enough and that some other task might as well have the CPU.

Daemon threads

public class DaemonThreadFactory implements ThreadFactory {
  public Thread newThread(Runnable r) {
    Thread t = new Thread(r);
    t.setDaemon(true);
    return t;
  }
} 
ExecutorService exec = Executors.newCachedThreadPool(
  new DaemonThreadFactory());
for(int i = 0; i < 10; i++)
  exec.execute(new DaemonFromFactory()); 

The Daemon thread is set to daemon mode and it then spawns a bunch of other threads—which
are implicitly set to daemon mode.

Terminology

To clarify these discussions, I shall attempt to use the term "task" when I am describing the work that is being done, and "thread" only when I am referring to the specific mechanism that’s driving the task.

Graphical User Interfaces

omitted