]]>
二、UML?br />
三：单测试代码如下：
1
/**
2
* 抽象的工厂接?br />
3
*/
4public interface IFactory {
5
/**
6 * {l构A的工厂方?br />
7
*/
8 public IProductA factoryA();
9
10 /**
11 * {l构B的工厂方?br />
12 */
13 public IProductB factoryB();
14}
15public class FactoryA implements IFactory {
16
17 public IProductA factoryA() {
18 return new ProductA();
19 }
20
21 public IProductB factoryB() {
22 return new ProductB();
23 }
24
25}
26public class FactoryB implements IFactory {
27
28 public IProductA factoryA() {
29 return new ProductA();
30 }
31
32 public IProductB factoryB() {
33 return new ProductB();
34 }
35
36}
37/**
38 * 产品的接?br />
39 */
40
41public interface IProductA {
42 void helloA();
43}
44
45public class ProductA implements IProductA{
46
47 public void helloA() {
48 System.out.println("ProductA");
49 }
50
51}
52
53public interface IProductB {
54 void helloB();
55}
56public class ProductB implements IProductB{
57
58 public void helloB() {
59 System.out.println("Product B");
60 }
61}
62
63public class TestAbstractFactory {
64
65 /**
66 * 试抽象工厂模式
67 * @param args
68 */
69 public static void main(String[] args) {
70 IFactory f = new FactoryA();
71 f.factoryA().helloA();
72 f.factoryB().helloB();
73
74 IFactory f1 = new FactoryB();
75 f1.factoryA().helloA();
76 f1.factoryB().helloB();
77 }
78
79}
80
81
82
/**
2
* 抽象的工厂接?br />
3 */4
public interface IFactory {
5
/**
6
* {l构A的工厂方?br />
7 */8
public IProductA factoryA();9
10
/**11
* {l构B的工厂方?br />
12 */13
public IProductB factoryB();14
}15
public class FactoryA implements IFactory {16
17
public IProductA factoryA() {18
return new ProductA();19
}20
21
public IProductB factoryB() {22
return new ProductB();23
}24
25
}26
public class FactoryB implements IFactory {27
28
public IProductA factoryA() {29
return new ProductA();30
}31
32
public IProductB factoryB() {33
return new ProductB();34
}35
36
}37
/**38
* 产品的接?br />
39 */40
41
public interface IProductA {42
void helloA();43
}44
45
public class ProductA implements IProductA{46
47
public void helloA() {48
System.out.println("ProductA");49
}50
51
}52
53
public interface IProductB {54
void helloB();55
}56
public class ProductB implements IProductB{57
58
public void helloB() {59
System.out.println("Product B");60
}61
}62
63
public class TestAbstractFactory {64
65
/**66
* 试抽象工厂模式67
* @param args68
*/69
public static void main(String[] args) {70
IFactory f = new FactoryA();71
f.factoryA().helloA();72
f.factoryB().helloB();73
74
IFactory f1 = new FactoryB();75
f1.factoryA().helloA();76
f1.factoryB().helloB();77
}78
79
}80
81
82
]]>
2.UML?br />
3.单测试代码如下：
1/**
2 * 定义一个抽象工?br />
3 */
4public interface ICarFactory {
5
6 /**
7 * 工厂Ҏ
8 */
9 ICar factory();
10}
11
12public class BMWFactory implements ICarFactory {
13
14 public ICar factory() {
15 return new BMW();
16 }
17
18}
19
20public class BenzFactory implements ICarFactory {
21
22 public ICar factory() {
23 return new Benz();
24 }
25
26}
27
28/**
29 * 定义一个品的接口
30 */
31public interface ICar {
32 void start();
33}
34
35public class Benz implements ICar {
36
37 public void start() {
38 System.out.println("Benz start.");
39 }
40
41}
42
43public class BMW implements ICar {
44
45 public void start() {
46 System.out.println("BMW() start.");
47 }
48}
49
50/**
51 * 试工厂Ҏ模式
52 */
53public class TestFactoryMethod {
54
55 public static void main(String[] args) {
56
57 ICarFactory carFactory = new BMWFactory(); //BMW工厂
58 ICar car = carFactory.factory();
59 car.start();
60
61 ICarFactory carFactory1 = new BenzFactory(); //Benz工厂
62 ICar car1 = carFactory1.factory();
63 car1.start();
64 }
65}
66
/**2
* 定义一个抽象工?br />
3 */4
public interface ICarFactory {5
6
/**7
* 工厂Ҏ8
*/9
ICar factory();10
}11
12
public class BMWFactory implements ICarFactory {13
14
public ICar factory() {15
return new BMW();16
}17
18
}19
20
public class BenzFactory implements ICarFactory {21
22
public ICar factory() {23
return new Benz();24
}25
26
}27
28
/**29
* 定义一个品的接口30
*/31
public interface ICar {32
void start();33
}34
35
public class Benz implements ICar {36
37
public void start() {38
System.out.println("Benz start.");39
}40
41
}42
43
public class BMW implements ICar {44
45
public void start() {46
System.out.println("BMW() start.");47
}48
}49
50
/**51
* 试工厂Ҏ模式52
*/53
public class TestFactoryMethod {54
55
public static void main(String[] args) {56
57
ICarFactory carFactory = new BMWFactory(); //BMW工厂58
ICar car = carFactory.factory();59
car.start();60
61
ICarFactory carFactory1 = new BenzFactory(); //Benz工厂62
ICar car1 = carFactory1.factory();63
car1.start();64
}65
}66
三、在Java中的使用
1.在集合中的运?br /> java.util.Collection ?iterator()Ҏ --> 通过q个Ҏ创徏Iterator对象
java.uitl.Iterator
]]>
]]>
1.cd(主要Q?br />
2.时序?头、生命线--垂直的虚Uѝ激zLQ?br /> 3.状态图
二、设计原?br /> 1.软gpȝ的核心的软g的可l护性（maintainabilityQ和可重用性（ReusabilityQ?br /> I、Y件维护性低?点原因（q于늡Rigidity、过于脆弱Flagility、复用性低Immobility、黏度过高viscosityQ?br /> II、设计目?条：(可扩展性Extensibility、灵zLFlexibility、可插入性Pluggability)
III、面向对象的复用Q复用焦点的倒{说的是复用不再集中到函数和算法的具体实现上，而是集中到最重要的业务逻辑上去?br /> 2.设计原则
I、开闭原?Open-Closed-Principle) ----> OOD 的根?br /> 定义Q?nbsp;是软g实体应该Ҏ展开放，对修改关闭?br /> 如何实现Q关键在于抽象化Q就是说l系l定义出一个不再更改的抽象设计Q此设计允许有无Ih的的行为在实现层被实现Q?br /> 对可变性的装原则QPrinciple of Encapsulation of Variation EVP q是OCP的另一个角度的说法) :定义是找C个可变的因素Q将其封装v来?br /> 一U重构做法的讨论Q?br /> "条件{U语句改写ؓ多态? 是广为流传的代码重构的做法，要注意用的场合Q从OCP出发Q?nbsp;
java.util.Calendar 不符合开闭原则，
II、接口和抽象c?br /> 1.抽象cL用来l承的，具体cM是用来承的Q认真体会）
2.抽象cd该拥有尽可能多的代码Q尽可能的数据
3.不要滥用l承Q哪何时使用l承呢？
满4条可使用l承Q?br /> a.子ؓ父的ҎU类Q而不是一个角?是is-a关系Q而不?has-a关系-->聚合AggregationQ?br /> b.永远不会出现需要将一个子c{换成另一个子cȝ情况
c.子类h扩展类的责任，而不是置换掉QoverrideQ或?nbsp;注销?Nullify) 的责?br /> d.只有在分cd有意义时Q才可以使用l承Q不要从工具cȝ?br /> Q?br /> III、里氏代换原则（Liskov Substitution Principle LSPQ?---> 是承复用的Ҏ
1.定义Q一个Y件实体如果用的一个超cȝ话，那么一定适用于子c，而且Ҏ察觉不到类对象和子cd象的区别?br /> (换言?--> 父类使用的地方，一定可以替换成子类)
2.Java语言可以在编译期间可以从无关业务逻辑、语法上查一个程序是否符合LSP(比如_子类中override父类的一个方法时其访问权限不能更?
3.LSP说的是超cd子类之间的关pR?br /> IV、依赖倒{原则QDependency Inversion PrincipleQ?br /> 1.定义Q?要依赖于抽象Q不要依赖于具体
2.依赖Q耦合Q关p?br /> a.零耦合QNil CouplingQ两个类没有耦合关系
b.具体耦合QConcrete CouplingQ两个具体类之间,一个类对另一个类直接调用造成
c.抽象耦合QAbstract CouplingQ?一个抽象类和一个具体类之间
3.具体说明Q?br /> a.DIP 要求客户端依赖于抽象耦合
b.表述一: 抽象不应该依赖于l节Q细节应该依赖于抽象(Abstractions should not depend upon details,Details should depend upon abstractions)
c.表述?要针对于接口~程Q不要针对于实现~程QProgram to an interface not an implementationQ?br /> 具体来说Q针对于接口~程Q就是用Java接口和抽象Javac进?变量的类型声明、参数的cd声明、方法返回值的cd声明、数据类型的转换
反之Q就是不使用
如何做到呢？Q一个具体的Javacd该只实现Java接口和抽象JavacM声明q的ҎQ而不应该写其他多余的Ҏ4.变量的静态类型和变量的实际类?br /> a.静态类?Static Type)Q?变量被声明时的类?又称明显cdQApparent Type)
b.实际cd(Actual Type)Q?nbsp; 变量所引用对象的真实类?br /> 比如Q?List employees = new Vector(); //List为静态类型，Vector为实际类?br /> c.作用Q?要引用对象的抽象cd--> 如果一个对象有一个抽象类型的话，应该使用此抽象类型作为对象的静态类?
List employees = new Vector(); // 代替 Vector employees = new Vector();
List employees = new ArrayList(); //面向抽象~程 q里有一定的问题Q其构造还是具体类的构造，需要通过模式改进?br /> 5.如何做到依赖倒{Q?br /> a.关键点：以抽象方式耦合
6.JavaҎ象类型的支持
a.提供了两U支持：接口和抽象类
b.接口和抽象类区别
1.抽象cd以提供部分方法的实现Q而接口不可以
2.子类只能l承1个抽象类,而接口的实现cd可以实现多个接口
3.从代码重构的角度看，一个具体类重构成一个接口的实现很容易，而抽象类却比较复?br /> 4.Java接口是定义合类?Mixin Type) 的理惛_?nbsp;
比如Hashtable 其主cd是Map ơ类型ؓClonable Serializable
7.联合使用Java接口和Java抽象c?br /> 具体说明Q声明一个接口，l出一个抽象类实现此接口，在抽象类中具体实现此接口中的ҎQ可以程序就可以选择实现接口或者承此抽象c?br /> UCؓ“~省适配模式QDefault AdapterQ?#8221;
参看Java API (abstract + 接口名） ׃用这L Default Adapter 比如Collection --> AbstractCollection
8.优缺点：
a.强大Q但不容易实玎ͼ需要很好的oop思想Q?br /> b.DIP:假定所有的具体c都是变化的Q这不太准确Q有些具体类是相对稳定的Q就不需要再使用抽象了~·
V、接口隔d则（Interface Segeration Principle ISP)
1.定义Q?使用多个专门的接口比使用单一的L口要好~,但不要提供不必要的接口，否则可能造成接口污染Qinterface ContaminationQ?br /> 2.“接口”的理解：
a.一个类中所有方法的集合(角色隔离原则)
b.真正意义上的接口Qinterface)Q定制服务原则：Customized ServiceQ?br /> VI、组?聚合复用原则QComposition/Aggregation Reuse Principle CARPQ?br /> 1.定义Q在一个新的对象里面用一些已有的对象Q之称为新对象的一部分Q新的对象通过向这些对象委z达到复用已有功能的目的
a之：量使用聚合l合Q不要用?br /> 2.复用
a.l合/聚合
b.l承
VII、_c特法则QLaw of Demeter LODQ?-> Least Knowledge Principle 最知识原?br /> 1.定义Q一个对象应该对另一个对象有可能少的了?br /> 2.如果两个cM必彼此通信Q那么这两个cM不必发生怺作用Q如果其中一个类需要调用另一个类的方法，可以通过W三者{发这U调?
3.使用说明Q?br /> a.优先考虑一个类讄Z变类
b.量降低一个类的访问权?br /> c.慎用Serializable
d.量降低成员的访问权?br />
]]>