为什么将这两个模式一起说呢，因为它们经常是同时出现(框架中)或者使用(自己写的代码).
直接上代码，然后再说其中的区别。
工厂模式(这里主要以抽象工厂为例)
意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
书内完整：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
主要解决：主要解决接口选择的问题。何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
如何解决：在一个产品族里面，定义多个产品。
关键代码：在一个工厂里聚合多个同类产品。
应用实例：工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。假设一种情况（现实中是不存在的，要不然，没法进入共产主义了，但有利于说明抽象工厂模式），在您的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OOP 的思想去理解，所有的衣柜（具体工厂）都是衣柜类的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），这些具体的上衣其实也都是上衣（抽象产品），具体的裤子也都是裤子（另一个抽象产品）。
优点：
抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。
1.可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
2.当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
3.抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。
4.当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：
1.产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。
2.当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。
使用场景： 1、QQ 换皮肤，一整套一起换。 2、生成不同操作系统的程序。注意事项：产品族难扩展，产品等级易扩展。
先看基本目录哈
1.先创建Shape和Color工厂
Color.java
public interface Color {
/**
* 填充
*/
void fill();
}
Shape.jaba
public interface Shape {
/**
* 绘画
*/
void draw();
}
2.然后我们color和shape都拿其中一个来举例，其他效仿哈
Red.java
public class Red implements Color {
@Override
public void fill() {
System.out.println("Inside Red::fill() method.");
}
}
Circle.java
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
3.再创建工厂创造器
FactoryProducer
public class FactoryProducer {
public static AbstractFactoryDemo getFactory(String choice) {
if (choice.equalsIgnoreCase("SHAPE")) return new ShapeFactory();
if (choice.equalsIgnoreCase("COLOR")) return new ColorFactory();
return null;
}
}
4.最后测试一下(自己创一个类)
public static void main(String[] args) {
//获取图形工厂
AbstractFactoryDemo shape = FactoryProducer.getFactory("SHAPE");
//通过图形工厂 获取图形中的3个或多个图形
Shape circle = shape.getShape("CIRCLE");
circle.draw();
Shape rectangle = shape.getShape("RECTANGLE");
rectangle.draw();
Shape square = shape.getShape("SQUARE");
square.draw();
//获取颜色工厂
AbstractFactoryDemo color = FactoryProducer.getFactory("COLOR");
//通过颜色工厂 获取颜色中的3个或多个颜色
Color red = color.getColor("RED");
red.fill();
Color yellow = color.getColor("YELLOW");
yellow.fill();
Color blue = color.getColor("BLUE");
blue.fill();
}
输出结果：
策略模式
意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。
书内完整：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。
主要解决：在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护。何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。
如何解决：将这些算法封装成一个一个的类，任意地替换。
关键代码：实现同一个接口。
应用实例： 1、JAVA AWT 中的 LayoutManager 2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。3、spring中使用。 4、jdk中使用。 5、电商的多促销模式。 6、多种不同的支付方式。
优点：
1.算法可以自由切换。 1.2、避免使用多重条件判断。 1.3、扩展性良好。
2.多重条件语句不易维护，而使用策略模式可以避免使用多重条件语句，如 if...else 语句、switch...case 语句。
3.策略模式提供了一系列的可供重用的算法族，恰当使用继承可以把算法族的公共代码转移到父类里面，从而避免重复的代码。
4.策略模式可以提供相同行为的不同实现，客户可以根据不同时间或空间要求选择不同的。
5.策略模式提供了对开闭原则的完美支持，可以在不修改原代码的情况下，灵活增加新算法。
6.策略模式把算法的使用放到环境类中，而算法的实现移到具体策略类中，实现了二者的分离。
缺点： 1.策略类会增多。 2.所有策略类都需要对外暴露。
3.客户端必须理解所有策略算法的区别，以便适时选择恰当的算法类。
4.策略模式造成很多的策略类，增加维护难度。使用场景： 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。
注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。
大致的目录跟工厂模式一样差不多创建即可
CrabCookingStrategy 、CrabCooking(抽象策略接口)、(具体策略)1.BraisedCrabs 2.SteamedCrabs、Kitchen(环境)
为了方便看我直接放一个类了
public class CrabCookingStrategy {
private Kitchen kitchen; //厨房
private CrabCooking qzx, hsx; //大闸蟹加工者
CrabCookingStrategy() {
System.out.println("策略模式在大闸蟹做菜中的应用");
List arrayList= new ArrayList<>();
//环境
kitchen = new Kitchen();
// 清蒸
qzx = new SteamedCrabs();
// 红烧
hsx = new BraisedCrabs();
//修改策略
itemStateChanged(qzx);
System.out.println(kitchen.getStrategy());
itemStateChanged(hsx);
System.out.println(kitchen.getStrategy());
itemStateChanged(qzx);
System.out.println(kitchen.getStrategy());
}
public void itemStateChanged(Object action) {
if (action == qzx) {
kitchen.setStrategy(qzx);
kitchen.cookingMethod(); //清蒸
} else if (action == hsx) {
kitchen.setStrategy(hsx);
kitchen.cookingMethod(); //红烧
}
}
public static void main(String[] args) {
new CrabCookingStrategy();
}
}
//抽象策略类：大闸蟹加工类
interface CrabCooking {
public void cookingMethod(); //做菜方法
}
//具体策略类：清蒸大闸蟹
class SteamedCrabs implements CrabCooking {
private static final long serialVersionUID = 1L;
public void cookingMethod() {
System.out.println("清蒸大闸蟹");
}
}
//具体策略类：红烧大闸蟹
class BraisedCrabs implements CrabCooking {
private static final long serialVersionUID = 1L;
public void cookingMethod() {
System.out.println("红烧大闸蟹");
}
}
//环境类：厨房
class Kitchen {
//抽象策略
private CrabCooking strategy;
public void setStrategy(CrabCooking strategy) {
this.strategy = strategy;
}
public CrabCooking getStrategy() {
return strategy;
}
public void cookingMethod() {
System.out.println("做菜");
strategy.cookingMethod(); //做菜
}
}
