设计模式（-）-工厂模式介绍

今天介绍的几个设计模式是前一段时间看《大话设计模式》这本书中介绍的，做个笔记记录下看完的前几章节的内容。不足之处欢迎指正。

简单工厂模式

古代四大发明--活字印刷，里面有四大好处：

可维护
可复用
可扩展
灵活性

活字印刷的优点正好体现了java面向对象的好处
java通过封装，继承，多态把程序的耦合度降低，在没有活字印刷术之前，传统的印刷术把所有字都刻在同一版面上造成耦合度太高。
用设计模式可以让程序更加的灵活，容易修改，便于复用
这里的复用跟复制是完全不一样的哦，复制代码会冗余，复用是将需要的代码在需要的地方直接引用就行了。例如我们平常开发的时候将业务和计算分开显示。

下面通过一个简单代码来了解下工厂模式

//动物类
abstract class Animal {
    //动物有新陈代谢的功能
    public void Metabolism(Oxygen oxygen, Water water) {
    };
}

//鸟类
public class Bird extends Animal {
    private Wing wing;
    public Bird() {
        wing = new Wing();//鸟在初始化时就有翅膀
    }
    public egg() {
    }
}

//企鹅
public class Penguin extends Bird {
    private Climate climate;
    public egg() {
    }
}

企鹅是一种特别的鸟，会游泳不会飞，从它的属性来看与气候有关联（常年在寒冷地区），所以它需要知道气候的变化，“了解”气候。

------------------------------------------------------------
//飞翔的借口
public interface Fly {
    //飞行能力
    void fly();
}

//大雁
public class WideGoose extends Animal implements Fly {
    @Override
    public void fly() {
        
    }
    public egg() {
    }    
}
//雁群
public class WideGooseGroup  {
   private WideGoose[] wideGooseGroup;
}

大雁是群居动物，每只大雁都是属于一个雁群，一个雁群可以又多只大雁。所以它们之间就满足聚合关系。

聚合表示一种弱的拥有关系，体现的是A对象可以包含B对象，当B对象不是A对象的一部分；
合成是一种强的拥有关系，体现了严格的部分和整体的生命周期一样，在上述Bird类中鸟和翅膀Wind就是组合关系，它们是部分和整体的关系，并且翅膀和鸟的生命周期是相同的。

策略模式

策略模式是一种定义一系列算法的方法，从概念上看，所有的这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少各种算法类与使用算法之间的耦合。还有个优点是简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试

abstract class CashSuper {
    public abstract double acceptCash(double money);
}

public class CashNormal extends CashSuper {

    @Override
    public double acceptCash(double money) {
        //计算方法
        return money;
    }
}

public class CashRebate extends CashSuper {

    @Override
    public double acceptCash(double money) {
        //计算方法
        return money;
    }
}

public class CashReturn extends CashSuper {
    @Override
    public double acceptCash(double money) {
        //计算方法
        return money;
    }
}

public class CashContext {
    private CashSuper cashSuper = null;
    
    public CashContext(String type) {
        switch (type) {
            case "正常收费" : 
                CashNormal cashNormal = new CashNormal();
                cashSuper = cashNormal;
                break;
            case "满200减50" :
                CashReturn cashReturn = new CashReturn();
                cashSuper = cashReturn;
                break;
            case "8折" :
                CashRebate cashRebate = new CashRebate();
                cashSuper = cashRebate;
                break;
        }
    }
    
    public double getResult(double money) {
        return cashSuper.acceptCash(money);
    }
}

策略模式与简单工厂模式结合，客户端只需要认识一个类CashContext，就可以了，降低耦合

单一职责

如果一个类的职责过多，就等于把这些职责耦合在一起，在单一职责中，需要清楚的将逻辑分块分好。

开发-封闭原则

通过抽象类，一些面向对象的手段（如继承，多态来隔离具体方法），面对新的需求，对程序的改动是通过增加新代码进行的，而不是更改现有的代码-----开发／封闭原则
例如：

以前对工厂模式比较模糊，希望通过笔记更加清楚的理解何为工厂模式，如何使用工厂模式，待我再看些内容，再做笔记。一起学习，一起进步。