类图的六大关系
依赖
依赖关系是指类中用到了对方。可以是“类的成员属性”、“方法的返回类型”、“方法接收的参数类型”和“方法中使用到的类”。对应的类图：
public class PersonServiceBean {private PersonDao personDao;public void save(Person person) {}public IDCard getIDCare(Integer personid) {return null;}public void modefy() {Department department = new Department();}}
public class Department {}public class IDCard {}public class Person {}public class PersonDao {}
泛化
泛化关系实际上就是继承关系，是依赖关系的特例。
对应的类图：
public abstract class DaoSupport {public void save(Object entity) {}public void delete(Object id) {}}public class PersonServiceBean extends DaoSupport {}//泛化关系就是继承关系//如果A类继承了B类,我们就说A类和B类存在泛化关系
实现
实现关系实际上就是A类实现B类的接口，是依赖关系的特例。
类图如下：
public interface PersonService {public void delete(Integer id);}public class PersonServiceBean implements PersonService {@Overridepublic void delete(Integer id) {// TODO Auto-generated method stubSystem.out.println("delete..");}}
关联
关联关系实际上就是类与类之间的关系，是依赖关系的特例。
关联具有导航性：即双向关系或单向关系。
关联具有多重性：如“1”（表示有且仅有一个），“0…”（表示0个或多个），“0，1”（表示0个或1个），“n…m”（表示n到m个都可以）。
UML类图:
单向一对一关系：
public class Person {private IDCard card;}public class IDCard {}
双向一对一关系：
public class Person {
private IDCard card;
}
public class IDCard {
private Person person;
}
聚合
聚合关系表示的是整体和部分的关系，整体与部分可以分开。聚合关系是关联关系的特例，具有关联的导航性与多重性。
如：一台电脑由键盘、显示器、鼠标等组成，组成电脑的各个配件是可以从电脑上分离出的，使用带空心菱形的实线来表示。
public class Computer {
private Mouse mouse; //鼠标可以和Computer分离
private Moniter moniter;//显示器可以和Computer分离
public void setMouse(Mouse mouse) {
this.mouse = mouse;
}
public void setMoniter(Moniter moniter) {
this.moniter = moniter;
}
}
组合
组合关系，也是整体与部分的关系，但是整体与部分不可以分开。
在程序中我们定义实体：Person与IDCard、Head，那么Head和Person就是组合，IDCard和Person就是聚合。
但是如果在程序中Person实体定义了对IDCard进行级联删除，即删除Person时连同IDCard一起删除，那么IDCard和Person就是组合了。
public class Person {
private IDCard card; //聚合关系
private Head head = new Head(); //组合关系
}
public class IDCard {
}
public class Head {
}
public class Computer {
private Mouse mouse = new Mouse(); //鼠标不可以和Computer分离
private Moniter moniter = new Moniter();//显示器不可以 和Computer分离
public void setMouse(Mouse mouse) {
this.mouse = mouse;
}
public void setMoniter(
Moniter moniter) {
this.moniter = moniter;
}
}
摘要
设计模式分为三种类型，共 23 种
1）创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。
2） 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
3）行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter 模式）、状态模式、策略模式、职责链模式(责任链模式)。
单例模式
单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。
比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够了，这时就会使用到单例模式。3.1.2 单例模式的八种方式
单例模式有八种方式：
1. 饿汉式（静态常量）；
2. 饿汉式（静态代码块）；
3. 懒汉式（线程不安全）；
4. 懒汉式（线程安全，同步方法）；
5. 懒汉式（线程安全，同步代码块）；
6. 双重检查；
7. 静态内部类；
8. 枚举
八种方式详解
饿汉式（静态常量）
代码演示：
public class SingletonTest1 {
public static void main(String[] args) {
Singleton instance = Singleton.getInstance();
Singleton instance2 = Singleton.getInstance();
System.out.println(instance == instance2);
}
}
//饿汉式（静态常量）
class Singleton {
//1、构造器私有化，外部不能new
private Singleton() {
}
//2、本类内部创建对象实例
private final static Singleton instance = new Singleton();
//3、提供一个公有的静态方法，返回实例对象
public static Singleton getInstance() {
return instance;
}
}
优缺点说明：
优点：这种写法比较简单，就是在类装载的时候就完成实例化，避免了线程同步问题；
缺点：在类装载的时候就完成实例化，没有达到懒加载的效果，如果从始至终从未使用过这个实例，则会造成内存的浪费；
这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他静态方法）导致类加载，这时候初始化instance就没有达到懒加载的效果。
结论：这种单例模式可用，可能造成内存浪费。
饿汉式（静态代码块）
代码演示：
public class SingletonTest2 {
public static void main(String[] args) {
Singleton instance = Singleton.getInstance();
Singleton instance2 = Singleton.getInstance();
System.out.println(instance == instance2);
}
}
//饿汉式（静态代码块）
class Singleton {
//1、构造器私有化，外部不能new
private Singleton() {
}
//2、静态代码块
private static Singleton instance;
static {
instance = new Singleton();
}
//3、提供一个公有的静态方法，返回实例对象
public static Singleton getInstance() {
return instance;
}
}
优缺点说明：
这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码快中的代码，初始化类的实例。优缺点和上面是一样的。
结论：这种单例模式可用，但是可能造成内存浪费。
懒汉式（线程不安全）
代码演示：
public class SingletonTest3 {
public static void main(String[] args) {
Singleton instance = Singleton.getInstance();
Singleton instance2 = Singleton.getInstance();
System.out.println(instance == instance2);
}
}
//懒汉式（线程不安全）
class Singleton {
private static Singleton instance;
private Singleton() {
}
//提供一个静态的公有方法，当使用到该方法时，才去创建instance
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
优缺点说明：
* 起到了懒加载的效果，但是只能在单线程下使用；
* 如果在多线程下，一个线程进入了if(singleton==null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。
* 结论：在实际开发中，不要使用这种方式。
懒汉式（线程安全，同步方法）
代码演示：
public class SingletonTest4 {
public static void main(String[] args) {
Singleton instance = Singleton.getInstance();
Singleton instance2 = Singleton.getInstance();
System.out.println(instance == instance2);
}
}
//懒汉式（线程安全，同步方法）
class Singleton {
private static Singleton instance;
private Singleton() {
}
//提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
优缺点说明：
解决了线程安全问题；
效率太低了，每个线程在想获得类的实例的时候，执行getInstance（）方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低；
结论：在实际开发中，不推荐使用这种方式。
懒汉式（线程安全，同步代码块）
代码演示：
public class SingletonTest5 {
public static void main(String[] args) {
Singleton instance = Singleton.getInstance();
Singleton instance2 = Singleton.getInstance();
System.out.println(instance == instance2);
}
}
//懒汉式（线程安全，同步代码块）
class Singleton {
private static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
instance = new Singleton();
}
}
return instance;
}
}
说明：
- 看似线程安全，但不一定安全。
- 结论：不推荐使用。
双重检查
代码演示：
public class SingletonTest6 {
public static void main(String[] args) {
Singleton instance = Singleton.getInstance();
Singleton instance2 = Singleton.getInstance();
System.out.println(instance == instance2);
}
}
//双重检查
class Singleton {
private static volatile Singleton instance;
private Singleton() {
}
//提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
public static synchronized Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
优缺点说明：
- Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if(singleton==null)检查，这样就可以保证线程安全了。
- 这样，实例化代码只用执行一次，后面再次访问时，判断if(singleton==null)，直接reeturn实例化对象，也避免反复进行方法同步；
- 线程安全，延迟加载，效率较高；
- 结论：在实际开发中，推荐使用这种单例设计模式。
静态内部类
代码演示：
public class SingletonTest7 {
public static void main(String[] args) {
Singleton instance = Singleton.getInstance();
Singleton instance2 = Singleton.getInstance();
System.out.println(instance == instance2);
}
}
//静态内部类
class Singleton {
private Singleton() {
}
//写一个静态内部类，该类中有一个静态属性Singleton
private static class singleInstance {
private static final Singleton INSTANCE = new Singleton();
}
//提供一个静态的公有方法，直接返回对象
public static synchronized Singleton getInstance() {
return singleInstance.INSTANCE;
}
}
优缺点说明：
- 静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，会装载SingletonInstance类，从而完成Singleton的实例化；
- 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的；
- 这种方法采用类装载的机制来保证初始化实例时只有一个线程
- 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高；
- 结论：推荐使用
枚举
代码演示：
public class SingletonTest8 {
public static void main(String[] args) {
Singleton instance = Singleton.INSTANCE;
Singleton instance2 = Singleton.INSTANCE;
System.out.println(instance == instance2);
instance.sayOK();
}
}
//使用枚举，可以实现单例
enum Singleton {
INSTANCE;//属性
public void sayOK() {
System.out.println("ok");
}
}
优缺点说明：
- 这借助了JDK1.5中添加的枚举来实现单例模式，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象；
- 结论：推荐使用
单例模式注意事项和细节说明
单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
- 当想实例化一个单例类的时候，必须要记住使用相应的获得对象的方法，而不是使用new；
- 单例模式使用场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多（即：重量级对象），但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象（比如数据源、session工厂等）。
工厂模式
看一个披萨的项目：要便于披萨种类的扩展，要便于维护。
- 披萨的种类很多（比如GreekPizza、CheesePizza等）；
- 披萨的制作有prepare，bake，cut，box；
- 完成披萨店订购功能。
使用传统的方式完成
//把Pizza类做成抽象类
public abstract class Pizza {
private String name;//名字
//准备原材料，不同的披萨不一样，因此，我们做成抽象方法
public abstract void prepare();
public void bake() {
System.out.println(name + " baking");
}
public void cut() {
System.out.println(name + " cutting");
}
public void box() {
System.out.println(name + " boxing");
}
public void setName(String name) {
this.name = name;
}
}
public class GreekPizza extends Pizza {
@Override
public void prepare() {
System.out.println("给GreekPizza准备原材料");
}
}
public class CheessPizza extends Pizza {
@Override
public void prepare() {
System.out.println("给CheessPizza准备原材料");
}
}
public class OrderPizza {
//构造方法
public OrderPizza() {
Pizza pizza = null;
String orderType;//订购披萨的类型
do {
orderType = getType();
if (orderType.equals("greek")) {
pizza = new GreekPizza();
pizza.setName("GreekPizza");
} else if (orderType.equals("cheess")) {
pizza = new CheessPizza();
pizza.setName("CheessPizza");
} else {
break;
}
//输出pizza制作过程
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} while (true);
}
//写一个方法，可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza type:");
String str = null;
str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
//相当于客户端
public class OrderStore {
public static void main(String[] args) {
OrderPizza orderPizza = new OrderPizza();
}
}
传统方式的优缺点：
很显然，当需要扩展时，面对的问题非常大，违反了OCP原则
- 优点是比较好理解，简单易操作；
- 缺点是违反了设计模式的ocp原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽量少修改代码；
- 比如这时我们要新增加一个Pizza的种类（Pepper披萨），我们需要做的修改较大。
改进的思路分析：
- 分析：修改代码可以接受，但是如果我们在其它的地方也有创建Pizza的代码，就意味着，也需要修改，而创建Pizza的代码，往往有多处；
- 思路：把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改该类就可，其它有创建到Pizza对象的代码就不需要修改了（使用简单工厂模式）。
简单工厂模式
简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。
简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为。
在软件开发中，当我们会用到大量的创建某种、某类或者谋批对象时，就会使用到工厂模式。
简单工厂模式的设计方案：定义一个可以实例化Pizza对象的类，封装创建对象的代码。
//简单工厂类
public class SimpleFactory {
//简单工厂模式，也叫静态工厂模式，可以用static修饰该方法
public Pizza createPizza(String orderType) {
Pizza pizza = null;
if (orderType.equals("greek")) {
pizza = new GreekPizza();
pizza.setName("GreekPizza");
} else if (orderType.equals("cheess")) {
pizza = new CheessPizza();
pizza.setName("CheessPizza");
}
//输出pizza制作过程
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
}
public class OrderPizza2 {
//定义一个简单工厂对象
SimpleFactory simpleFactory;
//构造器
public OrderPizza2(SimpleFactory simpleFactory) {
setFactory(simpleFactory);
}
Pizza pizza = null;
public void setFactory(SimpleFactory simpleFactory) {
String orderType = "";//用户输入的
this.simpleFactory = simpleFactory;//设置简单工厂对象
do {
orderType = getType();
pizza = this.simpleFactory.createPizza(orderType);
//输出pizza制作过程
if (pizza != null) {
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} else {
System.out.println("订购失败");
break;
}
} while (true);
}
//写一个方法，可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza type:");
String str = null;
str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
静态工厂模式
静态工厂模式也是简单工厂模式的一种，只是将工厂方法改为静态方法
public class PizzaFactory {
public static Pizza createPizza(String orderType) {
// ...
}
}
public class OrderPizza {
public OrderPizza() {
Pizza pizza;
do {
pizza = PizzaFactory.createPizza(getType());
// ...
} while (true);
}
工厂方法模式
披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如“北京的奶酪披萨”、“北京的胡椒披萨”或者是“伦敦的奶酪披萨”、“伦敦的胡椒披萨”。
思路一：使用简单工厂模式。创建不同的简单工厂类，比如BJPizzaSimpleFactory、LDPizzzaSimpleFactory等等，从当前这个案例来说，也是可以的，但是考虑到项目的规模，以及软件的可维护性 、可扩展性并不是特别好。
思路二：使用工厂方法模式。将披萨项目的实例化功能抽象成抽象方法，在不同口味点餐子类中具体实现。
工厂方法模式定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类
//把Pizza类做成抽象类
public abstract class Pizza {
private String name;//名字
//准备原材料，不同的披萨不一样，因此，我们做成抽象方法
public abstract void prepare();
public void bake() {
System.out.println(name + " baking");
}
public void cut() {
System.out.println(name + " cutting");
}
public void box() {
System.out.println(name + " boxing");
}
public void setName(String name) {
this.name = name;
}
}
public class BJCheessPizza extends Pizza {
@Override
public void prepare() {
setName("北京的CheessPizza");
System.out.println(" 北京的CheessPizza 准备原材料");
}
}
public class BJPepperPizza extends Pizza {
@Override
public void prepare() {
setName("北京的Pepper");
System.out.println(" 北京的Pepper 准备原材料");
}
}
public class LDCheessPizza extends Pizza {
@Override
public void prepare() {
setName("伦敦的CheessPizza");
System.out.println(" 伦敦的CheessPizza 准备原材料");
}
}
public class LDPepperPizza extends Pizza {
@Override
public void prepare() {
setName("伦敦的Pepper");
System.out.println(" 伦敦的Pepper 准备原材料");
}
}
public abstract class OrderPizza {
//构造方法
public OrderPizza() {
Pizza pizza = null;
String orderType;//订购披萨的类型
do {
orderType = getType();
//调用方法
pizza = creatPizza(orderType);
//输出pizza制作过程
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} while (true);
}
//定义一个抽象方法，让各个工厂子类自己实现
abstract Pizza creatPizza(String orderType);
//写一个方法，可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza type:");
String str = null;
str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
public class BJOrderPizza extends OrderPizza {
@Override
Pizza creatPizza(String orderType) {
Pizza pizza=null;
if (orderType.equals("Cheess")){
pizza=new BJCheessPizza();
}else if(orderType.equals("Pepper")){
pizza=new BJPepperPizza();
}
return pizza;
}
}
public class LDOrderPizza extends OrderPizza {
@Override
Pizza creatPizza(String orderType) {
Pizza pizza = null;
if (orderType.equals("Cheess")) {
pizza = new LDCheessPizza();
} else if (orderType.equals("Pepper")) {
pizza = new LDPepperPizza();
}
return pizza;
}
}
//披萨店
public class PizzaStore {
public static void main(String[] args) {
new BJOrderPizza();//创建北京各种口味的披萨
new LDOrderPizza();//创建伦敦各种口味的披萨
}
}
抽象工厂模式
抽象工厂模式：
定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类。
抽线工厂模式可以将简单工厂模式和工厂方法模式进行整合。
从设计层面看，抽象工厂模式就是对简单工厂模式的改进（或者 称为进一步的抽象）。
将工厂抽象成两层，AbsFactory（抽象工厂）具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护。
//一个抽象工厂模式的抽象层（接口）
public interface AbsFactory {
//让下面的工厂子类来具体实现
Pizza createPizza(String orderType);
}
//这是一个工厂子类
public class BJFactory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
Pizza pizza = null;
if (orderType.equals("Cheess")) {
pizza = new BJCheessPizza();
}
if (orderType.equals("Pepper")) {
pizza = new BJPepperPizza();
}
return pizza;
}
}
public class LDFactory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
Pizza pizza=null;
if (orderType.equals("Cheess")){
pizza=new LDCheessPizza();
}if (orderType.equals("Pepper")){
pizza=new LDPepperPizza();
}
return pizza;
}
}
public class OrderPizza {
AbsFactory factory;
//构造器
public OrderPizza(AbsFactory factory) {
setFactory(factory);
}
private void setFactory(AbsFactory factory) {
Pizza pizza = null;
String orderType = "";//用户输入
this.factory = factory;
do {
orderType = getType();
//factory可能是北京的工厂子类，也可能是伦敦的工厂子类
pizza = factory.createPizza(orderType);
if (pizza != null) {
pizza.prepare();
pizza.bake();
pizza.box();
pizza.cut();
} else {
System.out.println("订购失败");
break;
}
} while (true);
}
//写一个方法，可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza type:");
String str = null;
str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
public class PizzaStore {
public static void main(String[] args) {
new OrderPizza(new BJFactory());
new OrderPizza(new LDFactory());
}
}
JDK源码分析
工厂模式小结
工厂模式的意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦，从而提高项目的扩展和维护性。
三种工厂模式：简单工厂模式、工厂方法模式、抽象工厂模式。
设计模式的依赖抽象原则：
- 创建对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用；
- 不要让类继承具体类，而是继承抽象类或者是实现interface（接口）；
- 不要覆盖基类中已经实现的方法。
JDK-CLANDERR用到了简单的工厂模式
原型模式
克隆羊问题
现在有一只羊，姓名为：tom，年龄为：1，颜色为：白色，请编写程序创建和tom羊属性完全相同的10只羊。
传统方式解决克隆羊问题
public class Sheep {
private String name;
private int age;
private String color;
public Sheep(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
//get、set方法
@Override
public String toString() {
return "Sheep{" +
"name='" + name + '\'' +
", age=" + age +
", color='" + color + '\'' +
'}';
}
}
public class Client {
public static void main(String[] args) {
Sheep sheep = new Sheep("tom", 1, "白色");
Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
//......
System.out.println(sheep);
System.out.println(sheep2);
System.out.println(sheep3);
}
}
传统的方式的优缺点：
- 优点是比较好理解，简单易操作；
- 在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低；
- 总是需要重新初始化对象，而不是动态地获得对象运行时的状态，不够灵活；
改进的思路分析：Java中Object类是所有类的根类，Object类提供了一个clone( )方法，该方法可以将一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个接口Cloneable，该接口表示该类能够复制且具有复制的能力（原型模式）。
原型模式
原型模式是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。
原型模式是一种创建型设计模式，允许一个对象再创建另一个可定制的对象，无需知道如何创建的细节。
工作原理是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即“对象.clone( )”。
UML类图
public class Sheep implements Cloneable {
private String name;
private int age;
private String color;
public Sheep(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
//get、set方法
@Override
public String toString() {
return "Sheep{" +
"name='" + name + '\'' +
", age=" + age +
", color='" + color + '\'' +
'}';
}
//克隆该实例，使用默认的clone方法来完成
@Override
protected Object clone() {
Sheep sheep = null;
try {
sheep = (Sheep) super.clone();
} catch (CloneNotSupportedException e) {
System.out.println(e.getMessage());
}
return sheep;
}
}
public class Client {
public static void main(String[] args) {
Sheep sheep = new Sheep("tom", 1, "白色");
Sheep sheep2 = (Sheep) sheep.clone();
Sheep sheep3 = (Sheep)sheep.clone();
//......
System.out.println(sheep);
System.out.println(sheep2);
System.out.println(sheep3);
}
}
浅拷贝与深拷贝
浅拷贝
对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。
对于数据类型是引用类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响另一个对象的该成员变量值。
前面我们的克隆羊案例就是浅拷贝。
浅拷贝是使用默认的clone( ）方法来实现。
深拷贝
复制对象的所有基本数据类型的成员变量值。
为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象，也就是说，对象进行深拷贝要对整个对象（包括对象的引用类型）进行拷贝。
深拷贝的实现方式1：重写clone方法。
深拷贝实现方式2：通过对象序列化实现（推荐）。
public class DeepCloneableTarget implements Serializable, Cloneable {
private static final long serialVersionUID = 1L;
private String cloneName;
private String cloneClass;
public DeepCloneableTarget(String cloneName, String cloneClass) {
this.cloneName = cloneName;
this.cloneClass = cloneClass;
}
//因为该类的属性都是String，因此我们这里使用默认的clone完成即可
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class DeepProtoType implements Serializable, Cloneable {
public String name;
public DeepCloneableTarget deepCloneableTarget;
public DeepProtoType() {
super();
}
//深拷贝-方式1
@Override
protected Object clone() throws CloneNotSupportedException {
Object deep = null;
//完成对属性为基本数据类型和String的克隆
deep = super.clone();
//对属性为引用类型的单独处理
DeepProtoType deepProtoType = (DeepProtoType) deep;
deepProtoType.deepCloneableTarget = (DeepCloneableTarget) deepCloneableTarget.clone();
return deepProtoType;
}
//深拷贝-方式2
public Object deepClone() {
//创建流对象
ByteArrayOutputStream bos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bis = null;
ObjectInputStream ois = null;
try {
//序列化
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
oos.writeObject(this); //把当前这个对象以对象流的方式输出
//反序列化
bis = new ByteArrayInputStream(bos.toByteArray());
ois = new ObjectInputStream(bis);
DeepProtoType copyObj = (DeepProtoType) ois.readObject();
return copyObj;
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
//关闭流
try {
bos.close();
oos.close();
bis.close();
ois.close();
} catch (Exception e2) {
System.out.println(e2.getMessage());
}
}
}
}
public class Client {
public static void main(String[] args) throws Exception {
DeepProtoType p = new DeepProtoType();
p.name = "宋江";
p.deepCloneableTarget = new DeepCloneableTarget("小明", "学生类");
//测试，方式1
DeepProtoType p1 = (DeepProtoType) p.clone();
System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
System.out.println("p1.name=" + p.name + "p2.deepCloneableTarget=" + p1.deepCloneableTarget.hashCode());
//测试，方式2
DeepProtoType p2 = (DeepProtoType) p.deepClone();
System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
}
}
JDK源码分析
原型模式的注意事项的细节
- 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率；
- 不用重新初始化对象，而是动态地获得对象运行时的状态；
- 如果原始对象发生变化（增加或者减少属性），其它克隆对象的也会发生相应的变化，无需修改代码 ；
- 在实现深克隆的时候可能需要比较复杂的代码；
- 缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了ocp原则，这点请注意。
建造者模式
盖房项目需求
需求描述：
- 需要建造房子：这一过程为：打桩、砌墙、封顶。
- 房子有各种各样的，比如普通房，高楼，别墅，各种房子的过程虽然一样，但是要求不要相同的。
- 请编写程序，完成需求。
传统方式解决盖房需求
public abstract class AbstractHouse {
public abstract void buildbasic();//打地基
public abstract void buildWalls();//砌墙
public abstract void roofed();//封顶
public void build() {
buildbasic();
buildWalls();
roofed();
}
}
public class CommonHouse extends AbstractHouse {
@Override
public void buildbasic() {
System.out.println("普通房子打地基");
}
@Override
public void buildWalls() {
System.out.println("普通房子砌墙");
}
@Override
public void roofed() {
System.out.println("普通房子封顶");
}
}
public class Client {
public static void main(String[] args) {
AbstractHouse commonHouse = new CommonHouse();
commonHouse.build();
}
}
传统方式问题分析：
- 优点是比较好理解，简单易操作。
- 设计的程序结构，过于简单，没有设计缓存层对象，程序的扩展和维护不好，也就是说，这种设计方案，把产品（房子）和创建产品的过程（建房子的流程）封装在一起，耦合性增强了。
- 解决方案：将产品和产品建造过程解耦，即使用建造者模式。
建造者模式
建造者模式，又叫生成器模式，是一种对象构建模式，它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。
建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。
建造者模式的四个角色：
- Product（产品角色）：一个具体的产品对象。
- Builder（抽象建造者）：创建一个Product对象的各个部件指定的接口/抽象类。
- ConcreteBuilder（具体建造者）：实现接口，构建和装配各个部件。
- Director（指挥者）：构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。它主要由两个作用，一是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程。
下面我们使用建造者模式来完成需求。
//产品-->Product
public class House {
private String baise;
private String wall;
private String roofed;
public String getBaise() {
return baise;
}
public void setBaise(String baise) {
this.baise = baise;
}
public String getWall() {
return wall;
}
public void setWall(String wall) {
this.wall = wall;
}
public String getRoofed() {
return roofed;
}
public void setRoofed(String roofed) {
this.roofed = roofed;
}
}
//抽象的建造者
public abstract class HouseBuilder {
protected House house = new House();
//将建造的流程写好，抽象的方法
public abstract void buildBasic();
public abstract void buildWalls();
public abstract void roofed();
//建造房子后，将产品（房子）返回
public House buildHouse() {
return house;
}
}
public class CommonHouse extends HouseBuilder {
@Override
public void buildBasic() {
System.out.println("普通房子打地基 5米");
}
@Override
public void buildWalls() {
System.out.println("普通房子砌墙10cm");
}
@Override
public void roofed() {
System.out.println("普通房子屋顶");
}
}
public class HighBuilding extends HouseBuilder {
@Override
public void buildBasic() {
System.out.println("高楼的打地基100米");
}
@Override
public void buildWalls() {
System.out.println("高楼的砌墙20cm");
}
@Override
public void roofed() {
System.out.println("高楼的透明屋顶");
}
}
//指挥者，指定制作流程
public class HouseDirector {
HouseBuilder houseBuilder = null;
//通过构造器传入houseBuilder
public HouseDirector(HouseBuilder houseBuilder) {
this.houseBuilder = houseBuilder;
}
//或者通过set方法传入houseBuilder
public void setHouseBuilder(HouseBuilder houseBuilder) {
this.houseBuilder = houseBuilder;
}
//如何处理建造房子的流程？交给指挥者
public House constructHouse() {
houseBuilder.buildBasic();
houseBuilder.buildWalls();
houseBuilder.roofed();
return houseBuilder.buildHouse();
}
}
public class Client {
public static void main(String[] args) {
CommonHouse commonHouse = new CommonHouse();//盖普通房子
//HighBuilding highBuilding = new HighBuilding();//盖高房子
HouseDirector houseDirector = new HouseDirector(commonHouse);//创建房子的指挥者
House house = houseDirector.constructHouse();//完成盖房，返回产品（房子）
}
}
StringBuilder在JDK源码分析
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
}
//此为jdk中 AbstractStringBuilder类实现的append方法，即StringBuilder实际上是指挥者，
//而且充当了建造者的身份
建造者模式的注意事项和细节
客户端（使用程序）不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。
可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
增加新的具体建造者无需修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”。
建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，因此这种情况下，要考虑是否选择建造者模式。
此前五种模式皆为创建型模式
若有收获，就点个赞吧
0 人点赞
