设计模式—工厂方法

 

设计模式—工厂方法

工厂方法与抽象方法

面向接口编程可以提高代码的灵活性,可以横向扩充代码.切忌不能使用面向实现的编程，这样做不便于以后业务的扩充和代码的灵活性。

工厂方法:就是把new class的过程交给factory来做.构造类的细节不需要我们知道。

 比如:构造一个List我们可以这样写:

public class ListFactory{

   public List getList(String type){
             if (type.equals("1")){
              return new MyList1();
             }else if(type.equals("2")){
              return new MyList2();
             }else if(type.equals("3")){
              return new MyList3();
              
             }

   }

 }

抽象方法

若你构造一个类是比较复杂的话,就必须是抽象工厂了.

比如你构造一个产品,这个产品可能有好多种，但他们的接口是相同的。如网卡类,显卡类等.显卡类和网卡类都有自己的内存和CPU。所以在构造这系列类的时候就需要考虑。首先要抽象一个产品类,在抽象产品的CPU和内存.具体的产品和CPU，内存可以用具体的类来实现。

//构造产品接口

public interface Product {

public CPU getCPU();

public RAM getRAM();

}

//构造产品的一个部件CPU接口

public interface CPU {

public void writer(String message);

public String reader();

}

//构造产品的一个部件RAM接口

public interface RAM {

public void writer(String message);

public String reader();

}

//产品和部件的实现

public class MacRam implements RAM {

 

    public String reader() {

       return "macRam";

    }

 

    public void writer(String message) {

       System.out.println("===macRam==");

    }

 

}

public class ChipRam implements RAM {

 

    public String reader() {

       return "chipRam";

    }

 

    public void writer(String message) {

      System.out.println("===chipRam===");

    }

 

}

 

public class MacCpu implements CPU {

 

    public String reader() {

       return "macCpu";

    }

 

    public void writer(String message) {

       System.out.println("==macCpu==");

    }

 

}

public class ChipCpu implements CPU{

 

    public String reader() {

       return "chipCpu";

    }

 

    public void writer(String message) {

       System.out.println("====chipCpu==");

    }

 

 

}

 

public class MacProduct implements Product {

 

    public CPU getCPU() {

       return new MacCpu();

    }

 

    public RAM getRAM() {

       return new MacRam();

    }

 

}

//产品工厂类

public class ProductFactory {

    public static Product getMacProduct(){

       return new MacProduct();

    }

    public static Product getCpuProduct(){

    return new ChipProduct();

    }

}

 

public class ChipProduct implements Product {

 

    public CPU getCPU() {

       return new ChipCpu();

    }

 

    public RAM getRAM() {

       return new ChipRam();

    }

 

}

 

//测试类

public class TestFactory {

 

    public static void main(String[] args) {

           Product product=ProductFactory.getMacProduct();

           product.getCPU().writer("www.test.com");

           product.getRAM().reader();

    }

 

}

当你需要增加新的产品的时候,直接横向扩展类就可以了，实现RAM接口,实现CPU接口,实现Product接口,这样一个新产品就出来了,代码只需要修改工厂方法就可以了.比如我们需要一个显卡产品VideoProduct，它也由CPU和RAM组成.所以我们就需要做类的横向扩展,VideoRam,VideoCpu,VideoProduct。最后工厂方法要变一下,增加一个新的产品创建方法getVideoProduct()，外围使用ProductFactory去构造新的产品类的时候，基本的代码框架是不需要变得。对代码的扩展性,重用性得到了很大的提高。此工厂方法的缺点,就是每增加一个产品,就需要在工厂方法里增加一个方法。需要修改工厂方法类。考虑是否可以使用类的动态加载。