Skip to content

D
datax-cloud
Commit a3ac3e3d by yuwei
Options

Java设计模式

parent b9ee30ea
Showing with 582 additions and 359 deletions
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/AbstractFactory.java deleted 100644 → 0
package cn.datax.learning.design.patterns.creational;
/**
* 抽象工厂模式（Abstract Factory Pattern）
* 提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。
*/
public class AbstractFactory {
public static void main(String[] args) {
AFactory bigerFactory = new BigerFactory();
AFactory smallerFactory = new SmallerFactory();
bigerFactory.produceHeadset().play();
bigerFactory.produceXiaomoPhone().run();
smallerFactory.produceXiaomoPhone().run();
smallerFactory.produceHeadset().play();
}
}
//抽象产品1
interface Headset {
void play();
}
//抽象产品2
interface XiaomiPhone {
void run();
}
//Headset具体产品*2
class EP21 implements Headset {
@Override
public void play() {
System.out.println("我是一副EP21");
}
}
class EP22 implements Headset {
@Override
public void play() {
System.out.println("我是一副EP22");
}
}
//XiaomiPhone具体产品*2
class MixPhone implements XiaomiPhone {
@Override
public void run() {
System.out.println("我是一台MIXPhone");
}
}
class MaxPhone implements XiaomiPhone {
@Override
public void run() {
System.out.println("我是一台MaxPhone");
}
}
//抽象工厂
interface AFactory {
Headset produceHeadset();
XiaomiPhone produceXiaomoPhone();
}
//Headset具体工厂*2
class SmallerFactory implements AFactory {
@Override
public Headset produceHeadset() {
return new EP21();
}
@Override
public XiaomiPhone produceXiaomoPhone() {
return new MixPhone();
}
}
class BigerFactory implements AFactory {
@Override
public Headset produceHeadset() {
return new EP22();
}
@Override
public XiaomiPhone produceXiaomoPhone() {
return new MaxPhone();
}
}
\ No newline at end of file
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/BuilderPattern.java deleted 100644 → 0
package cn.datax.learning.design.patterns.creational;
/**
* 建造者模式（Builder Pattern）
*/
public class BuilderPattern {
public static void main(String[] args) {
MyDate myDate = new MyDate();
IDateBuilder builder;
builder = new DateBuilder1(myDate);
String date1 = new Derector(builder).getDate(2066, 3, 6);
System.out.println(date1);
builder = new DateBuilder2(myDate);
String date2 = new Derector(builder).getDate(2067, 4, 6);
System.out.println(date2);
}
}
//首先定义一个产品类
class MyDate {
String Date;
}
//然后抽象生成器，描述生成器的行为
interface IDateBuilder {
IDateBuilder buildDate(int y, int m, int d);
String date();
}
//接下来是具体生成器，一个以“-”分割年月日，另一个使用空格：
class DateBuilder1 implements IDateBuilder {
private MyDate myDate;
public DateBuilder1(MyDate myDate) {
this.myDate = myDate;
}
@Override
public IDateBuilder buildDate(int y, int m, int d) {
myDate.Date = y + "-" + m + "-" + d;
return this;
}
@Override
public String date() {
return myDate.Date;
}
}
//具体生成器
class DateBuilder2 implements IDateBuilder {
private MyDate myDate;
public DateBuilder2(MyDate myDate) {
this.myDate = myDate;
}
@Override
public IDateBuilder buildDate(int y, int m, int d) {
myDate.Date = y + " " + m + " " + d;
return this;
}
@Override
public String date() {
return myDate.Date;
}
}
//接下来是指挥官，向用户提供具体的生成器：
class Derector {
private IDateBuilder builder;
public Derector(IDateBuilder builder) {
this.builder = builder;
}
public String getDate(int y, int m, int d) {
builder.buildDate(y, m, d);
return builder.date();
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/FactoryMethod.java deleted 100644 → 0
package cn.datax.learning.design.patterns.creational;
/**
* 工厂模式（Factory Pattern）
* 2.工厂方法模式
* 是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。
*/
public class FactoryMethod {
public static void main(String[] args) {
IFactory bigFactory = new BigFactory();
bigFactory.produce().run();
IFactory smallFactory = new SmallFactory();
smallFactory.produce().run();
}
}
//抽象产品类
interface HuweiPhone {
void run();
}
//具体产品类
class Mate5 implements HuweiPhone {
@Override
public void run() {
System.out.println("我是一台Mate5");
}
}
//具体产品类
class Mate6 implements HuweiPhone {
@Override
public void run() {
System.out.println("我是一台Mate6");
}
}
//抽象的工厂
interface IFactory {
HuweiPhone produce();
}
//工厂1
class BigFactory implements IFactory {
@Override
public HuweiPhone produce() {
return new Mate5();
}
}
//工厂2
class SmallFactory implements IFactory {
@Override
public HuweiPhone produce() {
return new Mate6();
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/SimpleFactory.java deleted 100644 → 0
package cn.datax.learning.design.patterns.creational;
/**
* 工厂模式（Factory Pattern）
* 1.简单工厂模式又称静态工厂方法模式
* 是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。
*/
public class SimpleFactory {
public static void main(String[] args) throws Exception {
Factory factory = new Factory();
factory.produce("PRO5").run();
factory.produce("PRO6").run();
}
}
//抽象产品类
interface MeizuPhone {
void run();
}
//具体产品类
class PRO5 implements MeizuPhone {
@Override
public void run() {
System.out.println("我是一台PRO5");
}
}
//具体产品类
class PRO6 implements MeizuPhone {
@Override
public void run() {
System.out.println("我是一台PRO6");
}
}
//创建工厂类
class Factory{
MeizuPhone produce(String produce) throws Exception {
if (produce.equals("PRO5")) {
return new PRO5();
} else if (produce.equals("PRO6")) {
return new PRO6();
}
throw new Exception("No Such Class");
}
}
\ No newline at end of file
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/SingletonPattern.java deleted 100644 → 0
package cn.datax.learning.design.patterns.creational;
/**
* 单例模式（Singleton Pattern）
*/
public class SingletonPattern {
private SingletonPattern() {}
/**
* 懒汉式加载
*/
private static SingletonPattern singleton;
//线程不安全，不用于多线程使用（不推荐）
public static SingletonPattern getInstance() {
if(singleton == null) {
singleton = new SingletonPattern();
}
return singleton;
}
//线程安全，同步方法（不推荐使用）
public static synchronized SingletonPattern getInstance2() {
if(singleton == null) {
singleton = new SingletonPattern();
}
return singleton;
}
//线程安全，同步代码块（不可用）
public static SingletonPattern getInstance3() {
if(singleton == null) {
synchronized(SingletonPattern.class) {
singleton = new SingletonPattern();
}
}
return singleton;
}
//线程安全，同步代码块，双重检查（推荐使用）
public static SingletonPattern getInstance4() {
if(singleton == null) {
synchronized(SingletonPattern.class) {
if(singleton == null) {
singleton = new SingletonPattern();
}
}
}
return singleton;
}
/**
* 饿汉式加载
*/
private static SingletonPattern singletonPattern = new SingletonPattern();
//静态常量（可用）
public static SingletonPattern getInstance5(){
return singletonPattern;
}
//静态代码块（可用）
static{
singletonPattern = new SingletonPattern();
}
public static SingletonPattern getInstance6(){
return singletonPattern;
}
//静态内部类（推荐用）
private static class SingletonPatternIntance {
private static final SingletonPattern INTANCE = new SingletonPattern();
}
public static SingletonPattern getInstance7(){
return SingletonPatternIntance.INTANCE;
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/builder/Builder.java 0 → 100644
package cn.datax.learning.design.patterns.creational.builder;
public abstract class Builder {
public abstract void setPart(String name, String type);
public abstract Product getProduct();
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/builder/BuilderPatternDemo.java 0 → 100644
package cn.datax.learning.design.patterns.creational.builder;
/**
* 建造者模式（Builder Pattern）
* 四个要素：
* 产品类：一般是一个较为复杂的对象，也就是说创建对象的过程比较复杂，一般会有比较多的代码量。在本类图中，产品类是一个具体的类，而非抽象类。实际编程中，产品类可以是由一个抽象类与它的不同实现组成，也可以是由多个抽象类与他们的实现组成。
* 抽象建造者：引入抽象建造者的目的，是为了将建造的具体过程交与它的子类来实现。这样更容易扩展。一般至少会有两个抽象方法，一个用来建造产品，一个是用来返回产品。
* 建造者：实现抽象类的所有未实现的方法，具体来说一般是两项任务：组建产品；返回组建好的产品。
* 导演类：负责调用适当的建造者来组建产品，导演类一般不与产品类发生依赖关系，与导演类直接交互的是建造者类。一般来说，导演类被用来封装程序中易变的部分。
*/
public class BuilderPatternDemo {
public static void main(String[] args){
Director director = new Director();
Product product1 = director.getAProduct();
product1.showProduct();
Product product2 = director.getBProduct();
product2.showProduct();
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/builder/ConcreteBuilder.java 0 → 100644
package cn.datax.learning.design.patterns.creational.builder;
public class ConcreteBuilder extends Builder {
private Product product = new Product();
@Override
public void setPart(String name, String type) {
product.setName(name);
product.setType(type);
}
@Override
public Product getProduct() {
return product;
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/builder/Director.java 0 → 100644
package cn.datax.learning.design.patterns.creational.builder;
public class Director {
private Builder builder = new ConcreteBuilder();
public Product getAProduct(){
builder.setPart("宝马汽车","X7");
return builder.getProduct();
}
public Product getBProduct(){
builder.setPart("奥迪汽车","Q5");
return builder.getProduct();
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/builder/Product.java 0 → 100644
package cn.datax.learning.design.patterns.creational.builder;
public class Product {
private String name;
private String type;
public void showProduct(){
System.out.println("名称：" + name);
System.out.println("型号：" + type);
}
public void setName(String name) {
this.name = name;
}
public void setType(String type) {
this.type = type;
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/Blue.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory;
public class Blue implements Color {
@Override
public void fill() {
System.out.println("Inside Blue::fill() method.");
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/Circle.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory;
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/Color.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory;
public interface Color {
void fill();
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/Green.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory;
public class Green implements Color {
@Override
public void fill() {
System.out.println("Inside Green::fill() method.");
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/Rectangle.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory;
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/Red.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory;
public class Red implements Color {
@Override
public void fill() {
System.out.println("Inside Red::fill() method.");
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/Shape.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory;
public interface Shape {
void draw();
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/Square.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory;
import cn.datax.learning.design.patterns.creational.factory.Shape;
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/abstractFactory/AbstractFactory.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory.abstractFactory;
import cn.datax.learning.design.patterns.creational.factory.Color;
import cn.datax.learning.design.patterns.creational.factory.Shape;
public abstract class AbstractFactory {
public abstract Color getColor(String color);
public abstract Shape getShape(String shape);
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/abstractFactory/AbstractFactoryPatternDemo.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory.abstractFactory;
import cn.datax.learning.design.patterns.creational.factory.Color;
import cn.datax.learning.design.patterns.creational.factory.Shape;
/**
* 抽象工厂模式（Abstract Factory Pattern）
*/
public class AbstractFactoryPatternDemo {
public static void main(String[] args) {
AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
Shape shape1 = shapeFactory.getShape("CIRCLE");
shape1.draw();
Shape shape2 = shapeFactory.getShape("RECTANGLE");
shape2.draw();
Shape shape3 = shapeFactory.getShape("SQUARE");
shape3.draw();
AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
Color color1 = colorFactory.getColor("RED");
color1.fill();
Color color2 = colorFactory.getColor("Green");
color2.fill();
Color color3 = colorFactory.getColor("BLUE");
color3.fill();
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/abstractFactory/ColorFactory.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory.abstractFactory;
import cn.datax.learning.design.patterns.creational.factory.*;
public class ColorFactory extends AbstractFactory {
@Override
Color getColor(String color) {
if (color == null){
return null;
}
if (color.equalsIgnoreCase("RED")) {
return new Red();
} else if (color.equalsIgnoreCase("GREEN")) {
return new Green();
} else if (color.equalsIgnoreCase("BLUE")) {
return new Blue();
}
return null;
}
@Override
Shape getShape(String shapeType) {
return null;
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/abstractFactory/FactoryProducer.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory.abstractFactory;
public class FactoryProducer {
public static AbstractFactory getFactory(String choice){
if(choice.equalsIgnoreCase("SHAPE")){
return new ShapeFactory();
}else if(choice.equalsIgnoreCase("COLOR")){
return new ColorFactory();
}
return null;
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/abstractFactory/ShapeFactory.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory.abstractFactory;
import cn.datax.learning.design.patterns.creational.factory.*;
public class ShapeFactory extends AbstractFactory {
@Override
Color getColor(String color) {
return null;
}
@Override
Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
}
if (shapeType.equalsIgnoreCase("CIRCLE")) {
return new Circle();
} else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
return new Rectangle();
} else if (shapeType.equalsIgnoreCase("SQUARE")) {
return new Square();
}
return null;
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/method/BlueFactory.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory.method;
import cn.datax.learning.design.patterns.creational.factory.Blue;
import cn.datax.learning.design.patterns.creational.factory.Color;
public class BlueFactory implements ColorFactory {
@Override
public Color getColor() {
return new Blue();
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/method/ColorFactory.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory.method;
import cn.datax.learning.design.patterns.creational.factory.Color;
public interface ColorFactory {
Color getColor();
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/method/FactoryMethodDemo.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory.method;
import cn.datax.learning.design.patterns.creational.factory.Color;
/**
* 工厂模式（Factory Pattern）
* 2.工厂方法模式
*/
public class FactoryMethodDemo {
public static void main(String[] args) {
ColorFactory colorFactory1 = new RedFactory();
Color color1 = colorFactory1.getColor();
color1.fill();
ColorFactory colorFactory2 = new GreenFactory();
Color color2 = colorFactory2.getColor();
color2.fill();
ColorFactory colorFactory3 = new BlueFactory();
Color color3 = colorFactory3.getColor();
color3.fill();
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/method/GreenFactory.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory.method;
import cn.datax.learning.design.patterns.creational.factory.Color;
import cn.datax.learning.design.patterns.creational.factory.Green;
public class GreenFactory implements ColorFactory {
@Override
public Color getColor() {
return new Green();
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/method/RedFactory.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory.method;
import cn.datax.learning.design.patterns.creational.factory.Color;
import cn.datax.learning.design.patterns.creational.factory.Red;
public class RedFactory implements ColorFactory {
@Override
public Color getColor() {
return new Red();
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/simple/ShapeFactory.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory.simple;
import cn.datax.learning.design.patterns.creational.factory.Circle;
import cn.datax.learning.design.patterns.creational.factory.Rectangle;
import cn.datax.learning.design.patterns.creational.factory.Shape;
import cn.datax.learning.design.patterns.creational.factory.Square;
public class ShapeFactory {
public Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
}
if (shapeType.equalsIgnoreCase("CIRCLE")) {
return new Circle();
} else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
return new Rectangle();
} else if (shapeType.equalsIgnoreCase("SQUARE")) {
return new Square();
}
return null;
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/factory/simple/SimpleFactoryDemo.java 0 → 100644
package cn.datax.learning.design.patterns.creational.factory.simple;
import cn.datax.learning.design.patterns.creational.factory.Shape;
/**
* 工厂模式（Factory Pattern）
* 1.简单工厂模式又称静态工厂模式
*/
public class SimpleFactoryDemo {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
Shape shape1 = shapeFactory.getShape("CIRCLE");
shape1.draw();
Shape shape2 = shapeFactory.getShape("RECTANGLE");
shape2.draw();
Shape shape3 = shapeFactory.getShape("SQUARE");
shape3.draw();
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/prototype/Circle.java 0 → 100644
package cn.datax.learning.design.patterns.creational.prototype;
public class Circle extends Shape {
public Circle() {
type = "Circle";
}
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/prototype/PrototypePatternDemo.java 0 → 100644
package cn.datax.learning.design.patterns.creational.prototype;
/**
* 原型模式（Prototype Pattern）
*/
public class PrototypePatternDemo {
public static void main(String[] args) {
ShapeCache.loadCache();
Shape clonedShape1 = ShapeCache.getShape("1");
System.out.println("Shape : " + clonedShape1.getType());
Shape clonedShape2 = ShapeCache.getShape("2");
System.out.println("Shape : " + clonedShape2.getType());
Shape clonedShape3 = ShapeCache.getShape("3");
System.out.println("Shape : " + clonedShape3.getType());
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/prototype/Rectangle.java 0 → 100644
package cn.datax.learning.design.patterns.creational.prototype;
public class Rectangle extends Shape {
public Rectangle() {
type = "Rectangle";
}
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/prototype/Shape.java 0 → 100644
package cn.datax.learning.design.patterns.creational.prototype;
public abstract class Shape implements Cloneable {
private String id;
protected String type;
abstract void draw();
public String getType() {
return type;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public Object clone() {
Object clone = null;
try {
clone = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return clone;
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/prototype/ShapeCache.java 0 → 100644
package cn.datax.learning.design.patterns.creational.prototype;
import java.util.concurrent.ConcurrentHashMap;
public class ShapeCache {
private static ConcurrentHashMap<String, Shape> shapeMap = new ConcurrentHashMap<>();
public static Shape getShape(String shapeId) {
Shape cachedShape = shapeMap.get(shapeId);
return (Shape) cachedShape.clone();
}
// 对每种形状都运行数据库查询，并创建该形状
// shapeMap.put(shapeKey, shape);
// 例如，我们要添加三种形状
public static void loadCache() {
Circle circle = new Circle();
circle.setId("1");
shapeMap.put(circle.getId(), circle);
Square square = new Square();
square.setId("2");
shapeMap.put(square.getId(), square);
Rectangle rectangle = new Rectangle();
rectangle.setId("3");
shapeMap.put(rectangle.getId(), rectangle);
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/prototype/Square.java 0 → 100644
package cn.datax.learning.design.patterns.creational.prototype;
public class Square extends Shape {
public Square() {
type = "Square";
}
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/singleton/SingleObject.java 0 → 100644
package cn.datax.learning.design.patterns.creational.singleton;
public class SingleObject {
private SingleObject() {}
/**
* 懒汉式加载
*/
private static SingleObject instance;
//线程不安全，不用于多线程使用（不推荐）
public static SingleObject getInstance1() {
if(instance == null) {
instance = new SingleObject();
}
return instance;
}
//线程安全，同步方法（不推荐使用）
public static synchronized SingleObject getInstance2() {
if(instance == null) {
instance = new SingleObject();
}
return instance;
}
//线程安全，同步代码块（不可用）
public static SingleObject getInstance3() {
if(instance == null) {
synchronized(SingleObject.class) {
instance = new SingleObject();
}
}
return instance;
}
//线程安全，同步代码块，双重检查（推荐使用）
private static volatile SingleObject instance2;
public static SingleObject getInstance4() {
if(instance2 == null) {
synchronized(SingleObject.class) {
if(instance2 == null) {
instance2 = new SingleObject();
}
}
}
return instance2;
}
/**
* 饿汉式加载
*/
private static SingleObject instance3 = new SingleObject();
//静态常量（可用）
public static SingleObject getInstance5(){
return instance3;
}
//静态代码块（可用）
private static SingleObject instance4;
static{
instance4 = new SingleObject();
}
public static SingleObject getInstance6(){
return instance4;
}
//静态内部类（推荐用）
private static class SingleObjectHolder {
private static final SingleObject INTANCE = new SingleObject();
}
public static SingleObject getInstance7(){
return SingleObject.SingleObjectHolder.INTANCE;
}
}
datax-learning/design-patterns/src/main/java/cn/datax/learning/design/patterns/creational/singleton/SingletonPatternDemo.java 0 → 100644
package cn.datax.learning.design.patterns.creational.singleton;
/**
* 单例模式（Singleton Pattern）
*/
public class SingletonPatternDemo {
public static void main(String[] args) {
SingleObject.getInstance1();
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment