Though Eclipse Monkey is a tool under project Dash, which seems to used by those committers of Eclipse community, it sounds good for the automation of routine programming tasks. Anyway, I need check it out for my benefits. Purpose:
Defines a higher-level interface to hide subsystem's complexities and provides an easy interface for client to use.

Case study:
Compiler subsystem

Structure:
-- The facade and backend classes(subsystem classes) are in a separate package from the client.
-- The backend API is package-private
-- The facade API is public.

Implementation:
consider following two issues when implementing a facade:
-- Reducing client-subsystem coupling.
-- Public versus private subsystem classes.

reference:
http://www.allapplabs.com/java_design_patterns/facade_pattern.htm
Purpose:
Attach additional responsiblities to an object dynamically, which thus provide a flexible alternative to subclassing for extending functionality.

Structure:
Typically, there will be a parameter to pass original object to decorator object in its constructor, then decorator can implement additional functions within its own interface and apply to original object.

when to use:

-- when subclassing is not avaible
-- when the responsibilities (for different functions) are required flexiable and dynamical
-- can not predict combination of extending functionality. (We can not design subclasses for all combination of potential additional functionalities at compile time)

reference:
Book: Design Pattern (GoF)
http://en.wikipedia.org/wiki/Decorator_pattern Purpose:
Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compostions of objects uniformly.

Structure:
The composite object contains other primitive objects(or say Components), and has the same operation as in those primitive objects. Thus we can operater the composite object with the same operations as a whole. Or in other word, composite object is a container of primitive ojects and itself is derived from same base (abstract) class as primitives, so that it can have same operations as primitives. Actually, we can say that the abstract class represents both primitives and their containers

Implementation:
-- Extend a base class that represents primitive objects. And the same operation(override function) will be implemented by iterating over that collection and invoking the appropriate method for each component in the collection.
-- Add & Remove function (for component collection) will be defined in base class, though it is meaninglessful for leaf classes.

reference:
http://www.javaworld.com/javaworld/jw-09-2002/jw-0913-designpatterns.html
http://www.codeproject.com/useritems/Composite.asp

example:
http://java.sun.com/blueprints/patterns/CompositeView.html Purpose:
Decouple an abstraction from its implementation so that the two can vary independently.

To think about this situation that an abstract class has two categories of inheritance. Each category can be a seperate hierarchical inheritance tree, if we derive all the subclasses from the abstract class, it will make complex when we need to get some sub-classes that contains facades from two categories. So we need seperate those subclasses into differenct categories, typically one into implementation hierarchy while another into abstraction hierarchy which can employ subclasses of implementation hierarchy. No matter how, the relationship between different hierarchies is a bridge. From this point, the bridge pattern design lets different hierarchies can evolve seperately.

The structure of the Adapter Pattern (object adapter) may look similar to the Bridge Pattern. However, the adapter is meant to change the interface of an existing object and is mainly intended to make unrelated classes work together.

reference:
book:"Design Patterns” Gamma et al.
http://en.wikipedia.org/wiki/Bridge_pattern
http://www.c-sharpcorner.com/Language/BridgePatternsinCSRVS.asp
http://www.codeproject.com/gen/design/bridge.asp
Purpose: Adapters are used to enable objects with different interfaces to communicate with each other which convert the interface of a class into another interface clients expect thus let classes work together without imcompatible interfaces problem.

Object Adapter:

-- use compositional technique
-- by composing interface B's instance within interface A (target interface, adapter) and implement interface A in terms of B's interface(adaptee). Interface A is Object Adapter which enables the client (the class or object to use Interface A) and the adaptee(Interface B) to be completely decoupled from each other.

Class Adapter:

-- use multiple inheritance
-- Notice that Java is not supporting true multiple inheritance, there must be one inheritance is from Java Interface(implementation) not Java class. So take above Object Adapter as example, if client want to access Interface B, the adpater Interface A will inherit from class(Class Adapter) which Client can access, and inherit the implementation of Interface B(Adaptee). So Interface A can have a funtion to call functions in Interface B, and so that Interface will not have an object of Interface B, that is the difference from Object Adapter method.

reference:
http://www.exciton.cs.rice.edu/JavaResources/DesignPatterns/adapter.htm

The main purpose of Factory method is to create objects. There will be one product instant creation function (Factory Method) in the abstract class(Creator), which can be overrided by its subclasses(Concrete Creator) and thus products can be specified in subclasses.

reference:

http://gsraj.tripod.com/design/creational/factory/factory.html
http://en.wikipedia.org/wiki/Factory_method_pattern
http://www.developer.com/java/other/article.php/626001
http://www.javacamp.org/designPattern/factory.html
在软件工程里，两者并不矛盾。只是侧重点会不一样，根据每个人的职位。如果我是一个构架师，我会偏重在前者，如果我是一个模块程序员，我会偏重后者。

最近，在看两本书：
《Code Complete》
《Design Pattern》

两本都是很经典的书。尤其是后者，由著名的“四人帮”(GoF:Gang of Four)所著。是在软件总体设计和详细设计时应该好好参照的一本书。而前者，这是注重实效编程(Pragmatic Programming)的一本启发性的书。

在不断追求最新技术的今天，静下心来读这两本书，尤其前者启发性的书，往往获益匪浅。温故而知新。 I feel interested in Rail, which is web-application and persistence framework that includes everything needed to create database-backed web-applications according to the Model-View-Control pattern of separation.

here is good article for getting start with Rails on my Linux machine.
Here are some hints for difference between abstract classes and interfaces

1. Use Interface if something will change frequently in design
2. If the methods can be determined and implemented, use abstract classes to encapsulate them as methods of base classes and therefore can be inherited by subclasses.
3. If you just want to declare some methods in your design which allows to be devoloped from scratch later into different classes, the interface is best choice.
4. if need provide more common data structure, use abstract classes as base class.
5. if want to add your code to other existing third party class for later potential requirement, interface is good to choose.
6. Interfaces are often used to describe certain functionality of classes, thus one class can get multi-funcationlity from multiple interfaces (multiple inheritance), while an abstract class, try to describe a class's general attributes and functionalities which can be reused or re-implemented by its subclasses.
7. in other word, Abstract class want to say is-a proposition, while Interface want to say -able or can-do proposition.

reference:
http://mindprod.com/jgloss/interfacevsabstract.html
http://www.javaworld.com/javaworld/javaqa/2001-04/03-qa-0420-abstract.html

Default Key Bindings provided by Eclipse
1. Ctrl & Shift &  T: Open type.
2. Ctrl &  Shift -  R:Open resource
3. F3 :Open declaration
4. Ctrl & Shift &  G: Open references
5. Alt  &  Up/Down Arrow : Moves the line up/down
6. Alt &  Left/Right Arrow : Moves sequentially to the last edited location

Customized Key Bindings:
1. F4 : Close Project
2. Shift & F4 : Open Project
3. Ctrl  & + : Generate Getter Setters
4. Ctrl & Alt & k : Surround with try-catch Longer I use Java, more curiously I wanna compare J2EE to .Net.
here is a good article (though a little bit old) to speak out my thinking.

If you have been using another computer language, you will always think about similar mechanism when using a new language, well, here is question when I want to use enum type in Java just like in C...

 

and here is good article to talk about that issue.