单例模式 #

描述 #

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供了一个全局访问点来访问该实例。
UML #

代码实现 #

public class Main {
 public static void main(String[] args) {
 //获取唯一可用的对象
 SingleObject object = SingleObject.getInstance();
 //显示消息
 object.showMessage();
 }
}

public class Singleton { 
 private Singleton (){}
 private static Singleton instance; 
 public static /*synchronized*/ Singleton getInstance() { 
 if (instance == null) { 
 instance = new Singleton(); 
 } 
 return instance; 
 } 
}

public class Singleton { 
 private Singleton (){}
 private static Singleton instance = new Singleton();
 public static Singleton getInstance() {
 return instance;
 }
}

public class Singleton { 
 private Singleton (){}
 private volatile static Singleton singleton; 
 public static Singleton getSingleton() { 
 if (singleton == null) { 
 synchronized (Singleton.class) { 
 if (singleton == null) { 
 singleton = new Singleton(); 
 } 
 } 
 } 
 return singleton; 
 }
}

public class Singleton { 
 private Singleton (){}
 private static class SingletonHolder { 
 private static final Singleton INSTANCE = new Singleton(); 
 } 
 public static final Singleton getInstance() { 
 return SingletonHolder.INSTANCE; 
 } 
}

public enum Singleton { 
 INSTANCE; 
 public void whateverMethod() { 
 } 
}

Reference #
- https://www.runoob.com/design-pattern/singleton-pattern.html

Mon, 01 Jan 0001 00:00:00 +0000

工厂模式 #

描述 #

工厂模式提供了一种创建对象的方式，而无需指定要创建的具体类。

工厂模式属于创建型模式，它在创建对象时提供了一种封装机制，将实际创建对象的代码与使用代码分离。
UML #

代码实现 #

public class Main {
 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();
 }
}

public class ShapeFactory {

 //使用 getShape 方法获取形状类型的对象
 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;
 }
}

public interface Shape {
 void draw();
}

public class Circle implements Shape {
 @Override
 public void draw() {
 System.out.println("Inside Circle::draw() method.");
 }
}

public class Rectangle implements Shape {
 @Override
 public void draw() {
 System.out.println("Inside Rectangle::draw() method.");
 }
}

public class Square implements Shape {
 @Override
 public void draw() {
 System.out.println("Inside Square::draw() method.");
}

Mon, 01 Jan 0001 00:00:00 +0000

抽象工厂模式 #

描述 #

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口，而无需指定具体实现类。通过使用抽象工厂模式，可以将客户端与具体产品的创建过程解耦，使得客户端可以通过工厂接口来创建一族产品。
UML #

代码实现 #

public class Main {
 public static void main(String[] args) {
 //获取形状工厂
 AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");

 // 会出现NPE
 // Color color = shapeFactory.getColor("everything");
 Shape shape1 = shapeFactory.getShape("CIRCLE");
 shape1.draw();

 //获取颜色工厂
 AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");

 Color color1 = colorFactory.getColor("RED");
 color1.fill();
 }
}

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;
 }
}

public abstract class AbstractFactory {

 public abstract Color getColor(String color);

 public abstract Shape getShape(String shape);

}

public class ShapeFactory extends AbstractFactory {

 //使用 getShape 方法获取形状类型的对象
 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;
 }

 @Override
 public Color getColor(String color) {
 return null;
 }
}

public interface Shape {
 void draw();
}

public class Circle implements Shape {
 @Override
 public void draw() {
 System.out.println("Inside Circle::draw() method.");
 }
}

public class Rectangle implements Shape {
 @Override
 public void draw() {
 System.out.println("Inside Rectangle::draw() method.");
 }
}

public class Square implements Shape {
 @Override
 public void draw() {
 System.out.println("Inside Square::draw() method.");
}

public class ColorFactory extends AbstractFactory {
 @Override
 public Shape getShape(String shapeType){
 return null;
 }

 @Override
 public 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;
 }
}

public interface Color {
 void fill();
}

public class Blue implements Color {
 @Override
 public void fill() {
 System.out.println("Inside Blue::fill() method.");
 }
}

public class Green implements Color {
 @Override
 public void fill() {
 System.out.println("Inside Green::fill() method.");
 }
}

public class Red implements Color {
 @Override
 public void fill() {
 System.out.println("Inside Red::fill() method.");
 }
}

Mon, 01 Jan 0001 00:00:00 +0000

适配器模式 #

描述 #

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。

这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡。

我们通过下面的实例来演示适配器模式的使用。其中，音频播放器设备只能播放 mp3 文件，通过使用一个更高级的音频播放器来播放 vlc 和 mp4 文件。
UML #

代码实现 #

public class Main {
 public static void main(String[] args) {

 AudioPlayer audioPlayer = new AudioPlayer();

 audioPlayer.play("mp3", "beyond the horizon.mp3");
 audioPlayer.play("mp4", "alone.mp4");
 audioPlayer.play("vlc", "far far away.vlc");
 audioPlayer.play("avi", "mind me.avi");
 }
}

public class AudioPlayer implements MediaPlayer {
 MediaAdapter mediaAdapter;

 @Override
 public void play(String audioType, String fileName) {

 //播放 mp3 音乐文件的内置支持
 if(audioType.equalsIgnoreCase("mp3")){
 System.out.println("Playing mp3 file. Name: "+ fileName);
 }
 //mediaAdapter 提供了播放其他文件格式的支持
 else if(audioType.equalsIgnoreCase("vlc")
 || audioType.equalsIgnoreCase("mp4")){
 mediaAdapter = new MediaAdapter(audioType);
 mediaAdapter.play(audioType, fileName);
 }
 else{
 System.out.println("Invalid media. "+
 audioType + " format not supported");
 }
 }
}

public interface MediaPlayer {
 public void play(String audioType, String fileName);
}

public class MediaAdapter implements MediaPlayer {

 AdvancedMediaPlayer advancedMusicPlayer;

 public MediaAdapter(String audioType){
 if(audioType.equalsIgnoreCase("vlc") ){
 advancedMusicPlayer = new VlcPlayer();
 } else if (audioType.equalsIgnoreCase("mp4")){
 advancedMusicPlayer = new Mp4Player();
 }
 }

 @Override
 public void play(String audioType, String fileName) {
 if(audioType.equalsIgnoreCase("vlc")){
 advancedMusicPlayer.playVlc(fileName);
 }else if(audioType.equalsIgnoreCase("mp4")){
 advancedMusicPlayer.playMp4(fileName);
 }
 }
}

public class Mp4Player implements AdvancedMediaPlayer{

 @Override
 public void playVlc(String fileName) {
 //什么也不做
 }

 @Override
 public void playMp4(String fileName) {
 System.out.println("Playing mp4 file. Name: "+ fileName);
 }
}

public class VlcPlayer implements AdvancedMediaPlayer{
 @Override
 public void playVlc(String fileName) {
 System.out.println("Playing vlc file. Name: "+ fileName);
 }

 @Override
 public void playMp4(String fileName) {
 //什么也不做
 }
}

public interface AdvancedMediaPlayer {
 public void playVlc(String fileName);
 public void playMp4(String fileName);
}

Mon, 01 Jan 0001 00:00:00 +0000

责任链模式 #

描述 #

顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

我们创建抽象类 AbstractLogger，带有详细的日志记录级别。然后我们创建三种类型的记录器，都扩展了 AbstractLogger。每个记录器消息的级别是否属于自己的级别，如果是则相应地打印出来，否则将不打印并把消息传给下一个记录器。
UML #

代码实现 #

public class Main {
 private static AbstractLogger getChainOfLoggers(){

 AbstractLogger debugLogger = new DebugLogger(AbstractLogger.DEBUG);
 AbstractLogger infoLogger = new InfoLogger(AbstractLogger.INFO);
 AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);

 debugLogger.setNextLogger(infoLogger);
 infoLogger.setNextLogger(errorLogger);

 return debugLogger;
 }

 public static void main(String[] args) {
 AbstractLogger loggerChain = getChainOfLoggers();

 loggerChain.logMessage(AbstractLogger.DEBUG, "This is a debug level information.");

 loggerChain.logMessage(AbstractLogger.INFO, "This is an info level information.");

 loggerChain.logMessage(AbstractLogger.ERROR, "This is an error level information.");
 }
}

public abstract class AbstractLogger {
 public static int DEBUG = 1;
 public static int INFO = 2;
 public static int ERROR = 3;

 protected int level;

 //责任链中的下一个元素
 protected AbstractLogger nextLogger;

 public void setNextLogger(AbstractLogger nextLogger){
 this.nextLogger = nextLogger;
 }

 public void logMessage(int level, String message){
 if(this.level >= level){
 write(message);
 }
 if(nextLogger != null){
 nextLogger.logMessage(level, message);
 }else{ System.out.println();}
 }

 abstract protected void write(String message);
}

public class DebugLogger extends AbstractLogger {

 public DebugLogger(int level){
 this.level = level;
 }

 @Override
 protected void write(String message) {
 System.out.println("Debug::Logger: " + message);
 }
}

public class InfoLogger extends AbstractLogger {

 public InfoLogger(int level){
 this.level = level;
 }

 @Override
 protected void write(String message) {
 System.out.println("Info::Logger: " + message);
 }
}

public class ErrorLogger extends AbstractLogger {

 public ErrorLogger(int level){
 this.level = level;
 }

 @Override
 protected void write(String message) {
 System.out.println("Error::Logger: " + message);
 }
}

Mon, 01 Jan 0001 00:00:00 +0000

策略模式 #

描述 #

在策略模式（Strategy Pattern）中一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

在策略模式定义了一系列算法或策略，并将每个算法封装在独立的类中，使得它们可以互相替换。通过使用策略模式，可以在运行时根据需要选择不同的算法，而不需要修改客户端代码。

在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

我们将创建一个定义活动的 Strategy 接口和实现了 Strategy 接口的实体策略类。Context 是一个使用了某种策略的类。StrategyPatternDemo，我们的演示类使用 Context 和策略对象来演示 Context 在它所配置或使用的策略改变时的行为变化。
UML #

代码实现 #

public class Main {

 public static void main(String[] args) {

 Context context = new Context(new OperationAdd());
 System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

 context = new Context(new OperationSubtract());
 System.out.println("10 - 5 = " + context.executeStrategy(10, 5));

 context = new Context(new OperationMultiply());
 System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
 }
}

public class Context {
 private Strategy strategy;

 public Context(Strategy strategy){
 this.strategy = strategy;
 }

 public int executeStrategy(int num1, int num2){
 return strategy.doOperation(num1, num2);
 }
}

public interface Strategy {
 public int doOperation(int num1, int num2);
}

public class OperationAdd implements Strategy{
 @Override
 public int doOperation(int num1, int num2) {
 return num1 + num2;
 }
}

public class OperationSubtract implements Strategy{
 @Override
 public int doOperation(int num1, int num2) {
 return num1 - num2;
 }
}

public class OperationMultiply implements Strategy{
 @Override
 public int doOperation(int num1, int num2) {
 return num1 * num2;
 }
}

Mon, 01 Jan 0001 00:00:00 +0000

模板模式 #

描述 #

在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。
UML #

代码实现 #

public class Main {
 public static void main(String[] args) {

 Game game = new Cricket();
 game.play();

 game = new Football();
 game.play();
 }
}

public abstract class Game {
 abstract void initialize();
 abstract void startPlay();
 abstract void endPlay();
 //模板
 public final void play(){
 //初始化游戏
 initialize();
 //开始游戏
 startPlay();
 //结束游戏
 endPlay();
 }
}

public class Cricket extends Game {

 @Override
 void endPlay() {
 System.out.println("Cricket Game Finished!");
 }

 @Override
 void initialize() {
 System.out.println("Cricket Game Initialized! Start playing.");
 }

 @Override
 void startPlay() {
 System.out.println("Cricket Game Started. Enjoy the game!");
 }
}

public class Football extends Game {

 @Override
 void endPlay() {
 System.out.println("Football Game Finished!");
 }

 @Override
 void initialize() {
 System.out.println("Football Game Initialized! Start playing.");
 }

 @Override
 void startPlay() {
 System.out.println("Football Game Started. Enjoy the game!");
 }
}

Mon, 01 Jan 0001 00:00:00 +0000

访问者模式 #

描述 #

在访问者模式（Visitor Pattern）中，我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。

访问模式可以有变形，比如有些写法中被访问的是抽象类，而另外的是接口实现。

ASM里面就用到了访问者模式来处理字节码信息。
UML #

代码实现 #

public class Main {
 public static void main(String[] args) {

 List<Staff> staffs = new ArrayList<>();
 staffs.add(new Manager("经理-A"));
 staffs.add(new Manager("经理-B"));
 staffs.add(new Engineer("工程师-A"));
 staffs.add(new Engineer("工程师-B"));
 staffs.add(new Engineer("工程师-C"));
 staffs.add(new Engineer("工程师-D"));

 CEOVisitor ceoVisitor = new CEOVisitor();
 for (Staff staff : staffs) {
 staff.accept(ceoVisitor);
 }

 System.out.println();

 CTOVisitor ctoVisitor = new CTOVisitor();
 for (Staff staff : staffs) {
 staff.accept(ctoVisitor);
 }
 }
}

active(访问) #

public interface Visitor {
 void visit(Engineer engineer);
 void visit(Manager manager);
}

public class CEOVisitor implements Visitor {

 @Override
 public void visit(Engineer engineer) {
 System.out.println("CEO -visit-> 工程师: " + engineer.name + ", KPI: " + engineer.kpi);
 }

 @Override
 public void visit(Manager manager) {
 System.out.println("CEO -visit-> 经理: " + manager.name + ", KPI: " + manager.kpi +
 ", 新产品数量: " + manager.getProducts());
 }
}

public class CTOVisitor implements Visitor {

 @Override
 public void visit(Engineer engineer) {
 System.out.println("CTO -visit-> 工程师: " + engineer.name + ", 代码行数: " + engineer.getCodeLines());
 }

 @Override
 public void visit(Manager manager) {
 System.out.println("CTO -visit-> 经理: " + manager.name + ", 产品数量: " + manager.getProducts());
 }
}

passive(被访问) #

public abstract class Staff {

 public String name;
 public int kpi;// 员工KPI

 public Staff(String name) {
 this.name = name;
 kpi = new Random().nextInt(10);
 }
 // 核心方法，接受Visitor的访问
 public abstract void accept(Visitor visitor);
}

public class Engineer extends Staff {

 public Engineer(String name) {
 super(name);
 }

 @Override
 public void accept(Visitor visitor) {
 visitor.visit(this);
 }
 // 工程师一年的代码数量
 public int getCodeLines() {
 return new Random().nextInt(10 * 10000);
 }
}

public class Manager extends Staff {

 public Manager(String name) {
 super(name);
 }

 @Override
 public void accept(Visitor visitor) {
 visitor.visit(this);
 }

 // 一年做的产品数量
 public int getProducts() {
 return new Random().nextInt(10);
 }
}

archive

单例模式 #

描述 #

UML #

代码实现 #

Reference #

工厂模式 #

描述 #

UML #

代码实现 #

抽象工厂模式 #

描述 #

UML #

代码实现 #

适配器模式 #

描述 #

UML #

代码实现 #

责任链模式 #

描述 #

UML #

代码实现 #

策略模式 #

描述 #

UML #

代码实现 #

模板模式 #

描述 #

UML #

代码实现 #

访问者模式 #

描述 #

UML #

代码实现 #

active(访问) #

passive(被访问) #