设计模式-工厂模式

一、简单工厂模式     又叫静态工厂方法模式

是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。 

缺点：
拓展性差，额外增加一个具体产品类时，需要修改工厂。

 

一个例子： 
我喜欢吃面条，抽象一个面条基类，(接口也可以)，这是产品的抽象类。

public abstract class Noodles {
    //描述每种面条啥样的
    public abstract void desc();
}

先来一份兰州拉面（具体的产品类）：

程序员加班必备也要吃泡面（具体的产品类）：

还有我最爱吃的家乡的干扣面（具体的产品类）：

public class LzNoodles extends Noodles{
	@Override
	public void desc() {
		System.out.println("兰州拉面 上海的好贵");
	}
}


public class PaoNoodles extends Noodles{
	@Override
	public void desc() {
		 System.out.println("泡面-程序员加班必备");
	}
}

public class GankouNoodles extends Noodles {
	@Override
	public void desc() {
		System.out.println("还是家里的干扣面好吃 6块一碗");
	}
}

准备工作做完了，我们来到一家“简单面馆”（简单工厂类）

public class NoodlesFactory {
	 public static Noodles createNoodles(String name){
		 if(name == "兰州拉面"){
			 return new LzNoodles();
		 }else if(name == "泡面"){
			 return new PaoNoodles();
		 }else if(name == "干扣面"){
			 return new GankouNoodles();
		 }
		 return null;
	 }
}

简单面馆就提供三种面条（产品），你说你要啥，他就给你啥。这里我点了一份干扣面:

Noodles noodles = NoodlesFactory.createNoodles("干扣面");
noodles.desc();

输出：

还是家里的干扣面好吃 6块一碗

　　

 

二.   工厂方法模式

通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。

优点：提高了程序拓展性，降低了程序间耦合度，
缺点：当具体产品种类非常多时，会出现大量的与之对应的具体子工厂对象，程序变得

使用步

步骤1： 创建抽象工厂类，定义具体工厂的公共接口

abstract class Factory{
    public abstract Product Manufacture();
}

步骤2： 创建抽象产品类 ，定义具体产品的公共接口；

abstract class Product{
    public abstract void Show();
}

步骤3： 创建具体产品类（继承抽象产品类）， 定义生产的具体产品；

//具体产品A类
class  ProductA extends  Product{
    @Override
    public void Show() {
        System.out.println("生产出了产品A");
    }
}

//具体产品B类
class  ProductB extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品B");
    }
}

步骤4：创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；

//工厂A类 - 生产A类产品
class  FactoryA extends Factory{
    @Override
    public Product Manufacture() {
        return new ProductA();
    }
}

//工厂B类 - 生产B类产品
class  FactoryB extends Factory{
    @Override
    public Product Manufacture() {
        return new ProductB();
    }
}

步骤5：外界通过调用具体工厂类的方法，从而创建不同具体产品类的实例

/生产工作流程
public class FactoryPattern {
    public static void main(String[] args){
        //客户要产品A
        FactoryA mFactoryA = new FactoryA();
        mFactoryA.Manufacture().Show();

        //客户要产品B
        FactoryB mFactoryB = new FactoryB();
        mFactoryB.Manufacture().Show();
    }
}

结果：

生产出了产品A
生产出了产品C

 

三.  抽象工厂模式

实现的条件：
　　1.将产品工厂抽象化，为每一个具体产品类提供一个具体产品子工厂
　　2.对应在子工厂中提供去获取该具体产品对象的方法
　　3.在设计程序时要严格划分产品的等级关系
优点：限制了程序自由拓展
缺点：程序的拓展性变差，耦合度增加
使用场景：1.解决工厂方法模式带来的弊端

Nike和Adidas公司在生产鞋的同时，都还在生产衣服，那么，这种情况用工厂模式就不能做到了，因此产生了抽象工厂模式。 
抽象工厂模式的适用范围比工厂模式更加广泛，它与工厂模式最大的区别在于： 
工厂模式中一个工厂只能生产一种产品，而抽象工厂可以生产多个。

Shoes

public interface Shoes {
　　public void wear();
}

AdidasShoes

public class AdidasShoes implements Shoes{
　　@Override
　　public void wear() {
　　　　System.out.println("Wear Adidas Shoes");
　　}
}

NikeShoes

public class NikeShoes implements Shoes{
    @Override
    public void wear() {
        System.out.println("Wear Nike Shoes");
    }
}

Clothes

public interface Clothes {
    public void wear();
}


NikeClothes

public class NikeClothes implements Clothes{
    @Override
    public void wear() {
        System.out.println("Wear Nike Clothes");
    }
}

AdidasClothes

public class AdidasClothes implements Clothes{
    @Override
    public void wear() {
        System.out.println("Wear Adidas Clothes");
    }
}　

LabourFactory

public interface LabourFactory {
    Shoes produceShoes();
    Clothes produceClothes();
}

NikeFactory

public class NikeFactory implements LabourFactory{

    @Override
    public Shoes produceShoes() {
        System.out.println("Produce Nike Shoes");
        return new NikeShoes();
    }

    @Override
    public Clothes produceClothes() {
        System.out.println("Produce Nike Clothes");
        return new NikeClothes();
    }

}

AdidasFactory

public class AdidasFactory implements LabourFactory{

    @Override
    public Shoes produceShoes() {
        System.out.println("Produce Adidas Shoes");
        return new AdidasShoes();
    }

    @Override
    public Clothes produceClothes() {
        System.out.println("Produce Adidas Clothes");
        return new AdidasClothes();
    }

}

　　

链接：https://www.jianshu.com/p/d0c444275827
 
posted @ 2019-01-03 00:14  甘劭  阅读(226)  评论(0)    收藏  举报