单例模式
就是确保某一个类只有一个实例，并且提供一个全局访问点
//恶汉模式
public class Singleton {
private Singleton singleton = new Singleton();
private Singleton(){}
public Singleton getInstance(){
return singleton;
};
}
//懒汉模式
public class Singleton {
private Singleton singleton;
private Singleton(){}
public Singleton getInstance(){
if (singleton == null){
singleton = new Singleton();
}
return singleton;
};
}
//单例模式的双重校验锁
public class Singleton {
private volatile static Singleton singleton = null;
private Singleton(){}
public static Singleton getInstance(){
if (singleton == null){
synchronized(Singleton.class){
if (singleton == null){
singleton = new Singleton();
}
}
}
return singleton;
};
}
//静态内部类的单例模式
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton () {}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
原型模式
原型（Prototype）模式的定义如下：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。
spring中定义bean的作用域，默认是singleton ，prototype就是使用了原型模式。（另外还有request，session，globalSession）
深拷贝的使用方式有两种：1.重写clone方法。2.序列化之后再反序列化。
public class Wukong implements Cloneable{
public Wukong() {
System.out.println("create a wukong");
}
@Override
protected Wukong clone() throws CloneNotSupportedException {
System.out.println("clone a wukong");
return (Wukong)super.clone();
}
public static void main(String[] args) throws CloneNotSupportedException {
Wukong wukong1 = new Wukong();
Wukong wukong2 = wukong1.clone();
System.out.println(wukong1);
System.out.println(wukong2);
System.out.println(wukong1 == wukong2);
}
}
Connected to the target VM, address: '127.0.0.1:38656', transport: 'socket'
create a wukong
clone a wukong
com.ch.prototype.Wukong@66048bfd
com.ch.prototype.Wukong@61443d8f
false
Disconnected from the target VM, address: '127.0.0.1:38656', transport: 'socket'
Process finished with exit code 0
工厂方法模式
定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中
工厂方法.gif
//Shape接口
public interface Shape {
void draw();
}
//Circle实现类
public class Circle implements Shape{
public void draw() {
System.out.println("circle draw ...");
}
}
//Shape工厂类
public class ShapeFactory {
public Shape getShape(String shapeType){
if ("circle".equals(shapeType)){
return new Circle();
}
return null;
}
}
Main方法及运行结果：
public static void main(String[] args) {
ShapeFactory factory = new ShapeFactory();
Circle circle = (Circle) factory.getShape("circle");
circle.draw();
}
circle draw ...
抽象工厂模式
是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
//Shape接口
public interface Shape {
void draw();
}
//Circle实现类
public class Circle implements Shape{
public void draw() {
System.out.println("circle draw ...");
}
}
//抽象工厂类
public abstract class AbstractFactory {
public abstract Shape getShape(String shapeType);
}
//Shape工厂类
public class ShapeFactory extends AbstractFactory{
public Shape getShape(String shapeType) {
if ("circle".equals(shapeType)){
return new Circle();
}
return null;
}
}
//工厂创建者
public class FactoryProducer {
public static AbstractFactory getFactory(String choice){
if ("shape".equals(choice)) {
return new ShapeFactory();
}
return null;
}
}
Main方法及运行结果：
public static void main(String[] args) {
AbstractFactory factory = FactoryProducer.getFactory("shape");
Circle circle = (Circle) factory.getShape("circle");
circle.draw();
}
circle draw ...
建造者模式
指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示
建造者模式.gif
//产品类
public class Product {
private String partA;
private String partB;
public void setPartA(String partA) {
this.partA = partA;
}
public void setPartB(String partB) {
this.partB = partB;
}
@Override
public String toString() {
return "Product{" +
"partA='" + partA + '\'' +
", partB='" + partB + '\'' +
'}';
}
}
//抽象建造者
public abstract class Builder {
protected Product product = new Product();
public abstract void partA();
public abstract void partB();
public Product getProduct() {
return product;
}
}
//具体建造者1
public class Builder1 extends Builder{
public void partA() {
product.setPartA("set part A");
}
public void partB() {
product.setPartB("set part B");
}
}
//指挥者
public class Director {
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
public Product construct() {
builder.partA();
builder.partB();
return builder.getProduct();
}
}
主类及运行结果：
public static void main(String[] args) {
Builder builder = new Builder1();
Director director = new Director(builder);
Product product = director.construct();
System.out.println(product.toString());
}
Product{partA='set part A', partB='set part B'}
