设计模式——（工厂模式）（抽象工厂模式）

工厂模式：

 简单工厂模式：

        简单示例（订购）：传统方法
            优点：编写容易
            缺点：违背ocp原则，添加一个新的商品时，应修较少的修改代码。
        创建一个商品类

            package com.kun.gongchang;
            public abstract class Pizza {
                protected String name;
                public abstract void prepare();
                
                public void bake() {
                    System.out.println(name+" baking");
                }
                public void cut() {
                    System.out.println(name+" cuting");
                }
                public void box() {
                    System.out.println(name+" boxing");
                }
                public void setName(String name) {
                    this.name=name;
                }
            }

创建两个商品准备方法：

 public class GreekPizza extends Pizza{
                @Override
                public void prepare() {
                    System.out.println("zhun bei b");
                }
                
            }
            public class CheesePizza extends Pizza{
                @Override
                public void prepare() {
                    // TODO Auto-generated method stub
                    System.out.println("zhun bei a");
                }
                
            }

创建一个订单类：  

package com.kun.gongchang;
            import java.util.Scanner;
            public class OrderPizza {
                public OrderPizza() {
                    Pizza p=null;
                    String orderType;
                    do {
                        orderType=gettype();
                        if (orderType.equals("greek")) {
                            p=new GreekPizza();
                            p.setName("greek");
                        }else if(orderType.equals("cheese")){
                            p=new CheesePizza();
                            p.setName("cheese");
                        }else {
                            System.out.println("mei you");
                            break;
                        }
                        p.prepare();
                        p.bake();
                        p.cut();
                        p.box();
                    }while(true);
                }
                private String gettype() {
                    Scanner s= new Scanner(System.in);
                    System.out.print("shuru : ");
                    String type=s.next();
                    return type;
                }
            }

        最后：
            直接new一个订单类对象并输入商品。
        简单工厂模式：
            创建一个工厂类： 

 public class Factory {
                public Pizza createPizza(String orderType) {
                    Pizza pizza=null;
                    System.out.println("factory----");
                    if (orderType.equals("greek")) {
                        pizza=new GreekPizza();
                        pizza.setName("greek");
                    }else if(orderType.equals("cheese")){
                        pizza=new CheesePizza();
                        pizza.setName("cheese");
                    }
                    return pizza;
                }
            }

 修改订单里面的方法（使用聚合）：

 Factory factory;
                Pizza pizza=null;
                public OrderPizza(Factory factory) {
                    setFactory(factory);
                }
                public void setFactory(Factory factory) {
                    String orderType="";
                    this.factory=factory;
                    do {
                        orderType=gettype();
                        pizza=this.factory.createPizza(orderType);
                        if (pizza!=null) {
                            pizza.prepare();
                            pizza.bake();
                            pizza.cut();
                            pizza.box();
                        }else {
                            System.out.println("shi  bai");
                            break;
                        }
                    } while (true);
                }

修改运行类：

  public class PizzaStore {
            public static void main(String[] args) {
                new OrderPizza(new Factory());
                System.out.println("00000");
            }
        }

 工厂方法模式：

        介绍：
            将项目的实例化功能抽象成抽象方法
            定义了一个创建对象的抽象方法，由子类决定实例化的类。对对象的实例化推迟到子类。
        实例：
            创建一个商品类

public abstract class Pizza {
                protected String name;
                public abstract void prepare();
                public void bake() {
                    System.out.println(name+" baking");
                }
                public void cut() {
                    System.out.println(name+" cuting");
                }
                public void box() {
                    System.out.println(name+" boxing");
                }
                public void setName(String name) {
                    this.name=name;
                }
            }

 分别创建两个地方，俩个种类的商品（一个地方的代码，另个一样）    

 public class TJCheesePizza extends Pizza{
                    @Override
                    public void prepare() {
                        setName("tian jing cheese");
                        System.out.println("TIAN JIN AAA");
                    }
                }
            ——————————————————————————————————————————————————
                public class TJPepperPizza extends Pizza{
                    @Override
                    public void prepare() {
                        // TODO Auto-generated method stub
                        setName("TIAN JIN pepper");
                        System.out.println("TIAN JIN BBB");
                    }
                }

 创建订单类

package com.kun.gongchangfangfa;
                import java.util.Scanner;
                public abstract class OrderPizza {
                    public OrderPizza() {
                        Pizza pizza=null;
                        String orderType;
                        do {
                            orderType=gettype();
                            pizza=createPizza(orderType);
                            pizza.prepare();
                            pizza.bake();
                            pizza.cut();
                            pizza.box();
                        }while(true);
                    }
                    abstract Pizza createPizza(String orderType);
                    
                    private String gettype() {
                        Scanner s= new Scanner(System.in);
                        System.out.print("shuru : ");
                        String type=s.next();
                        return type;
                    }
                }

 分别创建两个地方的订单类，继承订单类实现createPizza抽象方法（另一个相同）

  public class BJOrderPizza extends OrderPizza{
                    @Override
                    Pizza createPizza(String orderType) {
                        // TODO Auto-generated method stub
                        Pizza pizza=null;
                        if (orderType.equals("cheese")) {

                            pizza=new BJCheesePizza();
                        }else if(orderType.equals("pepper")){
                            pizza=new BJPepperPizza();
                        }
                        return pizza;
                    }

                }

            在商店类实现创建订单

  public class PizzaStore {
                    public static void main(String[] args) {
                        new BJOrderPizza();
                    }
                }

抽象工厂模式

介绍：
        定义一个交接口用于创建相关的对象
        抽象工厂模式可以将简单的工厂模式和工厂模式方法整合

创建一个接口

public interface AbsFactory {
	public Pizza createPizza(String orderType);
}

创建一个地区的工厂继承接口，管理这个地区的商品

public class BJFactory implements AbsFactory{

	@Override
	public Pizza createPizza(String orderType) {
		Pizza pizza=null;
		if (orderType.equals("cheese")) {
			pizza=new BJCheesePizza();
		}else if (orderType.equals("pepper")) {
			pizza=new BJPepperPizza();
		}
		return pizza;
	}

}

创建一个总的订单类管理上面两个工厂

package com.kun.gongchangchouxiang;

import java.util.Scanner;

public class OrderPizza {
	AbsFactory absFactory;
	public OrderPizza(AbsFactory absFactory) {
		setFactory(absFactory);
	}
	private void setFactory(AbsFactory absFactory) {
		Pizza pizza=null;
		String orderType="";
		this.absFactory=absFactory;
		do {
			orderType=gettype();
			pizza=absFactory.createPizza(orderType);
			if (pizza!=null) {
				pizza.prepare();
				pizza.bake();
				pizza.cut();
				pizza.box();
			}else {
				System.out.println("shi  bai");
				break;
			}
		} while (true);
	}
	private String gettype() {
		Scanner s= new Scanner(System.in);
		System.out.print("shuru : ");
		String type=s.next();
		return type;
	}
}

运行

public class PizzaStore {
	public static void main(String[] args) {
		new OrderPizza(new BJFactory());
	}
}