【设计模式】【一】创建型模式总结

    前文提到，设计模式大致分为创建型、结构型、以及行为型三个大类。

    而创建型模式、多为更合理的创建对象而设计，由于J2EE中对象的创建多为Spring管理，所以实际开发中使用的并不多。当然不包括造轮子的大牛们。

    于此，简单总结了创建型模式的应用场景以及简单示例，欢迎指点：

一、单例模式

        简介：顾名思义，单例模式（singleton pattern）保证一个类只生产一个对象。

        情景：用于一些重量级资源，节约资源。

        注意：多线程下需要注意同步锁。

        Demo：

/**
 * singleton pattern
 * @author ZX
 *
 */
public class SingleObject {
    //
    private static SingleObject instance = new SingleObject();
    public static SingleObject getInstance(){
        return instance;
    }
    //私有构造方法，不允许直接创建对象
    private SingleObject() {}
}

 

二、工厂模式

        简介：生产对象的工厂，工厂模式（Factory Pattern），提供一个接口，传入参数生产对应类型的对象。

        情景：例如数据库切换等。提升了系统的灵活性。

        注意：不宜滥用，工厂模式会增加类的数量与系统复杂度。

        Demo：

 

class FoodFactory {
	public Food getFood(String food){
		switch (food) {
		case "fish":
			return new Fish();
		case "meat":
			return new Meat();
		default:
			return new WestNothWind();
		}
	   
		
	}
}
interface Food{
}
class Fish implements Food{

	public Fish() {
		System.err.println("fish");
	}
	
}

class Meat implements Food{

	public Meat() {
		System.err.println("Meat");
	}
	
}

class WestNothWind implements Food{

	public WestNothWind() {
		System.err.println("fuck");
	}
	
}

public class TestFactoryPattern{
	public static void main(String[] args) {
		FoodFactory foodFactory = new FoodFactory();
		foodFactory.getFood("meat");
	}
}

 

三、抽象工厂模式

        简介:抽象工厂模式（Abstract Factory pattern），简单来说,就是生产工厂的工厂。

        情景：在工厂方法模式中，我们的具体创建者每次使用都只能创建一个同类型的对象，假如我们现在需要的是多个不同类型的对象，工厂方法就满足不了需求了。

        Demo：

 

//人对象
interface Human{
}
class Boy implements Human{

	public Boy() {
		System.err.println("boy");
	}
	
}

class Girl implements Human{

	public Girl() {
		System.err.println("girl");
	}
	
}

class Bill implements Human{

	public Bill() {
		System.err.println("Billy Herrington");
	}
	
}

//具体工厂
interface Factory{
	
}
class HumanFactory implements Factory{
	Human human=null;
	public Human getHuman(String sex){
		try {
			if(sex==null||"".equals(sex)){
				human=new Bill();
			}else if("男".equals(sex)){
				human=new Boy();
			}else if("女".equals(sex)){
				human=new Bill();
			}else{
				human=new Bill();
			}
		} catch (Exception e) {
			human=new Bill();
		}
		return human;
	}
}
//抽象工厂
class abstractFactory {
	public HumanFactory getHumanFactory(){
		return new HumanFactory();
	}
	public HumanFactory getAnimalFactory(){
		return new HumanFactory();
	}
}
public class TestFactoryPattern{
	public static void main(String[] args) {
		abstractFactory af = new abstractFactory();
		HumanFactory humanFactory = af.getHumanFactory();
		humanFactory.getHuman("男");
	}
}

 

四、建造者模式

        简介：建造者模式（Builder Pattern），打包创建对象。

        情景：假如某一个大的对象由很多小对象构成（一台电脑由鼠标、键盘、主机。。。组成，抽象出一个接口为标准）.

        Demo：

 

package tree;


import java.util.ArrayList;
import java.util.List;

/**
 * 建造模式测试类
 * @author zx
 */
public class Test {
    public static void main(String[] args) {
        //静态-已经定义好了属性，根据定义好的属性去建造这个对象
        Computer personalComputer =new MyPersonComputer();
        personalComputer.addMouse("雪蛇");
        personalComputer.addKeyBord("樱桃园");
        personalComputer.addBox("耿想");
        personalComputer.addScreen("朋基");
        //动态-动态添加购物车
        ShoppingCart b = new ShoppingCart();
        b.buy(new Pen());
        b.buy(new Ball());
        System.out.println("需支付："+b.getPrice());
    }
}

/**
 * 第一种，静态建造模式
 */
abstract class Computer {
    protected String mouse;
    protected String keyBord;
    protected String box;
    protected String screen;

    abstract void addMouse(String mouse);

    abstract void addKeyBord(String keyBord);

    abstract void addBox(String box);

    abstract void addScreen(String screen);


}
class MyPersonComputer extends Computer {
    @Override
    void addMouse(String mouse) {
        this.mouse=mouse;
    }

    @Override
    void addKeyBord(String keyBord) {
        this.keyBord=keyBord;
    }

    @Override
    void addBox(String box) {
        this.box=box;
    }

    @Override
    void addScreen(String screen) {
        this.screen=screen;
    }

}

/**
 * 第二种，动态的建造模式
 */
interface Shop {
    String getName();

    Double getPrice();
}

class Toy implements Shop {

    @Override
    public String getName() {
        return "toy";
    }

    @Override
    public Double getPrice() {
        return 10.0;
    }
}

class Pen implements Shop {
    @Override
    public String getName() {
        return "pen";
    }

    @Override
    public Double getPrice() {
        return 20.0;
    }
}

class Pencil implements Shop {

    @Override
    public String getName() {
        return "Pencil";
    }

    @Override
    public Double getPrice() {
        return 2.0;
    }
}

class Biro implements Shop {

    @Override
    public String getName() {
        return "Biro";
    }

    @Override
    public Double getPrice() {
        return 30.0;
    }
}

class Ball implements Shop {

    @Override
    public String getName() {
        return "ball";
    }

    @Override
    public Double getPrice() {
        return 40.0;
    }
}

/**
 * 购物车对象
 */
class ShoppingCart {
    List<Shop> shopList = new ArrayList<>();

    /**
     * 动态建造购物车商品列表
     * @param shop
     */
    public void buy(Shop shop) {
        shopList.add(shop);

    }

    public double getPrice() {
        double price = 0.0;
        for (Shop p : shopList) {
            price += p.getPrice();
        }
        return price;
    }
}

 

五、原型模式

        简介：原型模式（Prototype Pattern}）预先创建好对象存放进map中，使用时直接取出即可.

        情景：数据源

        注意：对象类实现cloneable接口

        Demo：

 

public class Box {
	 private static Map<String, Color> map = new HashMap<String, Color>();
	 static{
		 map.put("red", new Red());
		 map.put("Green", new Green());
		 map.put("blue", new Blue());
	 }
	 public static Color getColor(String name){
		 return map.get(name);
	 }
	
}

public class T {
	 public static void main(String[] args) {
		 
		 Color color = Box.getColor("red");
		 color.show();
		 Color color2 = Box.getColor("red");
		 color2.show();
		 Color color3 = Box.getColor("red");
		 color3.show();
		 Color color4 = Box.getColor("red");
		 color4.show();
	}
}

 

        以上是五种创建型设计模式，主要用作创建对象，由于现在大多数项目都采用Spring来管理，所以可以不用太过关心对象的创建，大体上了解即可。

        整体看下来后，采用设计模式无非是本着想让代码更灵活，可复用以节约资源等目的而总结出的，所以多多实践，多多思考自然也能总结出自己的设计模式，是吧？