亚洲一级毛片免费看,亚洲综合小说久久另类区,亚洲丰满熟女一区二区v

抽象工厂模式

��D��于渊 — 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("男�h开始吃东西�?");
107     }
108     public void sleep(){
109         System.out.println("男�h要睡觉了!");
110     }
111 }
112
113 class Woman implements Person{
114     public void eat(){
115         System.out.println("女�h开始吃东西�?");
116     }
117     public void sleep(){
118         System.out.println("女�h要睡觉了!");
119     }
120 }

��D��于渊 2008-12-21 09:04 发表评论

工厂模式

��D��于渊 — Sat, 20 Dec 2008 11:29:00 GMT

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

��D��于渊 2008-12-20 19:29 发表评论

��D��于渊 — Sat, 20 Dec 2008 10:19:00 GMT

工厂模式��是设计一个工厂类, 生��(�q�回�cȝ��实例)一�l�实��C��一个共同接口的�cȝ��实例的方�?

�W�一�U�设�? 为每一个类设计一个工�?br />

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

为每一个类设计一个工�? 昄��q�大的增加了代码�? 不是好的设计!

--------------------------------------------------------------
�W�二�U�方�? 为实��C��同一接口的类创徏一个公��q��工厂(而这里的各种车刚好都实现了Car�q�个接口)

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("不能造这�U��R!");
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

//�q�样仍然有一个不好的地方, ��是传入一个工厂不能造的东西会报�? 必须在客��L��判断一�?
//在扩充子�cȝ��时候要修改工厂,用反��机制可以解册��一问题!

�W�三�U�运用反��机制　

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

昄��q�样在增加一个子�c?如在此例中加一个Honda的类�?不需要修改工厂方法！

��D��于渊 2008-12-20 18:19 发表评论

单例模式(SingleTon)

��D��于渊 — 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�cȝ��实例), �q�样减少了内存的占有�? 而且�q�减��M��垃圾回收机制的负�?

下面看几个设计的不好的例�?

一.直接在类的内部设一个静态的该类的类�?

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�? 破坏了类的封�? ��不上是好的�cȝ��设计!
好的�Ҏ��是应该把该属性设为私有的, 然后在类里面提供一个公有的�Ҏ��q�回�q�个实例

��D��于渊 2008-12-20 18:12 发表评论