本文共 4853 字，大约阅读时间需要 16 分钟。
工厂模式-单例及多例: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(); } } |
运行结果：
