Java设计模式——工厂模式

工厂模式-单例及多例:http://www.cnblogs.com/shamgod/p/4586146.html

一、单例的作用是用于控制类的生成方式，而不让外部类任意new对象

1.Car.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

import  java.util.ArrayList; import  java.util.List;   public  class  Car {        //私有化构造函数，防止被外部的类new      private  Car() {      }        private  static  Car car =  new  Car();                      //单例      private  static  List<Car> cars =  new  ArrayList<Car>();    //多例，类似连接池            public  static  Car getInstance() {          return  car;      }        public  void  run() {          System.out.println( "Car running..............." );      }       }

　　

2.Test.java

1 2 3 4 5 6 7 8 9 10 11

public  class  Test {            @org .junit.Test      public  void  test() {          Car car = Car.getInstance();          car.run();          Car car2 = Car.getInstance();          System.out.println(car == car2);          System.out.println(car.equals(car2));      } }

　　

运行结果：

简单工厂--转自：http://www.cnblogs.com/shamgod/p/4586349.html

一、概述

1.目标：要控制任意类型交通工具的生产模式

2.目标有两层意思(1)任意类型 (2)生产模式，所以对应的，要这两个层面上抽象(Movable,VehicleFactory)，利用接口，实现多态

 

二、类结构

1.Interface Movable.java

2.Car.java

3.Plane.java

4.Interface VehicleFactory.java

5.CarFactory.java

6.PlaneFactory.java

 

 

三、代码

1.Movable.java

1 2 3

public  interface  Movable {      void  run(); }

　　

2.Car.java

1 2 3 4 5 6 7 8 9 10

public  class  Car  implements  Movable {        public  Car() {      }        public  void  run() {          System.out.println( "Car running..............." );      }       }

　　

3.Plane.java

1 2 3 4 5 6 7 8

public  class  Plane  implements  Movable {        @Override      public  void  run() {          System.out.println( "飞机飞翔中。。。。" );      }   }

　　

4.VehicleFactory.java

1 2 3

public  interface  VehicleFactory {      Movable create(); }

　　

5.CarFactory.java

1 2 3 4 5 6 7 8 9

public  class  CarFactory  implements  VehicleFactory {        private  static  Car car =  new  Car();      @Override      public  Movable create() {          return  car;      }   }

　　

6.PlaneFactory.java

1 2 3 4 5 6 7 8 9

public  class  PlaneFactory  implements  VehicleFactory {        private  static  Plane plane =  new  Plane();      @Override      public  Movable create() {          return  plane;      }   }

　　

7.Test.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

public  class  Test {            @org .junit.Test      public  void  test() {          VehicleFactory factory =  new  CarFactory();          Movable m1 = factory.create();          m1.run();                    Movable m2 = factory.create();          System.out.println(m1 == m2);          System.out.println(m1.equals(m2));                    System.out.println( "******************************" );                    factory =  new  PlaneFactory();          m1 = factory.create();          m1.run();                    m2 = factory.create();          System.out.println(m1 == m2);          System.out.println(m1.equals(m2));      } }

　　

8.测试结果

抽象工厂——http://www.cnblogs.com/shamgod/p/4586720.html

一、概述

1.抽象工厂：当情况是需要产生一系列产品，若需更换产品，则要求一系列产品一起换，且要控制一系列产品的产生过程，此时可考虑抽象工厂模式。例：小明装修屋子，把电视、冰箱都替换掉，他这次需要把电视、冰箱换成三星的，下次装修可能要换成海尔的。此时可设计抽象类Telveison及Fridge负责产生产品,抽象工厂AbstractFactory负责产生一系列产品

PS:抽象工厂与普通工厂各自的优缺点：

(1)普通工厂容易在产品维度进行扩展，但产生系列产品时不方便，且易造成工厂类泛滥

(2)抽象工厂增加新产品时，要修改AbstractFactory等多处地方

 

二、类结构

1.Televison.java

2.Fridge.java

3.SamsumgTelevison.java

4.SamsungFridge.java

5.HaierTevevison.java

6.HaierFridge.java

7.AbstractFactory.java

8.SamsungFactory.java

9.HaierFactory.java

 

 

三、代码

1.Televison.java

1 2 3 4

public  abstract  class  Televison {        abstract  void  show(); }

　　

2.Fridge.java

1 2 3 4

public  abstract  class  Fridge {        abstract  void  cool(); }

　　

3.SamsumgTelevison.java

1 2 3 4 5 6 7

public  class  SamsungTelevison  extends  Televison {        @Override      public  void  show(){          System.out.println( "SamsungTelevison showing..........." );      } }

　　

4.SamsungFridge.java

1 2 3 4 5 6 7 8

public  class  SamsungFridge  extends  Fridge {        @Override      void  cool() {          System.out.println( "SamsungFridge cooling" );      }   }

　　

5.HaierTevevison.java

1 2 3 4 5 6 7 8

public  class  HaierTelevison  extends  Televison {        @Override      void  show() {          System.out.println( "海尔电视 showinng..........." );      }   }

　　

6.HaierFridge.java

1 2 3 4 5 6 7 8

public  class  HaierFridge  extends  Fridge {        @Override      void  cool() {          System.out.println( "海尔冰箱冷却中............" );      }   }

　　

7.AbstractFactory.java

1 2 3 4

public  abstract  class  AbstractFactory {      abstract  Televison createTelevison();      abstract  Fridge createFridge(); }

　　

8.SamsungFactory.java

1 2 3 4 5 6 7 8 9 10 11 12 13

public  class  SamsungFactory  extends  AbstractFactory {        @Override      Televison createTelevison() {          return  new  SamsungTelevison();      }        @Override      Fridge createFridge() {              return  new  SamsungFridge();      }   }

　　

9.HaierFactory.java

 

1 2 3 4 5 6 7 8 9 10 11 12 13

public  class  HaierFactory  extends  AbstractFactory {        @Override      Televison createTelevison() {          return  new  HaierTelevison();      }        @Override      Fridge createFridge() {          return  new  HaierFridge();      }   }

　　

10.Test.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public  class  Test {        @org .junit.Test      public  void  test(){          AbstractFactory factory =  new  SamsungFactory();          Televison tv = factory.createTelevison();          Fridge fridge = factory.createFridge();          tv.show();          fridge.cool();                    System.out.println( "=======================================" );                    factory =  new  HaierFactory();          tv = factory.createTelevison();          fridge = factory.createFridge();          tv.show();          fridge.cool();      } }

　　

运行结果：