前文提到，设计模式大致分为创建型、结构型、以及行为型三个大类。
而创建型模式、多为更合理的创建对象而设计，由于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() {}
}
更多：https://www.runoob.com/design-pattern/singleton-pattern.html
二、工厂模式
简介：生产对象的工厂，工厂模式（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("****");
}
}
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("????");
}
}
//具体工厂
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：
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来管理，所以可以不用太过关心对象的创建，大体上了解即可。
整体看下来后，采用设计模式无非是本着想让代码更灵活，可复用以节约资源等目的而总结出的，所以多多实践，多多思考自然也能总结出自己的设计模式，是吧？