Java 项目的技术设计方案书

java设计模式最全讲解

话不多说，面试和使用足够用

1.单例模式（Singleton Pattern）
定义：Ensure a class has only one instance, and provide a global point of access to it.（确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。）
首先我们要知道单例模式不是线程安全的。怎么确保安全再单例模式尤为重要。
通用代码：（是线程安全的） static修饰类加载的时候创建实例 ，静态私有方法—在类加载时已经初始化

public class Singleton {      
	private static final Singleton singleton = new Singleton(); 
	//限制产生多个对象      
	private Singleton(){      
	}      
	//通过该方法获得实例对象      
	public static Singleton getSingleton(){              
	return singleton;      
	}        
	//类中其他方法，尽量是 static      
	public static void doSomething(){      
	} 
}

由于是一个对象所以使用场景收到限制
使用场景： ● 要求生成唯一序列号的环境； ● 在整个项目中需要一个共享访问点或共享数据，例如一个 Web 页面上的计数器，可以不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确 保是线程安全的； ● 创建一个对象需要消耗的资源过多，如要访问 IO 和数据库等资源； ● 需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式 （当然，也可以直接声明为 static 的方式）。

线程不安全实例（懒汉式）

public class Singleton {      
	private static Singleton singleton = null;             
	private Singleton(){      
	}        
	//通过该方法获得实例对象      
	public static Singleton getSingleton(){              
		if(singleton == null){                     
			singleton = new Singleton(); 
	   	}              
	   	return singleton;      
	} 
}

解决办法： 在 getSingleton 方法前加 synchronized 关键字，也可以在 getSingleton 方法内增 加 synchronized 来实现。最优的办法是如通用代码那样写。

2.工厂模式（ Factory Pattern）
定义：Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses. （定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类 的实例化延迟到其子类。）
Product 为抽象产品类负责定义产品的共性，实现对事物最抽象的定义； Creator 为抽象创建类，也就是抽象工厂，具体如何创建产品类是由具体的实现工 厂 ConcreteCreator 完成的。 具体工厂类代码：

public class ConcreteCreator extends Creator {
        public <T extends Product> T createProduct(Class<T> c) {
            Product product = null;
            try {
                product = (Product) Class.forName(c.getName()).newInstance();
            } catch (Exception e) {
                //异常处理
            }
            return (T)product;
        }
    }

简单工厂模式： 一个模块仅需要一个工厂类，没有必要把它产生出来，使用静态的方法。
多个工厂类： 每个人种（具体的产品类）都对应了一个创建者，每个创建者独立负责创建对应的 产品对象，非常符合单一职责原则。
代替单例模式： 单例模式的核心要求就是在内存中只有一个对象，通过工厂方法模式也可以只在内 存中生产一个对象。
使用场景：jdbc 连接数据库，硬件访问，降低对象的产生和销
你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。

3.抽象工厂模式（Abstract Factory Pattern）
定义：Provide an interface for creating families of related or dependent objects without specifying their concrete classes.（为创建一组相关或相互依赖的对象提供 一个接口，而且无须指定它们的具体类。

有N个产品族，在抽象工厂类中就应该有N个创建方法。我们这里定义两个产品族的产品创建，代码如下

public abstract class AbstractCreator {
        //创建 A 产品家族
        public abstract AbstractProductA createProductA();
        //创建 B 产品家族
        public abstract AbstractProductB createProductB();
}

public abstract class AbstractProductA {
    //每个产品共有的方法
    public void shareMethod() {
    }
    // 每个产品相同方法，不同实现
    public abstract void doSomething();
}

public abstract class AbstractProductB {
    //每个产品共有的方法
    public void shareMethod() {
    }
    // 每个产品相同方法，不同实现
    public abstract void doSomething();
}

两个产品族的具体实现类代码

public class ProductA1 extends AbstractProductA {
    public void doSomething() {
        System.out.println("我是产品A1");
    }
}

public class ProductA2 extends AbstractProductA {
    public void doSomething() {
        System.out.println("我是产品A2");
    }
}

public class ProductB1 extends AbstractProductB {
    public void doSomething() {
        System.out.println("我是产品B1");
    }
}
public class ProductB2 extends AbstractProductB {
    public void doSomething() {
        System.out.println("我是产品B2");
    }
}

然后是创建产品的具体工厂，有N个产品等级就应该有N个实现工厂类，在每个实现工厂中，实现不同产品族的生产任务。

public class Creator1 extends AbstractCreator {
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}
public class Creator2 extends AbstractCreator {
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

到此为止，我们把所有的角色都创建出来了，然后最后一个为客户端

public class Client {
    public static void main(String[] args) {
        //定义出两个工厂
        AbstractCreator creator1 = new Creator1();
        AbstractCreator creator2 = new Creator2();
        //产生A1对象
        AbstractProductA a1 = creator1.createProductA();
        //产生A2对象
        AbstractProductA a2 = creator2.createProductA();
        //产生B1对象
        AbstractProductB b1 = creator1.createProductB();
        //产生B2对象
        AbstractProductB b2 = creator2.createProductB();
        a1.doSomething();
        a2.doSomething();
        b1.doSomething();
        b2.doSomething();
    }
}

结果

我是产品A1
我是产品A2
我是产品B1
我是产品B2

使用场景： 一个对象族（或是一组没有任何关系的对象）都有相同的约束。 涉及不同操作系统的时候，都可以考虑使用抽象工厂模式。
总结
总结下抽象工厂模式的特点，抽象工厂是所有形式的工厂模式中最为抽象和最具一般性的一种形态，其优缺点大致如下：
1、隔离了具体类的生成，使得客户并不需要知道什么被创建，具有良好的封装性。
2、横向扩展容易。同个产品族如果需要增加多个 产品，只需要增加新的工厂类和产品类即可。
3、纵向扩展困难。如果增加新的产品组，抽象工厂类也要添加创建该产品组的对应方法，这样一来所有的具体工厂类都要做修改了，严重违背了开闭原则。

4.模板方法模式（Template Method Pattern）
定义：Define the skeleton of an algorithm in an operation,deferring some steps to subclasses.Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure.（定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。）
AbstractClass 叫做抽象模板，它的方法分为两类：
● 基本方法 基本方法也叫做基本操作，是由子类实现的方法，并且在模板方法被调用。
● 模板方法 可以有一个或几个，一般是一个具体方法，也就是一个框架，实现对基本方法的调度，完成固定的逻辑。注意：为了防止恶意的操作，一般模板方法都加上 final 关键字，不允许被覆写。
具体模板：ConcreteClass1 和 ConcreteClass2 属于具体模板，实现父类所定义的 一个或多个抽象方法，也就是父类定义的基本方法在子类中得以实现
使用场景：
● 多个子类有公有的方法，并且逻辑基本相同时。
● 重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能则由各个子类实现。
● 重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类中，然后通过钩子函数（见“模板方法模式的扩展”）约束其行为。
不多说直接上代码

public abstract class Template {
    protected void work() {
        System.out.println("还要工作");
    }
    //模拟一天吃饭
    // 早饭
    public abstract void breakfast();
    // 午餐
    public abstract void lunch();
    // 晚餐
    public abstract void dinner();

public class PeopleA extends Template {

    @Override
    public void breakfast() {
        System.out.println("吃煎饼");
    }
    @Override
    public void lunch() {
        System.out.println("吃米饭");
    }
    @Override
    public void dinner() {
        System.out.println("喝汤");
    }
}

public class PeopleB extends Template {

    @Override
    public void breakfast() {
        System.out.println("吃水饺");
    }
    @Override
    public void lunch() {
        System.out.println("吃菜");
    }
    @Override
    public void dinner() {
        System.out.println("烤鸭");
    }
    private void travel() {
        System.out.println("去北京旅游");
    }
}

模板模式的优点：
　（1）具体细节步骤实现定义在子类中，子类定义详细处理算法是不会改变算法整体结构。
　（2）代码复用的基本技术，在数据库设计中尤为重要。
　（3）存在一种反向的控制结构，通过一个父类调用其子类的操作，通过子类对父类进行扩展增加新的行 为，符合“开闭原则”。
不足：
每个不同的实现都需要定义一个子类，会导致类的个数增加，系统更加庞大。

5.建造者模式（Builder Pattern）
定义：Separate the construction of a complex object from its representation so that the same construction process can create different representations.
（将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。）

● Product 产品类 通常是实现了模板方法模式，也就是有模板方法和基本方法，例子中的 BenzModel 和 BMWModel 就属于产品类。
● Builder 抽象建造者 规范产品的组建，一般是由子类实现。例子中的 CarBuilder 就属于抽象建造者。
● ConcreteBuilder 具体建造者 实现抽象类定义的所有方法，并且返回一个组建好的对象。例子中的 BenzBuilder 和 BMWBuilder 就属于具体建造者。
● Director 导演类 负责安排已有模块的顺序，然后告诉 Builder 开始建造 使用场景：
● 相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。
● 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时， 则可以使用该模式。
● 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使 用建造者模式非常合适。 建造者模式与工厂模式的不同： 建造者模式最主要的功能是基本方法的调用顺序安排，这些基本方法已经实现了， 顺序不同产生的对象也不同； 工厂方法则重点是创建，创建零件是它的主要职责，组装顺序则不是它关心的。

6.代理模式（Proxy Pattern）
定义：Provide a surrogate or placeholder for another object to control access to it. （为其他对象提供一种代理以控制对这个对象的访问。）
● Subject 抽象主题角色 抽象主题类可以是抽象类也可以是接口，是一个最普通的业务类型定义，无特殊要 求。
● RealSubject 具体主题角色 也叫做被委托角色、被代理角色。它才是冤大头，是业务逻辑的具体执行者。
● Proxy 代理主题角色 也叫做委托类、代理类。它负责对真实角色的应用，把所有抽象主题类定义的方法 限制委托给真实主题角色实现，并且在真实主题角色处理完毕前后做预处理和善后 处理工作。
普通代理和强制代理： 普通代理就是我们要知道代理的存在，也就是类似的 GamePlayerProxy 这个类的 存在，然后才能访问； 强制代理则是调用者直接调用真实角色，而不用关心代理是否存在，其代理的产生 是由真实角色决定的。 普通代理：

在该模式下，调用者只知代理而不用知道真实的角色是谁，屏蔽了真实角色的变更 对高层模块的影响，真实的主题角色想怎么修改就怎么修改，对高层次的模块没有
任何的影响，只要你实现了接口所对应的方法，该模式非常适合对扩展性要求较高 的场合。 强制代理：

强制代理的概念就是要从真实角色查找到代理角色，不允许直接访问真实角色。高 层模块只要调用 getProxy 就可以访问真实角色的所有方法，它根本就不需要产生 一个代理出来，代理的管理已经由真实角色自己完成。 动态代理： 根据被代理的接口生成所有的方法，也就是说 给定一个接口，动态代理会宣称 “ 我 已经实现该接口下的所有方法了 ” 。

两条独立发展的线路。动态代理实现代理的职责，业务逻辑 Subject 实现相关的逻 辑功能，两者之间没有必然的相互耦合的关系。通知 Advice 从另一个切面切入， 最终在高层模块也就是 Client 进行耦合，完成逻辑的封装任务。 动态代理调用过程示意图：

动态代理的意图：横切面编程，在不改变我们已有代码结构的情况下增强或控制对 象的行为。 首要条件：被代理的类必须要实现一个接口。