随笔- 6 文章- 0 评论- 0 阅读- 2853

设计模式（一）

什么是设计模式？

设计模式，在软件工程中是对软件设计过程中普遍存在的问题，所提出的解决方案。

设计模式分类

GoF设计模式一共23种，分为三大类：创建型模式、结构型模式、行为型模式。

常用的设计模式

1.工厂模式（Factory Pattern）

工厂模式是Java中最常用的设计模式之一。这种设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，创建对象时不会对客户暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

实例：

// 接口<br>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) {<br>
        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）

抽象工厂模式是围绕一个超级工厂创建其他的工厂。该超级工厂又称为其他工厂的工厂。

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

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

实例：

// 接口<br>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();
    }
}

1 2	`// 代码执行结果` `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 (){}
    <br>　　// 直接实例化
    private static final HungrySingletonPattern hungrySingletonPattern = new HungrySingletonPattern();
    <br>　　// 获取唯一可用的对象
    public static HungrySingletonPattern getHungrySingletonPattern(){
        return hungrySingletonPattern;
    }
}