David's Untitled Life

Learn JAVA5 Tiger from sample codes: avargs

Mon, 26 Jun 2006 14:02:40 +0100

public   class  Artist   {
    
    String[] others;
     /** */ /**  Creates a new instance of Artist  */ 
      public  Artist()   {
    } 
      public  Artist(String name,String ... others)  {
         for (String other : others)  {
            System.out.println(other);
        } 
         this .others  =  others;
    } 
      public   void  wildestMethod(Object ... objs)  {
     // this method will accept any arguments 
     } 
      public   static   void  main(String[] args)  {
        Artist artist  =   new  Artist( " You " ,  " 1 " ,  " 2 " );
        artist.wildestMethod( 1 ,  3.5 ,  " AA " ,  new  Artist());
    } 
    
}

Learn JAVA5 Tiger from sample codes: Auto Boxing and Unboxing

Thu, 22 Jun 2006 11:37:15 +0100

public class AutoBoxing {
    
    /** Creates a new instance of AutoBoxing */
    public AutoBoxing() {
    }
    public void boxingDemo(){
        //auto boxing
        Integer i = 0;
        float f = 1.66f;
        Float F = f;
        //auto unboxing
        Integer I = new Integer(1);
        int i2 = I;
        //null value test, it will case NullPointerException
        Integer I2 = null;
        int i3 = I2;
    }
    public void testOperator(){
        Integer i = 1;
        while(true){
            i++;
            System.out.println("Counter:"+i);
            if(i>5) break;
        }
    }
    public void testCompare(){
        //it's equal because -127~127 are immutable objects
        Integer i = 1;
        Integer i2 = 1;
        if(i == i2) System.out.println("1:Equal");
        else System.out.println("1:Not Equal");
        //it's not equal because j and j2 are different objects
        Integer j = 200;
        Integer j2 =200;
        if(j == j2) System.out.println("200:Equal");
        else System.out.println("200:Not Equal");
    }
    public void testControl(){
        Boolean flag = true;
        Integer i = 20;
        Integer j = 30;
        if(flag){
            System.out.println("Boolean affects");
        }
        if(i<j)
            System.out.println("Integer affects");
    }
    public void testMethod(double arg){
        System.out.println("public void testMethod(double arg) is invoked");
    }
    public void testMethod(Integer arg){
        System.out.println("public void testMethod2(Integer arg) is invoked");
    }
    public static void main(String args[]){
        AutoBoxing auto = new AutoBoxing();
        auto.testCompare();
        auto.testOperator();
        auto.testControl();
        int i = 1;
        // public void testMethod(Integer arg) wouldn't be invoked
        //because  public void testMethod(double arg) will be invoked in JDK1.4
        //Java tiger consider the backward capability
        auto.testMethod(i);
        auto.boxingDemo();
    }
    
}

Learn JAVA5 Tiger from sample codes: Enumerated

Thu, 22 Jun 2006 11:35:51 +0100

public enum User {
    Admin,User,Guest,Unknown   
}

public class Login {
    
    private User user;
    EnumMap<User,String> userName = new EnumMap<User, String>(User.class);
    /** Creates a new instance of Login */
    public Login() {
        userName.put(User.Admin, "Administrator");
        userName.put(User.User, "David");
        userName.put(User.Guest, "Steve");
    }
    public boolean isAdmin(User user){
        if(user.equals(User.Admin)){
            return true;
        }
        return false;
    }
    public void printUserRole(){
        User[] users = user.values();
        for(User u : user.values()){
            System.out.println(u.toString());
        }
    }
    public void isRole(User user){
        switch(user){
            case Admin:
                System.out.println("admin");
                break;
            case User:
                System.out.println("User");
                break;
            case Guest:
                System.out.println("Guest");
                break;
            default:
                System.out.println("unknow");
        }
    }
    public static void main(String[] args){
        Login login = new Login();
        System.out.println(login.isAdmin(User.Admin));
        login.printUserRole();
        login.isRole(User.User);
    }
    
}

Learn JAVA5 Tiger from sample codes: Generic

Tue, 20 Jun 2006 11:18:13 +0100

/**
 * public class Box<T extends Number>
 * @author david.duan
 */
public class Box<T> {
    
    //you can't have a static variable such as protected static List<T> list...
    protected List<T> contents;
    
    public Box( ) {
        contents = new ArrayList<T>( );
    }
    public int getSize( ) {
        return contents.size( );
    }
    public boolean isEmpty( ) {
        return (contents.size( ) == 0);
    }
    public void add(T o) {
        contents.add(o);
    }
    public T grab( ) {
        if (!isEmpty( )) {
            return contents.remove(0);
        } else
            return null;
    }
    public static void main(String[] args){
        Box<String> box = new Box<String>();
        //...
    }
}

public class Generic {
    
    /** Creates a new instance of Generic */
    public Generic() {
    }
    
    public void collectionGeneric(){
        //generic list
        List<String> onlyStrings = new LinkedList<String>();
        onlyStrings.add("Legal addition");
        //generic map
        Map<Integer, Integer> squares = new HashMap<Integer, Integer>();
        for (int i=0; i<100; i++) {
            squares.put(i, i*i);
        }
        for (int i=0; i<10; i++) {
            int n = i*3;
            System.out.println("The square of " + n + " is " + squares.get(n));
        }
        //generic iterator
        List<String> listOfStrings = new LinkedList<String>();
        listOfStrings.add("Happy");
        listOfStrings.add("Birthday");
        for (Iterator<String> i = listOfStrings.iterator(); i.hasNext( ); ) {
            String s = i.next( );
            System.out.println(s);
        }
    }
    //parameter generic
    public void paramGeneric(List<String> list){
        for(Iterator<String> i = list.iterator();i.hasNext();){
            String s = i.next();
            System.out.println(s);
        }
    }
    //return generic
    public List<String> returnGeneric(){
        List<String> list = new LinkedList<String>();
        list.add("string1");
        return list;
    }
    //conversion
    public void conversionGeneric(){
        LinkedList<Float> floatList = new LinkedList<Float>();
        List<Float> moreFloats = floatList;
        //illegal conversion LinkedList<Number> numberList = floatList;
        //the way to resolve for backward capbility
        List<Integer> ints = new LinkedList<Integer>();
        List oldList = ints;
        List<Number> numList = oldList;
    }
    //generic wildcard : this old plain way will generate unchecked warning
    public void wildcardGeneric(List list){
        for (Iterator i = list.iterator(); i.hasNext(); ) {
            System.out.println(i.next().toString());
        }
    }
    //generic wildcard
    public void wildcardGeneric2(List<?> list){
        //you can't solve the problem by List<Object>
        for (Iterator<?> i = list.iterator( ); i.hasNext(); ) {
            System.out.println(i.next().toString( ));
        }
    }
    
}

JAVA5 Tiger sample codes:

Tue, 20 Jun 2006 09:21:13 +0100

 int[][] ar = {{1,2,3},{4,5,6}};
        int[][] br = {{1,2,3},{4,5,6}};
        System.out.println(Arrays.deepToString(ar));
        System.out.println(Arrays.deepEquals(ar,br));
        StringBuilder sb = new StringBuilder("string builder");

Drool-Business Logic Framework

Wed, 31 May 2006 11:37:18 +0100

J2EE应用无限制的分层,各种框架层出不穷，设计模式经久不衰，就是为了设计更合理，合理的目的是为了松耦合高内聚，而大家在经典的J2EE3层架构中，持久层表示层业务逻辑层中，表示层与业务逻辑层的分离也是讨论很多，就是为了Business Logic的重用。很简单，你的业务层能够适应Java Web Start和Browser两种client么？而因为业务逻辑是核心，如果不解耦，它的变化将直接导致表示层持久层的变更。
长久以来，大家虽然最关心的是业务逻辑，但是，持久层表示层框架确是最丰富的。大家似乎习惯于让技术人员或者拥有业务能力背景的高级技术人员拿到需求然后用JAVA code来描述那复杂多变的业务逻辑。虽然目前俺忙于SAP,但是对java一直在关注，最近从SpringSide了解到了Drools这个我Rule Engine，我称它为Business Logic Framework. 因为它使用非JAVA code 而是DSL(Domain-Specific Language)来描述容易变化的商业的规则。不需要冗长的java代码，不需要变更后的编译打包部署。讲商业规则抽取出来，嗯，似乎有持久层里iBatis的味道(SQL抽取出来)。
以前草草的浏览了一次Drool 那个时候是版本2，商业规则要配置在XML里面，我感觉很郁闷，很不直观，也有点麻烦。Drool被JBOSS收购以后产生了大的变革，现在Rule写起来就像一种自然语言与计算机脚本语言的结合，快捷，明了。
废话不多了，大家先看一看Drool的介绍，这个介绍是针对Drool2的，不过可以看出来Drool的目的和用途了。
我的好朋友差沙最近也开始写blog，他介绍了一篇Drool3的，大家可以看到Drool3的变革。
您应该迫不及待去把自己的商业规则抽取出来了吧��

BIRT is a BOMB

Mon, 29 May 2006 08:01:08 +0100

BIRT is really a amazing report tool. It's so powerful and free.
No more crap, just check this flash demo http://download.eclipse.org/birt/downloads/examples/misc/BIRT/BIRT_demo_Camv3.html

SAP and JAVA Intergarion

Tue, 16 May 2006 08:09:47 +0100

I uploaded a document about SAP and JAVA's intergration.
It introduce BAPI RFC ALE IDoc JCo's basic concept. Enjoy it.
http://blueoxygen.dflying.net/3/resources/Java_SAP_Integration.pdf.html

The last reason to use NetBeans.

Sat, 29 Apr 2006 04:15:29 +0100

Recently,SUN publish Netbeans new release.Because project's requirement,I should use netbeans to design Swing UI. And at first,i really thought Netbeans Swing UI design tools pretty cool. But then i know,that's a vendor's production.Tody i got news from TheServerSide that the compony which design the Swing tools for SUN is supporting MyEclipse and i tried that.As convenience as it performed on NetBeans platform.
You can get a quic start here.Good luck.

Now the last reason to use NetBeans has gone.BTW,NetBeans default keymap really sucks!!! Ctrl+S means Search by default.The Netbeans designers are crazy??

Design Pattern--Creation Pattern

Fri, 24 Mar 2006 15:50:45 +0000

Creation Pattern

1 Simple Factory(Static Factory)

A Factory Class generates Objects:
public class ObjFactory{
public static MyObjFactory(String which){
if(which.equals("obj1"){
return new MyObj1();
}else if(which.equals("obj2"){
return new MyObj2();
}
}
}缺点：工厂类在增加新的子类的时候需要修改。在类的层次关系复杂的时候工厂类相当臃肿难于扩展。showcaseataFormat class of JDK工厂不单单总是返回新的对象，还可以内部维护一个对象列表，循环使用。

2 Factory

创建一个与要实例化的对象层级相同的工厂层次结构。通过不同的工厂产生不同的对象。public class Client{
private static Creator creator1,creator2;
private static Product prod1,prod2;
public static void main(String[] args){
creator1 = new Creator1();
prod1 = creator1.factory();
creator2 = new Creator1();
prod2 = creator1.factory();
}
}

showcase:java.util.Collection iterator()

3 Abstract Factory

当有n个产品等级的产品对象需要创建的时候，如果使用Factory模式必然需要和n相等的工厂等级结构来对应。但是如果这几个产品等级结构拥有相似性就可以用一个抽象工厂等级来处理。public interface AbstractFactory{
public ProductA factoryA();
public ProductB factoryB();
}

public class Factory1 implements AbstractFactory{
public ProductA factoryA(){
return new ProductA1();
}
public ProductB factoryA(){
return new ProductB1();
}
}
public class Factory2 implements AbstractFactory{
public ProductA factoryA(){
return new ProductA2();
}
public ProductB factoryA(){
return new ProductB2();
}
}
Principle:系统有多于一个的产品族，而系统只使用其中某一个族的产品。同属于一族的产品总是在一起使用。showcase:UI组件库。在windows下为一族，在Linux下为一族

4 Singleton

Public class FrameFactory{

private static final frameInstance = new frame();

private FrameFactory(){}

public static Frame frame(){

return frameInstance;

}

场景：系统要求此类只有一个实例

5 Multition

� 多例类可以有多个实例

� 多例类必须自己创建管理自己的实例，并向外提供自己的实例

实例数目有上限的叫做有上限多例类public class Die{
private static Die die1 = new Die();
private static Die die2 = new Die();
private Die(){}
public static Die getInstance(int whichOne){
if(whichOne ==1) return die1;
else return die2;
}

public synchronized int dice(){
//....service method
}
}

当实例个数很多的时候需要聚合管理，比如用一个HashMap来管理instance

6 Builder

建造模式可以将一个产品的内部表象和产品的生产过程分割开，从而可以使一个建造过程生成具有不同内部表象的产品对象。

public class Director{
private Builder builder;
public void construct(){
builder = new ConcreteBuilder();
builder.buildPart1();
builder.buildPart2();
builder.retrieveResult();
}
}

abstract public class Builder{
public abstract void buildPart1();
public abstract void buildPart2();
public abstract void retrieveResult();
}

public class ConcreteBuilder extends Builder{
private Product product = new Product();
public Product retrieveResult(){
return product;
}
public void buildPart1(){
//build first part of product
}
public void buildPart2(){
//build second part of product
}
}

省略导演者和抽象建造者对象

public class Builder{
private Product product = new Product();
public void buildPart1(){
//build part1
}
public void buildPart2(){
//build part2
}
public Product retriveResult(){
return product;
}
public void construct(){
buildPart1();
buildPart2();
}
}

public class Client{
private static Builder builder;
static public void main(){
builder = new Builer();
builder.construct();
Product product = builder.retrieveResult();
}
}

� Builder模式可以退化为Templete模式

� 可以将产品和产品的Builder类合二为一

� Builder模式与Abstract Factory模式的区别

� JavaMail中使用了Builder模式--Message MimeMessage class

String smtpHost = "smtp.mycompany.com";
String from = "david@mycompany.com";
String to = "nihao@be.com";
Properties prps = new Properties();
props.put("mail.smtp.host",smtpHost);
Session session = Session.getDefaultInstance(props,null);
InternetAddress[] address = {new InternetAddress(to)};
message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.setRecipients(Message.RecipientType.TO,address);
message.setSubject...
message.setSendDate...
message.setText...

7 Prototype