J2ee程序中的面向对象设计(OO Design Recommendations for J2EE Applications)--摘自ExpertOneOnOneJ2eeDes

1、使用接口降低程序的耦合性（Achieving Loose Coupling with Interfaces）

    虽然面向接口编程回比直接面向具体类编程增加一点点的复杂性，但是带来的好处却是巨大的。

2、尽量使用结合，而不是继承(Prefer Object Composition to Concrete Inheritance)

3、模版模式(The Template Method Design Pattern)

    模版模式是直接类继承的一种正确使用。但你知道一些算法的步骤，但是不清楚他们的具体操作就可以使用模版模式，将具体的操作留到以后实现。依赖倒转 (IOC/Inversion of Control)就是模版模式的一种使用，它通过模版模式，让框架代码调用用户自己的代码，而不是正常的那种用户代码去掉用框架的代码。模版模式特别适用 于框架设计。

4、策略模式(The Strategy Design Pattern)

6、观察者模式（The Observer Desing Pattern）

七、完善方法的参数（Consider Consolidating Method Parameters）

八、异常捕捉（Exception Handling – Checked or Unchecked Exceptions）

九、使用反射（Using Reflection）

public void vetoableChange(PropertyChangeEvent e) throws PropertyVetoException {
    if (e.getPropertyName() .equals ("email")) {
        String email = (String) e.getNewValue();
        validateEmail (email, e);
    }
    ...
    } else if (e.getPropertyName() .equals ("age")) {
        int age = ((Integer) e.getNewValue()).intValue();
        validateAge(age, e);
    }

    ...
  }

  public AbstractVetoableChangeListener() throws SecurityException {
    Method[] methods = getClass() .getMethods();
    for (int i = 0; i < methods.length; i++) {
        if (methods[i] .getName() .startsWith(VALIDATE_METHOD_PREFIX) &&
            methods[i] .getParameterTypes() .length == 2 &&
                PropertyChangeEvent.class.isAssignableFrom(methods[i].
                    getParameterTypes() [1])) {
            // We've found a potential validator
            Class[] exceptions = methods[i] .getExceptionTypes();
            // We don't care about the return type, but we must ensure that
            // the method throws only one checked exception, PropertyVetoException
            if (exceptions.length == 1 &&
                    PropertyVetoException.class.isAssignableFrom(exceptions[0])) {
                // We have a valid validator method
                // Ensure it's accessible (for example, it might be a method on an
                // inner class)
                methods[i].setAccessible(true);
                String propertyName = Introspector.decapitalize(methods[i].getName().
                substring(VALIDATE_METHOD_PREFIX.length()));
                validationMethodHash.put(propertyName, methods[i]);
                System.out.println(methods[i] + " is validator for property " +
                    propertyName);
            }
        }
    }
  }

public final void vetoableChange(PropertyChangeEvent e)
        throws PropertyVetoException {

    Method m = (Method) validationMethodHash.get(e.getPropertyName());

    if (m != null) {
        try {
            Object val = e.getNewValue();
            m.invoke(this, new Object[] { val, e });

        } catch (IllegalAccessException ex) {
            System.out.println("WARNING: can't validate. " +
                "Validation method "' + m + "' isn't accessible");

        } catch (InvocationTargetException ex) {
            // We don't need to catch runtime exceptions
            if (ex.getTargetException() instanceof RuntimeException)
                throw (RuntimeException) ex.getTargetException();
            // Must be a PropertyVetoException if it's a checked exception
            PropertyVetoException pex = (PropertyVetoException)
                ex.getTargetException();
            throw pex;
        }
    }
  }

    public Object getObject(String classname, Class requiredType)
        throws FactoryException {
    try {
        Class clazz = Class.forName(classname);
        Object o = clazz.newInstance();
        if (! requiredType.isAssignableFrom(clazz))
            throw new FactoryException("Class "' + classname +
                                                     "' not of required type " + requiredType);
        // Configure the object...
        return o;
    } catch (ClassNotFoundException ex) {
        throw new FactoryException("Couldn't load class "' + classname + ""', ex);
    } catch (IllegalAccessException ex) {
        throw new FactoryException("Couldn't construct class "' + classname + "': is the no arg constructor public?", ex);
    } catch (InstantiationException ex) {
        throw new FactoryException("Couldn't construct class "' + classname +
                                     "': does it have a no arg constructor", ex);
    }
  }
使用：    MyInterface mo = (MyInterface)
    beanFactory.getObject("com.mycompany.mypackage.MyImplementation",
    MyInterface.class);  

十、使用JavaBean取得灵活性（Using JavaBeans to Achieve Flexibility）

1. PropertyEditor

2. PropertyChangeListener

3. VetoableChangeListener

4. Introspector