设计模式（一）
什么是设计模式？
设计模式，在软件工程中是对软件设计过程中普遍存在的问题，所提出的解决方案。
设计模式分类
GoF设计模式一共23种，分为三大类：创建型模式、结构型模式、行为型模式。
常用的设计模式
1.工厂模式（Factory Pattern）
工厂模式是Java中最常用的设计模式之一。这种设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，创建对象时不会对客户暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
实例：
// 接口
public interface Shape { void draw(); }
// 实现类
public class Circle implements Shape{
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
// 实现类
public class Square implements Shape {
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
// 工厂类
public class ShapeFactory {
public Shape getShape(String shapeType){
if( "Square".equals(shapeType)){
return new Square();
}else if("Circle".equals(shapeType)){
return new Circle();
}else {
return null;
}
}
}
// Demo
public class FactoryPatternDemo {
public static void main(String[] args) {
ShapeFactory factory = new ShapeFactory();
Shape square = factory.getShape("Square");
Shape circle = factory.getShape("Circle");
square.draw();
circle.draw();
}
}
// 程序输出结果 Inside Square::draw() method. Inside Circle::draw() method.
2.抽象工厂模式（Abstract Factory Pattern）
抽象工厂模式是围绕一个超级工厂创建其他的工厂。该超级工厂又称为其他工厂的工厂。
这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显示指定他们的类，每个生成的工厂都能按照工厂模式提供对象。
实例：
// 接口
public interface Shape { void draw(); }
// 实现类
public class Circle implements Shape{
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
// 实现类
public class Square implements Shape {
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
public interface Color {
void fill();
}
public class Red implements Color {
public void fill() {
System.out.println("Inside Red::fill() method.");
}
}
public class Blue implements Color {
public void fill() {
System.out.println("Inside Blue::fill() method.");
}
}
public abstract class AbstractFactory {
public abstract Shape getShape(String shape) ;
public abstract Color getColor(String color) ;
}
public class ShapeFactory extends AbstractFactory{
public Shape getShape(String shapeType){
if( "Square".equals(shapeType)){
return new Square();
}else if("Circle".equals(shapeType)){
return new Circle();
}else {
return null;
}
}
public Color getColor(String color) {
return null;
}
}
public class ColorFactory extends AbstractFactory{
public Color getColor(String color){
if( "Red".equals(color)){
return new Red();
}else if("Blue".equals(color)){
return new Blue();
}else {
return null;
}
}
public Shape getShape(String shape) {
return null;
}
}
public class AbstractFactoryPatternDemo {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
ColorFactory colorFactory = new ColorFactory();
Shape square = shapeFactory.getShape("Square");
Shape circle = shapeFactory.getShape("Circle");
Color red = colorFactory.getColor("Red");
Color blue = colorFactory.getColor("Blue");
square.draw();
circle.draw();
red.fill();
blue.fill();
}
}
// 输出结果 Inside Square::draw() method. Inside Circle::draw() method. Inside Red::fill() method. Inside Blue::fill() method.
3.单例模式（Singleton Pattern）
单例模式是Java中最简单的设计模式之一。
这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
单例模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
注意：
单例类只能有一个实例
单例类必须自己创建自己的唯一实例
单例类必须给所有其他对象提供这一实例
实例：
public class SingleObject {
// 构造函数为私有的,该类就不会被实例化
private SingleObject(){};
// 自己创建自己的唯一实例
private static SingleObject singleObject = new SingleObject();
// 获取唯一可用的对象
public static SingleObject getSingleObject(){
return singleObject;
}
public void show(){
System.out.println("SingleObject.show()");
}
}
public class SingletonPatternDemo {
public static void main(String[] args) {
// 编译期报错
// SingleObject singleObject = new SingleObject();
SingleObject singleObject = SingleObject.getSingleObject();
singleObject.show();
}
}
// 代码执行结果 SingleObject.show()
懒汉式：
// 懒汉式单例
public class LazySingletonPattern {
// 私有的无参构造方法
private LazySingletonPattern(){}
// 默认不实例化，什么时候用什么时候实例化
private static LazySingletonPattern lazySingletonPattern = null;
// 获取唯一可用的对象
public static LazySingletonPattern getLazySingletonPattern(){
if(lazySingletonPattern == null){
lazySingletonPattern = new LazySingletonPattern();
}
return lazySingletonPattern;
}
}
饿汉式
// 饿汉式单例
public class HungrySingletonPattern {
// 无参构造方法私有化
private HungrySingletonPattern (){}
// 直接实例化
private static final HungrySingletonPattern hungrySingletonPattern = new HungrySingletonPattern();
// 获取唯一可用的对象
public static HungrySingletonPattern getHungrySingletonPattern(){
return hungrySingletonPattern;
}
}
4.建造者模式（Builder Pattern）
建造者模式，使用多个简单的对象一步一步构建成一个复杂的对象。
一个Builder类会一步一步构造最终的对象。该Builder类是独立于其他的对象。
5.原型模式（Prototype Pattern）
原型模式，用于创建重复的对象，又可以保证性能。
原型模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象代价比较大时，使用这种模式。
例如:一个对象需要在一个高代价的数据库操作之后创建。我们可以先缓存该对象，在下一个请求时返回他的克隆，在需要的时候更新数据库，以此来减少数据库的调用。
