BlogJava-鱼跃于渊-文章分类-设计模式

抽象工厂模式

鱼跃于渊 — Sun, 21 Dec 2008 01:04:00 GMT

  1 package com.givetop.AbstractFactory;
  2
  3 public class Factory {
  4     public static void main(String[] args){
  5         YangSheng ys = new YangSheng();
  6         Animal bull = null;
  7         bull = ys.getAnimal("Bull");
  8         bull.eat();
  9         bull.sleep();
10     }
11 }
12
13 interface NWFactory{
14     public Animal getAnimal(String type);
15     public Person getPerson(String type);
16 }
17
18 class YangSheng implements NWFactory{
19     Person man = null;
20     Animal bull = null;
21     public Animal getAnimal(String type){
22         try {
23             bull = (Bull)Class.forName("com.givetop.AbstractFactory."+type).newInstance();
24         } catch (InstantiationException e) {
25             e.printStackTrace();
26         } catch (IllegalAccessException e) {
27             e.printStackTrace();
28         } catch (ClassNotFoundException e) {
29             e.printStackTrace();
30         }
31         return bull;
32     }
33     public Person getPerson(String type){
34         try {
35             man = (Man)Class.forName("com.givetop.AbstractFactory."+type).newInstance();
36         } catch (InstantiationException e) {
37             e.printStackTrace();
38         } catch (IllegalAccessException e) {
39             e.printStackTrace();
40         } catch (ClassNotFoundException e) {
41             e.printStackTrace();
42         }
43         return man;
44     }
45 }
46
47 class YinSheng implements NWFactory{
48     Person woman = null;
49     Animal cow = null;
50     public Animal getAnimal(String type){
51         try {
52             cow = (Cow)Class.forName("com.givetop.AbstractFactory."+type).newInstance();
53         } catch (InstantiationException e) {
54             e.printStackTrace();
55         } catch (IllegalAccessException e) {
56             e.printStackTrace();
57         } catch (ClassNotFoundException e) {
58             e.printStackTrace();
59         }
60         return cow;
61     }
62     public Person getPerson(String type){
63         try {
64             woman = (Woman)Class.forName("com.givetop.AbstractFactory."+type).newInstance();
65         } catch (InstantiationException e) {
66             e.printStackTrace();
67         } catch (IllegalAccessException e) {
68             e.printStackTrace();
69         } catch (ClassNotFoundException e) {
70             e.printStackTrace();
71         }
72         return woman;
73     }
74 }
75
76 interface Animal{
77     public void eat();
78     public void sleep();
79 }
80
81 interface Person{
82     public void eat();
83     public void sleep();
84 }
85
86 class Bull implements Animal{
87     public void eat(){
88         System.out.println("公牛开始吃东西了!");
89     }
90     public void sleep(){
91         System.out.println("公牛开始睡觉了!");
92     }
93 }
94
95 class Cow implements Animal{
96     public void eat(){
97         System.out.println("奶牛开始吃东西了!");
98     }
99     public void sleep(){
100         System.out.println("奶牛开始睡觉了!");
101     }
102 }
103
104 class Man implements Person{
105     public void eat(){
106         System.out.println("男人开始吃东西了!");
107     }
108     public void sleep(){
109         System.out.println("男人要睡觉了!");
110     }
111 }
112
113 class Woman implements Person{
114     public void eat(){
115         System.out.println("女人开始吃东西了!");
116     }
117     public void sleep(){
118         System.out.println("女人要睡觉了!");
119     }
120 }

鱼跃于渊 2008-12-21 09:04 发表评论

工厂模式

鱼跃于渊 — Sat, 20 Dec 2008 11:29:00 GMT

摘要: 工厂方法模式和简单工厂模式在结构上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。工厂方法模式可以允许很多具体工厂类从抽象工厂类中将创建行为继承下来，从而可以成为多个简单工厂模式的综合，进而推广了简单工厂模式。下面看例子代码：此模式涉及到抽象工厂角色（汽车厂），具体工厂角色（具体的汽车车间），抽象产品角色（汽车）以及具体产品角色（私车，公交巴... 阅读全文

鱼跃于渊 2008-12-20 19:29 发表评论

简单工厂模式

鱼跃于渊 — Sat, 20 Dec 2008 10:19:00 GMT

工厂模式就是设计一个工厂类, 生产(返回类的实例)一组实现了一个共同接口的类的实例的方法.

第一种设计: 为每一个类设计一个工厂

1 package com.givetop.singleton;
2
3 public class Factory1 {
4     public static void main(String[] args){
5         Ford_Factory.getInstance().run();
6         Benz_Factory.getInstance().stop();
7     }
8 }
9
10 interface Car{
11     public void run();
12     public void stop();
13 }
14
15 class Ford implements Car{
16     public void run(){
17         System.out.println("Ford开始启动了!");
18     }
19     public void stop(){
20         System.out.println("Ford停止了!");
21     }
22 }
23
24 class Benz implements Car{
25     public void run(){
26         System.out.println("Benz开始启动了!");
27     }
28     public void stop(){
29         System.out.println("Benz停止了!");
30     }
31 }
32
33 class Ford_Factory{
34     public static Car getInstance(){
35         return new Ford();
36     }
37 }
38
39 class Benz_Factory{
40     public static Car getInstance(){
41         return new Benz();
42     }
43 }
44

为每一个类设计一个工厂, 显然这大的增加了代码量, 不是好的设计!

--------------------------------------------------------------
第二种方法: 为实现了同一接口的类创建一个公共的工厂(而这里的各种车刚好都实现了Car这个接口)

1 package com.givetop.singleton;
2
3 public class Factory2 {
4     public static void main(String[] args){
5         Factory.getInstance("Benz").run();
6         /*
7         Car car = Factory.getInstance("fsdf");
8         if(car!=null){
9             car.run();
10             car.stop();
11         }else{
12             System.out.println("不能造这种车!");
13         }
14         */
15     }
16 }
17
18 interface Car1{
19     public void run();
20     public void stop();
21 }
22
23 class Ford1 implements Car{
24     public void run(){
25         System.out.println("Ford1开始启动了!");
26     }
27     public void stop(){
28         System.out.println("Ford1停止了!");
29     }
30 }
31
32 class Benz1 implements Car{
33     public void run(){
34         System.out.println("Benz1开始启动了!");
35     }
36     public void stop(){
37         System.out.println("Benz1停止了!");
38     }
39 }
40
41 class Factory{
42     public static Car getInstance(String type){
43         Car c = null;
44         if("Ford".equals(type)){
45             c = new Ford1();
46         }
47         if("Benz".equals(type)){
48             c = new Benz1();
49         }
50         return c;
51     }
52 }
53
54

//这样仍然有一个不好的地方, 就是传入一个工厂不能造的东西会报错, 必须在客户端判断一下!
//在扩充子类的时候要修改工厂,用反射机制可以解决这一问题!

第三种运用反射机制　

1 package com.givetop.singleton;
2
3 public class Factory3 {
4     public static void main(String[] args){
5         Car_Factory.getInstance("Benz2").run();
6         Car2 c = null ;
7         c = Car_Factory.getInstance("Ford2");
8         c.run();
9         c.stop();
10         c=Car_Factory.getInstance("Honda");
11         if(c==null){
12             System.out.println("不能造Honda车!");
13         }
14     }
15 }
16
17 interface Car2{
18     public void run();
19     public void stop();
20 }
21
22 class Ford2 implements Car2{
23     public void run(){
24         System.out.println("Ford开始启动了!");
25     }
26     public void stop(){
27         System.out.println("Ford停止了!");
28     }
29 }
30
31 class Benz2 implements Car2{
32     public void run(){
33         System.out.println("Benz开始启动了!");
34     }
35     public void stop(){
36         System.out.println("Benz停止了!");
37     }
38 }
39
40 class Car_Factory{
41     public static Car2 getInstance(String type){
42         Car2 c = null;
43         try {
44             c = (Car2)Class.forName("com.givetop.singleton."+type).newInstance();
45         } catch (InstantiationException e) {
46             // TODO Auto-generated catch block
47             e.printStackTrace();
48         } catch (IllegalAccessException e) {
49             // TODO Auto-generated catch block
50             e.printStackTrace();
51         } catch (ClassNotFoundException e) {
52             // TODO Auto-generated catch block
53             //e.printStackTrace();
54             System.out.println("error here!");
55         }
56         return c;
57     }
58
59 }
60

显然这样在增加一个子类(如在此例中加一个Honda的类时)不需要修改工厂方法！

鱼跃于渊 2008-12-20 18:19 发表评论

单例模式(SingleTon)

鱼跃于渊 — Sat, 20 Dec 2008 10:12:00 GMT

1 package com.givetop.singleton;
2
3 public class singleton {
4
5
6  public static void main(String[] args) {
7   Single.getSingleton().say();
8  }
9
10 }
11
12 class Single{
13  private static Single s = new Single();
14  public static Single getSingleton(){
15   return Single.s;
16  }
17  private Single(){
18
19  }
20  public void say(){
21   System.out.println("我开始说话了!");
22  }
23 }
24

//思想是: 所谓单例就是只有一个实例存在(把类的构造方法设为私有的,防止在类的外面new类的实例), 这样减少了内存的占有量, 而且还减轻了垃圾回收机制的负担!

下面看几个设计的不好的例子!

一.直接在类的内部设一个静态的该类的类型!

1 package com.givetop.singleton;
2
3 public class singleton {
4
5
6     public static void main(String[] args) {
7         Single.s.say();
8     }
9
10 }
11
12 class Single{
13     static Single s = new Single();
14     private Single(){
15
16     }
17     public void say(){
18         System.out.println("我开始说话了!");
19     }
20 }

该类虽然实现了只能new一个实例但 s 属性是default的, 破坏了类的封装, 算不上是好的类的设计!
好的方法是应该把该属性设为私有的, 然后在类里面提供一个公有的方法返回这个实例

鱼跃于渊 2008-12-20 18:12 发表评论