设计模式

package com.lby.singleton;


import java.io.ObjectStreamException;
import java.io.Serializable;

/**
 *饿汉式
 */
public class SingletonDemo1 {
    //先实例化当前类的对象
    private static SingletonDemo1 singletonDemo1 = new SingletonDemo1();
    //私有化构造器
    private SingletonDemo1(){}
    //通过getInstance()调用该类的对象
    public static SingletonDemo1 getInstance(){
        return singletonDemo1;
    }
}
/**
 * 懒汉式
 */
class SingletonDemo2{
    //定义当前类的对象，但是不实例化，调用的时候在实例化，实现延时加载
    private static SingletonDemo2 singletonDemo2;
    //私有化构造器
    private SingletonDemo2(){}
    //通过getInstance()调用该类的对象，并发的时候线程不安全，所以要加同步
    public static synchronized SingletonDemo2 getInstance(){
        if(singletonDemo2 == null){
            singletonDemo2 =  new SingletonDemo2();
        }
        return singletonDemo2;
    }
}

/**
 * 双重检查锁实现单例模式
 * 编译器优化和JVM底层内部模型原因， 偶尔会出问题。不建议使用
 */
class SingletonDemo3 {

    private static SingletonDemo3 instance = null;

    public static SingletonDemo3 getInstance() {
        if (instance == null) {
            SingletonDemo3 sc;
            synchronized (SingletonDemo3.class) {
                sc = instance;
                if (sc == null) {
                    synchronized (SingletonDemo3.class) {
                        if(sc == null) {
                            sc = new SingletonDemo3();
                        }
                    }
                    instance = sc;
                }
            }
        }
        return instance;
    }
    private SingletonDemo3() {}
}

/**
 * 静态内部类实现单例模式
 */
class SingletonDemo4{
    //静态内部类
    private static class SingletonClasssInstance{
        private static SingletonDemo4 /*final*/ singletonInstance = new SingletonDemo4();
    }
    //私有化构造方法
    private SingletonDemo4(){}

    //不需要synchronized,因为类加载的时候线程时安全的
    public static SingletonDemo4 getInstance(){
        return SingletonClasssInstance.singletonInstance;
    }
}

/**
 * 枚举方式实现单例模式
 */
enum SingletonDemo5{

    //枚举元素本身就是单例的
    INSTANCE;
}

/**
 * 防止序列化和反射的懒加载
 */
 class SingletonDemo6 implements Serializable {

     private static SingletonDemo6 singletonDemo6Instance;
     //防止反射
     private SingletonDemo6(){
         if(singletonDemo6Instance != null){
             throw new RuntimeException();
         }
     }

     public static SingletonDemo6 getInstance(){
         if(singletonDemo6Instance == null){
             singletonDemo6Instance = new SingletonDemo6();
         }
         return singletonDemo6Instance;
     }

    private Object readResolve() throws ObjectStreamException {
        return singletonDemo6Instance;
    }

}

测试代码：

package com.lby.singleton;

public class Client {

    public static void main(String[] args) {

        System.out.println("饿汉式");

        SingletonDemo1 s11 = SingletonDemo1.getInstance();
        SingletonDemo1 s12 = SingletonDemo1.getInstance();
        System.out.println(s11);
        System.out.println(s12);

        System.out.println("懒汉式");

        SingletonDemo1 s21 = SingletonDemo1.getInstance();
        SingletonDemo1 s22 = SingletonDemo1.getInstance();
        System.out.println(s21);
        System.out.println(s22);

        System.out.println("静态内部类实现单例");

        SingletonDemo4 s41 = SingletonDemo4.getInstance();
        SingletonDemo4 s42 = SingletonDemo4.getInstance();
        System.out.println(s41);
        System.out.println(s42);

        System.out.println("枚举方式实现单例模式");

        SingletonDemo5 s51 = SingletonDemo5.INSTANCE;
        SingletonDemo5 s52 = SingletonDemo5.INSTANCE;
        System.out.println(s51 == s52);
        System.out.println(s51.hashCode());
        System.out.println(s52.hashCode());
    }

}

package com.lby.singleton;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * 测试反射和反序列化破解单例模式
 */
public class Client2 {
	
	public static void main(String[] args) throws Exception {
		SingletonDemo6 s1 = SingletonDemo6.getInstance();
		SingletonDemo6 s2 = SingletonDemo6.getInstance();
		
		System.out.println(s1);
		System.out.println(s2);
		
		//通过反序列化的方式构造多个对象 
		FileOutputStream fos = new FileOutputStream("d:/a.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(s1);
		oos.close();
		fos.close();
		
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
		SingletonDemo6 s3 =  (SingletonDemo6) ois.readObject();
		System.out.println(s3);
		
		
	}
}

package com.lby.singleton;

import java.util.concurrent.CountDownLatch;

/**
 * 测试多线程环境下五种创建单例模式的效率
 */
public class Client3 {
	
	public static void main(String[] args) throws Exception {
		
		long start = System.currentTimeMillis();
		int threadNum = 10;
		final CountDownLatch countDownLatch = new CountDownLatch(threadNum);
		
		for(int i=0;i<threadNum;i++){
			new Thread(new Runnable() {
				@Override
				public void run() {
					for(int i=0;i<1000000;i++){
						Object o = SingletonDemo5.INSTANCE;
					}
					countDownLatch.countDown();
				}
			}).start();
		}
		countDownLatch.await();	//main线程阻塞，直到计数器变为0，才会继续往下执行！
		long end = System.currentTimeMillis();
		System.out.println("总耗时："+(end-start));
	}
}

使用场景：
（1）windows的任务管理器
（2）读取配置文件的类，一般也只有一个对象，只在项目加载时读取一次配置文件即可
（3）操作系统的文件资源系统
（4）spring中的bean也是单例
（5）springMVC的控制器对象也是单

工厂模式

1.定义
简单工厂模式:用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码，结构简单）
工厂方法模式:用来生产同一等级结构中的任意产品。（对于增加新的产品，不需要修改已有代码，结构复杂）

（专注于创建新的产品）

简单工厂模式

2.代码

package com.lby.simpleFactory;

/**
 * 电脑工厂类
 */
public class ComputerFactory {

    public static Computer creatHuaweiComputer(){
        return new HuaweiComputer();
    }

    public static Computer creatXiaomiComputer(){
        return new XiaomiComputer();
    }

}

package com.lby.simpleFactory;

/**
 * 电脑接口
 */
public interface Computer {
    void playComputer();
}

package com.lby.simpleFactory;

public class HuaweiComputer implements Computer {

    @Override
    public void playComputer() {
        System.out.println("使用华为玩游戏");
    }
}

package com.lby.simpleFactory;

public class XiaomiComputer implements Computer {

    @Override
    public void playComputer() {
        System.out.println("使用小米玩游戏");
    }
}

package com.lby.simpleFactory;

/**
 * 简单工厂
 */
public class Client {

    public static void main(String[] args) {
        Computer 华为 = ComputerFactory.creatHuaweiComputer();
        Computer 小米 = ComputerFactory.creatXiaomiComputer();
        华为.playComputer();
        小米.playComputer();
    }
}

结构

工厂方法模式

package com.lby.factoryMethod;

/**
 * 电脑接口
 */
public interface Computer {
    void playComputer();
}

package com.lby.factoryMethod;

/**
 * 电脑工厂类
 */
public interface ComputerFactory {
    Computer createComputerFactory();
}

package com.lby.factoryMethod;

public class HuaweiComputerFactory implements ComputerFactory{

    @Override
    public Computer createComputerFactory() {
        return new HuaweiComputer();
    }
}

package com.lby.factoryMethod;

public class XiaomiComputerFactory implements ComputerFactory {

    @Override
    public Computer createComputerFactory() {
        return new XiaomiComputer();
    }
}

package com.lby.factoryMethod;

public class HuaweiComputer implements Computer {

    @Override
    public void playComputer() {
        System.out.println("使用华为玩游戏");
    }
}

package com.lby.factoryMethod;

public class XiaomiComputer implements Computer {

    @Override
    public void playComputer() {
        System.out.println("使用小米玩游戏");
    }
}

package com.lby.factoryMethod;

/**
 * 简单工厂
 */
public class Client {

    public static void main(String[] args) {
        Computer 华为 = new HuaweiComputerFactory().createComputerFactory();
        Computer 小米 = new XiaomiComputerFactory().createComputerFactory();
        华为.playComputer();
        小米.playComputer();
    }
}

3.使用场景

可以和单例模式连用，通过工厂模式创建创建单例对象

抽象工厂模式

1.定义：为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类

（专注于创建新的产品族）

2.代码

package com.lby.abstractFactory;

/**
 * 电脑工厂抽象接口
 */
public interface ComputerFactory {

    HardDisk createHardDisk();
    Screen createScreen();
    Xianka createXianka();

}

package com.lby.abstractFactory;

/**
 * 生产高级配置电脑工厂
 */
public class AdvancedComputerFactory implements ComputerFactory{

    private AdvancedHardDisk advancedHardDisk;
    private AdvancedScreen advancedScreen;
    private AdvancedXianka advancedXianka;

    @Override
    public HardDisk createHardDisk() {
        advancedHardDisk = new AdvancedHardDisk();
        return advancedHardDisk;
    }

    @Override
    public Screen createScreen() {
        advancedScreen = new AdvancedScreen();
        return advancedScreen;
    }

    @Override
    public Xianka createXianka() {
        advancedXianka = new AdvancedXianka();
        return advancedXianka;
    }
}

package com.lby.abstractFactory;

/**
 * 生产低配电脑工厂
 */
public class LowLevelComputerFactory implements ComputerFactory{

    private LowLevelHardDisk lowLevelHardDisk;
    private LowLevelScreen lowLevelScreen;
    private LowLevelXianka lowLevelXianka;

    @Override
    public HardDisk createHardDisk() {
        lowLevelHardDisk = new LowLevelHardDisk();
        return lowLevelHardDisk;
    }

    @Override
    public Screen createScreen() {
        lowLevelScreen = new LowLevelScreen();
        return lowLevelScreen;
    }

    @Override
    public Xianka createXianka() {
        lowLevelXianka = new LowLevelXianka();
        return lowLevelXianka;
    }
}

package com.lby.abstractFactory;

/**
 * 硬盘接口
 */
public interface HardDisk {
    //保存数据
    void saveData();

}

/**
 * 低端硬盘实现类
 */
class LowLevelHardDisk implements HardDisk{

    @Override
    public void saveData() {
        System.out.println("地端硬盘保存数据");
    }
}

/**
 * 高端硬盘实现类
 */
class AdvancedHardDisk implements  HardDisk{
    @Override
    public void saveData() {
        System.out.println("高端硬盘保存数据");
    }
}

package com.lby.abstractFactory;

/**
 * 屏幕接口
 */
public interface Screen {
    //显示
    void showImage();

}

/**
 * 低端屏幕实现类
 */
class LowLevelScreen implements Screen{

    @Override
    public void showImage() {
        System.out.println("低段分辨率屏");
    }
}
/**
 * 高端屏幕实现类
 */
class AdvancedScreen implements  Screen{
    @Override
    public void showImage() {
        System.out.println("高端分辨率屏2k");
    }
}

package com.lby.abstractFactory;

/**
 * 显卡接口
 */
public interface Xianka {
    //运算
    void opration();

}

/**
 * 低端显卡接口
 */
class LowLevelXianka implements Xianka{

    @Override
    public void opration() {
        System.out.println("低端显卡正在运算");
    }
}

/**
 * 高端显卡接口
 */
class AdvancedXianka implements  Xianka{
    @Override
    public void opration() {
        System.out.println("高端显卡正在运算");
    }
}

package com.lby.abstractFactory;

public class Client {

    public static void main(String[] args) {

        System.out.println("###高端电脑###");

        ComputerFactory computerFactory1 = new AdvancedComputerFactory();
        computerFactory1.createHardDisk().saveData();
        computerFactory1.createScreen().showImage();
        computerFactory1.createXianka().opration();

        System.out.println("###低端电脑###");

        ComputerFactory computerFactory2 = new LowLevelComputerFactory();
        computerFactory2.createHardDisk().saveData();
        computerFactory2.createScreen().showImage();
        computerFactory2.createXianka().opration();



    }

}

3.结构

4.使用场景

可以增加产品族，例如在增加一个中等配置电脑的系列

建造者模式

1.定义
分离复杂对象的创建和装配，实现构建和装配和解耦
（专注于专注于单个复杂的对象）

2.代码

package com.lby.builder;

/**
 * 汽车复杂对象
 */
public class Car {

    private Tyre tyre;//轮胎
    private Engine engine;//发动机
    private CarFrame carFrame;//车架

    //setter和getter方法
    public Tyre getTyre() {
        return tyre;
    }

    public void setTyre(Tyre tyre) {
        this.tyre = tyre;
    }

    public Engine getEngine() {
        return engine;
    }

    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    public CarFrame getCarFrame() {
        return carFrame;
    }

    public void setCarFrame(CarFrame carFrame) {
        this.carFrame = carFrame;
    }

    //复杂对象方法
    public void run(){
        System.out.println("复杂对象汽车启动");
    }
}

/**
 * 轮胎
 */
class Tyre{

    private String name;

    public Tyre(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

/**
 * 发动机
 */
class Engine{

    private String name;

    public Engine(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

/**
 * 车架
 */
class CarFrame{

    private String name;

    public CarFrame(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

package com.lby.builder;

/**
 * 组装复杂对象的子组件
 */
public interface CarBuilder {

    Tyre buildTyre();
    Engine buildEngine();
    CarFrame buildCarFrame();

}

/**
 * 实现组装子组件
 */
class CarBuilderImp implements CarBuilder{

    private Tyre tyre;
    private  Engine engine;
    private CarFrame carFrame;

    @Override
    public Tyre buildTyre() {
        System.out.println("创建子组件轮胎");
        tyre = new Tyre("高级轮胎");
        return tyre;
    }

    @Override
    public Engine buildEngine() {
        System.out.println("创建子组件发动机");
        engine = new Engine("高级发动机");
        return engine;
    }

    @Override
    public CarFrame buildCarFrame() {
        System.out.println("创建子组件车架");
        carFrame = new CarFrame("高级车架");
        return carFrame;
    }
}

package com.lby.builder;

/**
 * 创建复杂对象汽车
 */
public interface AssembleCar {
    Car assembleCar();
}

/**
 * 创建复杂对象实现类
 */
class AssembleCarImp implements AssembleCar{

    //创建复杂对象需要先组装所有复杂对象的子组件，所以需要引入组装子对象的类
    private CarBuilder carBuilder;

    //通过构造方法进行引入组装对象
    public AssembleCarImp(CarBuilder carBuilder){
        this.carBuilder = carBuilder;
    }


    @Override
    public Car assembleCar() {
        Car car = new Car();
        car.setCarFrame(carBuilder.buildCarFrame());
        car.setEngine(carBuilder.buildEngine());
        car.setTyre(carBuilder.buildTyre());
        return car;
    }
}

package com.lby.builder;

public class Client {

    public static void main(String[] args) {

        //组装汽车子组件
        CarBuilder carBuilder = new CarBuilderImp();
        //创建汽车
        AssembleCar assembleCar = new AssembleCarImp(carBuilder);
        //生成最终的汽车
        Car car = assembleCar.assembleCar();

        car.run();

    }

}

3.结构

角色：

最终的汽车实体类
组成汽车子组件的实体类
构建子组件的类：实例化所有子组件
最终创建汽车类：将所有的子组件通过set方法添加到汽车的实体类

4.使用场景

创建对象的过程非常复杂，或者对象可以由不同的子组件组成，组成对象的过程比较复杂
StringBuilder类的append方法
SQL中的PreparedStatement

原型模式

1.定义
指定一个模板，通过拷贝这个模板创建新的对象

注意原型模式是从内存中复制数据，而不是通过构造方法的方式，所以原型模式和单例模式是冲突的
深拷贝只会拷贝8种基本数据类型和String类型，对其他的引用类型不会拷贝

2.代码

浅拷贝

package com.lby.prototype;

import java.io.Serializable;
import java.util.Date;


public class Sheep implements Cloneable,Serializable {
	private String sname;
	private Date birthday;
	
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Sheep sheep;
		sheep = (Sheep)super.clone();  //直接调用object对象的clone()方法！
		return sheep;
	}


	public String getSname() {
		return sname;
	}


	public void setSname(String sname) {
		this.sname = sname;
	}


	public Date getBirthday() {
		return birthday;
	}


	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}


	public Sheep(String sname, Date birthday) {
		super();
		this.sname = sname;
		this.birthday = birthday;
	}
	
	public Sheep() {
	}
	
}

深拷贝

package com.lby.prototype;

import java.util.Date;


//测试深复制
public class Sheep2 implements Cloneable {   
	private String sname;
	private Date birthday;


	@Override
	protected Object clone() throws CloneNotSupportedException {
		Sheep2 sheep2;
		sheep2 = (Sheep2)super.clone();  //直接调用object对象的clone()方法！
		//添加如下代码实现深复制(deep Clone)
		sheep2.birthday = (Date) this.birthday.clone();  //把属性也进行克隆！
		return sheep2;
	}


	public String getSname() {
		return sname;
	}


	public void setSname(String sname) {
		this.sname = sname;
	}


	public Date getBirthday() {
		return birthday;
	}


	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}


	public Sheep2(String sname, Date birthday) {
		super();
		this.sname = sname;
		this.birthday = birthday;
	}

	public Sheep2() {
	}

}

//测试客户端代码
package com.lby.prototype;

import java.util.Date;

/**
 * 浅复制
 */
public class Client3 {

    public static void main(String[] args) throws CloneNotSupportedException {
        //创建一个时间
        Date date = new Date(12312321331L);
        Sheep2 s1 = new Sheep2("单细胞",date);
        Sheep2 s2 = (Sheep2) s1.clone();
        /*Sheep s1 = new Sheep("单细胞",date);
        Sheep s2 = (Sheep) s1.clone();//克隆*/

        System.out.println("单细胞："+ s1.getSname() + "," + s1.getBirthday().getTime());
        System.out.println("克隆羊多利："+ s2.getSname() + "," + s2.getBirthday().getTime());
        System.out.println("###########只修改S1时间############");
        /**
         * 修改s1时间为23432432423L
         * (1)浅复制由于date引用有s1和s2共同指向同一个内存地址，所以修改s1时间之后导致s2的时间也被修改了
         * (2)深复制，由于s1和s2的date在内存中是两个对象，互不影响，所以修改s1的时间之后s2的时间还是克隆时的时间
         */
        date.setTime(23432432423L);
        s2.setSname("多利");//修改说s2sname属性

        System.out.println("修改单细胞S1："+ s1.getSname() + "," + s1.getBirthday().getTime());
        System.out.println("修改克隆羊时间S2："+ s2.getSname() + "," + s2.getBirthday().getTime());

    }

}

3.使用场景
需要创建大量的对象时使用，因为原型模式创建对象的效率比较高
通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式

结构型模式

适配器模式

1.定义
将一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作
需要三个角色：
（1）目标角色
（2）适配器角色
（3）源角色

2.代码

package com.lby.adapter;

/**
 * 被适配的类：u盘接口
 */
public interface Usb {

    void sendMessage();

}
class UsbImp implements Usb {

    @Override
    public void sendMessage() {
        System.out.println("发送usb存储信息");
    }
}

package com.lby.adapter;

/**
 * 适配器：OTG转接头
 */
public class OTG {

    private Usb usb;

    public OTG(Usb usb){
        this.usb = usb;
    }

    public void handleMessage(){
        usb.sendMessage();
        System.out.println("处理从usb获得的消息");
    }

}

package com.lby.adapter;

/**
 * 目标接口：手机
 */
public interface Mobile {

    void getMessage();

}
class MobileImp implements  Mobile{

    private OTG otg;

    public MobileImp(OTG otg){
        this.otg = otg;
    }

    @Override
    public void getMessage() {
        otg.handleMessage();
        System.out.println("通过OTG获取usb消息");
    }
}

package com.lby.adapter;

public class Client {

    public static void main(String[] args) {
        Usb usb = new UsbImp();
        OTG otg = new OTG(usb);
        Mobile m = new MobileImp(otg);
        m.getMessage();
    }

}

3.结构