BlogJava-小草的天空-文章分类-设计模式

《java与模式》(阎宏) 学习笔记5(单例模式)

齐纳尔多 — Wed, 24 Dec 2008 00:54:00 GMT

一、单例模式（Singleton)

齐纳尔多 2008-12-24 08:54 发表评论

《java与模式》(阎宏) 学习笔记4(抽象工厂模式)

齐纳尔多 — Tue, 23 Dec 2008 06:23:00 GMT

一、抽象工厂模式和工厂方法模式的区别是：
工厂方法模式是一个工厂具体类对应一个产品的等级结构，而Abstract Factory 是一个工厂的具体类相应多个产品的等级结构
二、UML图

三：简单测试代码如下：

1/**
2 * 抽象的工厂接口
3 */
4public interface IFactory {
5    /**
6     * 等级结构A的工厂方法
7     */
8    public IProductA factoryA();
9
10    /**
11     * 等级结构B的工厂方法
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 * 产品的接口
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

齐纳尔多 2008-12-23 14:23 发表评论

《java与模式》(阎宏) 学习笔记III(工厂方法模式)

齐纳尔多 — Wed, 17 Dec 2008 01:55:00 GMT

一、工厂方法模式（Factory Method）--> 多态性工厂（Polymorphic Factory）
        1.定义：就是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类
        2.UML图

        3.简单测试代码如下：

1/**
2 * 定义一个抽象工厂
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

三、在Java中的使用
        1.在集合中的运用
                java.util.Collection 中 iterator()方法  --> 通过这个方法创建Iterator对象
                java.uitl.Iterator

齐纳尔多 2008-12-17 09:55 发表评论

《java与模式》(阎宏) 学习笔记II(简单工厂模式)

齐纳尔多 — Tue, 16 Dec 2008 09:07:00 GMT

摘要: 一、创建模式(Creational Pattern) --> 对类的实例化过程的抽象化分类： a.类的创建模式 &... 阅读全文

齐纳尔多 2008-12-16 17:07 发表评论

《java与模式》(阎宏) 学习笔记I

齐纳尔多 — Tue, 16 Dec 2008 02:09:00 GMT

一、uml的学习，了解
1.类图(主要）

2.时序图(箭头、生命线--垂直的虚线、激活条）
3.状态图

二、设计原则
1.软件系统的核心的软件的可维护性（maintainability）和可重用性（Reusability）
        I、软件维护性低的4点原因（过于僵硬Rigidity、过于脆弱Flagility、复用性低Immobility、黏度过高viscosity）
        II、设计目标3条：(可扩展性Extensibility、灵活性Flexibility、可插入性Pluggability)
        III、面向对象的复用：复用焦点的倒转说的是复用不再集中到函数和算法的具体实现上，而是集中到最重要的业务逻辑上去。
2.设计原则
        I、开闭原则(Open-Closed-Principle)    ----> OOD 的根本
            定义：就是软件实体应该对扩展开放，对修改关闭。
            如何实现：关键在于抽象化（就是说给系统定义出一个不再更改的抽象设计，此设计允许有无穷无尽的的行为在实现层被实现）
            对可变性的封装原则（Principle of Encapsulation of Variation EVP 这是OCP的另一个角度的说法)  :定义是找到一个可变的因素，将其封装起来。
            一种重构做法的讨论：
                    "将条件转移语句改写为多态性" 是广为流传的代码重构的做法，要注意使用的场合（从OCP出发）
            java.util.Calendar 不符合开闭原则，
        II、接口和抽象类
            1.抽象类是用来继承的，具体类不是用来继承的（认真体会）
            2.抽象类应该拥有尽可能多的代码，尽可能少的数据
            3.不要滥用继承，哪何时使用继承呢？
                    满足4条可使用继承（
                        a.子为父的特殊种类，而不是一个角色是is-a关系，而不是(has-a关系-->聚合Aggregation）
                        b.永远不会出现需要将一个子类转换成另一个子类的情况
                        c.子类具有扩展超类的责任，而不是置换掉（override）或者注销掉(Nullify) 的责任
                        d.只有在分类学有意义时，才可以使用继承，不要从工具类继承
                    ）
        III、里氏代换原则（Liskov Substitution Principle LSP）----> 是继承复用的根本
                1.定义：一个软件实体如果使用的一个超类的话，那么一定适用于子类，而且根本察觉不到超类对象和子类对象的区别。
                                (换言之---> 父类使用的地方，一定可以替换成子类)
                2.Java语言可以在编译期间可以从无关业务逻辑、语法上检查一个程序是否符合LSP(比如说：子类中override父类的一个方法时其访问权限不能更小)
                3.LSP说的是超类和子类之间的关系。
        IV、依赖倒转原则（Dependency Inversion Principle）
                1.定义：要依赖于抽象，不要依赖于具体
                2.依赖（耦合）关系
                    a.零耦合（Nil Coupling）两个类没有耦合关系
                    b.具体耦合（Concrete Coupling）两个具体类之间,一个类对另一个类直接调用造成
                    c.抽象耦合（Abstract Coupling）一个抽象类和一个具体类之间
                3.具体说明：
                    a.DIP 要求客户端依赖于抽象耦合
                    b.表述一: 抽象不应该依赖于细节，细节应该依赖于抽象(Abstractions should not depend upon details,Details should depend upon abstractions)
                    c.表述二:要针对于接口编程，不要针对于实现编程（Program to an interface not an implementation）
                            具体来说：针对于接口编程，就是使用Java接口和抽象Java类进行变量的类型声明、参数的类型声明、方法返回值的类型声明、数据类型的转换
                             反之，就是不使用如何做到呢？？一个具体的Java类应该只实现Java接口和抽象Java类中声明过的方法，而不应该写其他多余的方法
                4.变量的静态类型和变量的实际类型
                    a.静态类型(Static Type)：变量被声明时的类型,又称明显类型（Apparent Type)
                    b.实际类型(Actual Type)：  变量所引用对象的真实类型
                    比如： List employees = new Vector();        //List为静态类型，Vector为实际类型
                    c.作用：要引用对象的抽象类型--> 如果一个对象有一个抽象类型的话，应该使用此抽象类型作为对象的静态类型.
                            List employees = new Vector();        // 代替 Vector employees = new Vector();
                            List employees = new ArrayList();    //面向抽象编程        这里有一定的问题，其构造还是具体类的构造，需要通过模式改进。
               5.如何做到依赖倒转？
                    a.关键点：以抽象方式耦合
               6.Java对抽象类型的支持
                    a.提供了两种支持：接口和抽象类
                    b.接口和抽象类区别
                        1.抽象类可以提供部分方法的实现，而接口不可以
                        2.子类只能继承1个抽象类,而接口的实现类却可以实现多个接口
                        3.从代码重构的角度看，将一个具体类重构成一个接口的实现很容易，而抽象类却比较复杂
                        4.Java接口是定义混合类型(Mixin Type) 的理想工具
                                比如Hashtable 其主类型是Map 次类型为Clonable Serializable
                7.联合使用Java接口和Java抽象类
                    具体说明：声明一个接口，给出一个抽象类实现此接口，在抽象类中具体实现此接口中的方法，可以程序就可以选择实现接口或者继承此抽象类
                     称为“缺省适配模式（Default Adapter）”
                    参看Java API (abstract + 接口名）就使用这样的 Default Adapter 比如Collection --> AbstractCollection
                8.优缺点：
                    a.强大，但不容易实现（需要很好的oop思想）
                    b.DIP:假定所有的具体类都是变化的，这不太准确，有些具体类是相对稳定的，就不需要再使用抽象了~·
           V、接口隔离原则（Interface Segeration Principle ISP)
                1.定义：使用多个专门的接口比使用单一的总接口要好~,但不要提供不必要的接口，否则可能造成接口污染（interface Contamination）
                2.“接口”的理解：
                        a.一个类中所有方法的集合(角色隔离原则)
                        b.真正意义上的接口（interface)（定制服务原则：Customized Service）
          VI、组合/聚合复用原则（Composition/Aggregation Reuse Principle CARP）
                1.定义：在一个新的对象里面使用一些已有的对象，使之称为新对象的一部分，新的对象通过向这些对象委派达到复用已有功能的目的
                               简言之：尽量使用聚合组合，不要使用继承
                2.复用
                    a.组合/聚合
                    b.继承
         VII、迪米特法则（Law of Demeter LOD）--> Least Knowledge Principle 最少知识原则
                1.定义：一个对象应该对另一个对象有尽可能少的了解
                2.如果两个类不必彼此通信，那么这两个类也不必发生相互作用，如果其中一个类需要调用另一个类的方法，可以通过第三者转发这种调用.
                3.使用说明：
                    a.优先考虑将一个类设置为不变类
                    b.尽量降低一个类的访问权限
                    c.慎用Serializable
                    d.尽量降低成员的访问权限

齐纳尔多 2008-12-16 10:09 发表评论