工厂模式

工厂模式 Factory Pattern

适用的场景：统一的接口作为统一的零件，实现类作为零件的组合，将实例产品类的生产交给工厂，用户只需要面对工程提取指定的产品。

比如：客户需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现

思想创建的过程在子类中实现

具体实现，创建一个接口，创建多个接口的实现类，重写实现对应的方法，创建一个工厂类，工厂类中实现方法传入类型生产对应的接口实现类，返回接口，编写测试方法，new一个工厂传入多个类型就可以生产对应的产品了。

class CarFactory{
    public Production getProduction(String type){
        if (type == null) return null;
        if (type.equalsIgnoreCase("BaoMa")){
            return new BaoMa();
        } else if (type.equalsIgnoreCase("BiYaDi")) {
            return new BiYaDi();
        } else if (type.equalsIgnoreCase("AoDi")) {
            return new AoDi();
        }
        return null;
    }
}

class BaoMa implements Production{

    @Override
    public void production() {
        System.out.println("宝马车工厂生产中......");
    }
}

class BiYaDi implements Production{

    @Override
    public void production() {
        System.out.println("比亚迪车工厂生产中......");
    }
}

class AoDi implements Production{

    @Override
    public void production() {
        System.out.println("奥迪车工厂生产中......");
    }
}

interface Production{
    void production();
}

测试方法

    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        carFactory.getProduction("baoma").production();
        carFactory.getProduction("aodi").production();
        carFactory.getProduction("biyadi").production();
    }

单例模式

单例模式 Singleton Pattern

适用的场景，保证一个类仅有一个实例，并提供一个访问它的全局访问点。

例如，一个班级只有一个班主任，window对同一个文件的处理，设备处理器，打印机

具体实现，一个类有且具有一个实例，并且构造器私有，分为饿汉式单例和懒汉式单例

饿汉式单例

在类初始化的时就实例化对象，因此它是线程安全的，存在的问题就是使用不当，会造成空间资源的浪费

class Hungry{
    
    private final static Hungry hungry = new Hungry();

    private Hungry() {}

    public static Hungry getHungry() {
        return hungry;
    }

    public void hello(){
        System.out.println("饿汉式单例的hello()");
    }
}

存在问题，如果在Hungry的代码中加入一下代码，那么在类初始化时候，占用了这些空间，但是没有使用，就造成空间资源的浪费。

    byte[] a = new byte[1024*1024];
    byte[] b = new byte[1024*1024];
    byte[] c = new byte[1024*1024];

测试方法，仅能通过类在最开始私有进行实例化对象进行操作方法

    public static void main(String[] args) {
        // 仅仅能通过私有构造器进行对象的初始化工作，并且在最开始就进行了对象的初始化
        Hungry hungry = Hungry.getHungry();
        hungry.hello();
    }

懒汉式单例

不安全的基本的懒汉式单例，在get实例方法时候加入判空操作

class LazyMan{
    private static LazyMan lazyMan;

    private LazyMan() {}

    public static LazyMan getLazyMan() {
        if (lazyMan == null){
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }

    public void hello(){
        System.out.println("饿汉式单例的hello()");
    }
}

测试方法

    public static void main(String[] args) {
        LazyMan lazyMan = LazyMan.getLazyMan();
        lazyMan.hello();
    }

存在问题懒汉单例，当程序启动之后并不会进行初始化，在什么时候调用什么时候初始化。单线程下没有问题，但是在多线程下，由于没有加锁，所以会存在访问问题。

思考什么情况会导致线程不安全

• 线程的调度是抢占式执行
• 修改操作不是原子的
• 多个线程同时修改同一个变量
• 内存可见性
• 指令重排序

在并发访问的时候，线程实并发来访问这个懒汉式单例的，多个线程访问的结果不一致

加锁保证懒汉式单例的安全，直接在方法上进行加锁，但是锁的粒度过大，相对比较笨重

    public static synchronized LazyMan getLazyMan() {
        if (lazyMan == null){
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }

DCL优化加锁，在方法上双重检查锁，加入voliate关键字，作用是内存可见性，禁止指令重排序

class LazyMan{
    private volatile static LazyMan lazyMan;

    private LazyMan() {}

    public static LazyMan getLazyMan() {
        if (lazyMan == null){
            synchronized (LazyMan.class){
                if (lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }

    public void hello(){
        System.out.println("饿汉式单例的hello()");
    }
}

抽象工厂

抽象工厂 abstract Factory

使用场景，一个超级工厂去创建其他的小工厂，主要解决接口选择的问题。

例如，QQ 换皮肤，一整套一起换。 生成不同操作系统的程序。

具体实现

定义具体实现的两个接口，包含了各自的方法

interface Shape{
    public void draw();
}

interface Color{
    public void fill();
}

接口实现类，具体实现接口方法

class Rectangle implements Shape{
    @Override
    public void draw() {
        System.out.println("画出一个长方形");
    }
}

class Trangle implements Shape{
    @Override
    public void draw() {
        System.out.println("画出一个三角形");
    }
}

class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("画出一个圆形");
    }
}

class Red implements Color{
    @Override
    public void fill() {
        System.out.println("该图形填充了Red");
    }
}

class Blue implements Color{
    @Override
    public void fill() {
        System.out.println("该图形填充了Blue");
    }
}

class Green implements Color{
    @Override
    public void fill() {
        System.out.println("该图形填充了Green");
    }
}

定义抽象工厂类，每一个具体的工厂类继承这个抽象工厂类，在这个具体的工厂类中实现对应的零件

abstract class AbstractFactory{
    public abstract Shape getShape(String shape);
    public abstract Color getColor(String color);
}

class ShapeFactory extends AbstractFactory{

    @Override
    public Shape getShape(String shape) {
        if (shape == null) return null;
        if (shape.equalsIgnoreCase("Rectangle")){
            return new Rectangle();
        } else if (shape.equalsIgnoreCase("Trangle")) {
            return new Trangle();
        } else if (shape.equalsIgnoreCase("Circle")) {
            return new Circle();
        }
        return null;
    }

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

class ColorFactory extends AbstractFactory{

    @Override
    public Shape getShape(String shape) {
        return null;
    }

    @Override
    public Color getColor(String color) {
        if (color == null) return null;
        if (color.equalsIgnoreCase("Red")){
            return new Red();
        } else if (color.equalsIgnoreCase("Blue")) {
            return new Blue();
        } else if (color.equalsIgnoreCase("Green")) {
            return new Green();
        }
        return null;
    }
}

由于这个抽象工厂没有实例，所以需要一个工厂处理器，来处理抽象工厂，让其返回用户需要

class FactoryProducer{
    public AbstractFactory getFactory(String factory){
        if (factory == null) return null;
        if (factory.equalsIgnoreCase("ShapeFactory")){
            return new ShapeFactory();
        } else if (factory.equalsIgnoreCase("ColorFactory")) {
            return new ColorFactory();
        }
        return null;
    }
}

测试方法，工厂处理器通过抽象的超级工厂获取工厂的类型，通过指定的工厂就可以对指定的工具类进行操作

    public static void main(String[] args) {
        FactoryProducer factoryProducer = new FactoryProducer();
        AbstractFactory shapeFactory = factoryProducer.getFactory("ShapeFactory");
        shapeFactory.getShape("Rectangle").draw();
        shapeFactory.getShape("Trangle").draw();
        shapeFactory.getShape("Circle").draw();

        AbstractFactory colorFactory = factoryProducer.getFactory("ColorFactory");
        colorFactory.getColor("Red").fill();
        colorFactory.getColor("Blue").fill();
        colorFactory.getColor("Green").fill();
    }

建造者模式

建造者模式 Builder Pattern

使用多个简单的对象一步一步构建成一个复杂的对象，建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

应用，去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。JAVA 中的 StringBuilder。

厂模式的区别是：建造者模式更加关注与零件装配的顺序。

具体实现

创建接口，套餐项的接口，包装接口

// 套餐项，喝的，吃的
interface Item{
    public String name();
    public Packing packing();
    public float price();
}
// 包装：纸质包装，瓶装
interface Packing{
    public String pack();
}

包装接口的实现类，纸质包装和瓶装

class Wrapper implements Packing {

    @Override
    public String pack() {
        return "Wrapper";
    }
}

class Bottle implements Packing {

    @Override
    public String pack() {
        return "Bottle";
    }
}

抽象类封装基本的套餐项，饮料采用瓶子装，汉堡采用纸质装

// 创建实现 Item 接口的抽象类，该类提供了默认的功能。基本的汉堡，饮料的种类
abstract class ColdDrink implements Item {

    @Override
    public Packing packing() {
        return new Bottle();
    }

    @Override
    public abstract float price();
}

abstract class Burger implements Item {

    @Override
    public Packing packing() {
        return new Wrapper();
    }

    @Override
    public abstract float price();
}

创建扩展了 Burger 和 ColdDrink 的实体类。在汉堡上再封装成为蔬菜汉堡，鸡肉汉堡等，在喝的项目上封装可乐等饮料

class VegBurger extends Burger {

    @Override
    public float price() {
        return 25.0f;
    }

    @Override
    public String name() {
        return "Veg Burger";
    }
}
class ChickenBurger extends Burger {

    @Override
    public float price() {
        return 50.5f;
    }

    @Override
    public String name() {
        return "Chicken Burger";
    }
}

class Coke extends ColdDrink {

    @Override
    public float price() {
        return 30.0f;
    }

    @Override
    public String name() {
        return "Coke";
    }
}
class Pepsi extends ColdDrink {

    @Override
    public float price() {
        return 35.0f;
    }

    @Override
    public String name() {
        return "Pepsi";
    }
}

将item存入集合，并且计算套餐的价值及其一系列附加属性

class Meal {
    private List<Item> items = new ArrayList<Item>();

    public void addItem(Item item){
        items.add(item);
    }

    public float getCost(){
        float cost = 0.0f;
        for (Item item : items) {
            cost += item.price();
        }
        return cost;
    }

    public void showItems(){
        for (Item item : items) {
            System.out.print("Item : "+item.name());
            System.out.print(", Packing : "+item.packing().pack());
            System.out.println(", Price : "+item.price());
        }
    }
}

Builder类，负责准备两种不同的套餐，有蔬菜的套餐和没有蔬菜的套餐

class MealBuilder {

    public Meal prepareVegMeal (){
        Meal meal = new Meal();
        meal.addItem(new VegBurger());
        meal.addItem(new Coke());
        return meal;
    }

    public Meal prepareNonVegMeal (){
        Meal meal = new Meal();
        meal.addItem(new ChickenBurger());
        meal.addItem(new Pepsi());
        return meal;
    }
}

测试方法

    public static void main(String[] args) {
        MealBuilder mealBuilder = new MealBuilder();

        Meal vegMeal = mealBuilder.prepareVegMeal();
        System.out.println("Veg Meal");
        vegMeal.showItems();
        System.out.println("Total Cost: " +vegMeal.getCost());

        Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
        System.out.println("\n\nNon-Veg Meal");
        nonVegMeal.showItems();
        System.out.println("Total Cost: " +nonVegMeal.getCost());
    }

原型模式

利用已有的一个原型对象，快速地生成和原型对象一样的实例。通常用于克隆，可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

优点 性能提高。 逃避构造函数的约束。

应用 细胞分裂。JAVA 中的 Object clone() 方法。

具体实现

定义一个含有抽象方法的抽象类，实现克隆的接口

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

给抽象类进行扩展

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

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

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

Shape 的缓存类，负责先一步加载缓存

class ShapeCache {

    private static Hashtable<String, Shape> shapeMap
            = new Hashtable<String, Shape>();

    public static Shape getShape(String shapeId) {
        Shape cachedShape = shapeMap.get(shapeId);
        return (Shape) cachedShape.clone();
    }
    
    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);
    }
}

测试方法

public static void main(String[] args) {
      ShapeCache.loadCache();
 
      Shape clonedShape = (Shape) ShapeCache.getShape("1");
      System.out.println("Shape : " + clonedShape.getType());        
 
      Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
      System.out.println("Shape : " + clonedShape2.getType());        
 
      Shape clonedShape3 = (Shape) ShapeCache.getShape("3");
      System.out.println("Shape : " + clonedShape3.getType());        
   }

UML图形的绘制

interface 和 class之间的关系与对象与对象之间的关系

泛化关系也就是继承关系

-表示 private

+ 表示 public

#表示protected

不带符号代表 default

UML表示具体类

UML 表示抽象类，抽象类的类名以及抽象方法的名字都用斜体字表示

接口

或者（棒棒糖表示法）

UML 表示包

实现关系implements，一个类实现了一个接口

泛化关系extends，也就是类之间的继承关系

is a 关系表示

关联关系 Association

代码表现形式为一个对象含有另一个对象的引用

关联关系有单向关联和双向关联。如果两个对象都知道（即可以调用）对方的公共属性和操作，那么二者就是双向关联。如果只有一个对象知道（即可以调用）另一个对象的公共属性和操作，那么就是单向关联。大多数关联都是单向关联，单向关联关系更容易建立和维护，有助于寻找可重用的类。

关联关系又分为依赖关联、聚合关联和组合关联三种类型

依赖关系 Dependency

属于一种弱关联关系，使用 use a

依赖关系在Java中的具体代码表现形式为B为A的构造器或方法中的局部变量、方法或构造器的参数、方法的返回值，或者A调用B的静态方法。

聚合关系 Aggregation

体现的是整体与部分的拥有关系使用 has a，是一种弱引用关系

此时整体与部分之间是可分离的，它们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享，所以聚合关系也常称为共享关系。

例如，公司部门与员工的关系，一个员工可以属于多个部门，一个部门撤消了，员工可以转到其它部门。

组合关系 Composition也是关联关系的一种特例，它同样体现整体与部分间的包含关系，即 “contains a” 的关系。强关联关系

例如，人包含头、躯干、四肢，它们的生命周期一致。当人出生时，头、躯干、四肢同时诞生。当人死亡时，作为人体组成部分的头、躯干、四肢同时死亡。