Java设计模式-创建型模式

创建型模式

1、工厂方法

/**简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为
*工厂方法：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化下放到子类。
*抽象工厂方法：定义了一个接口用于创建相关或有依赖关系的对象族，而无需明确指定具体类
*/
//披萨例子
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+"cutting");
}
public void box(){
System.out.println(name+"boxing");
}
public void setName(String name){
this.name = name;
}
}
//具体披萨类
public class PepperPizaa extends Pizza{
@Override
public void prepare(){
super.setName("PepperPizaa");
System.out.println(name+"preparing;");
}
}
//订单类
public class OrderPizza{
public OrderPizza(){
Pizza pizza = null;
String orderType;
do{
orderType = getType();
//以下添加种类不便利
if(orderType.equals("cheese")){
pizza = new CheesePizza();
}else if(orderType.equals("greek")){
pizza = new GreekPizza();
}else{
break;
}

pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}while(true);
}
}
//简单工厂模式
//工厂类，包装变化部分
public class SimplePizzaFactory{
public Pizza CreatePizza(String oderType){
Pizza pizza = null;
if(orderType.equals("cheese")){
pizza = new CheesePizza();
}else if(orderType.equals("greek")){
pizza = new GreekPizza();
}else{
break;
}
return pizza;
}
}
//重构后的order类不变
public class OrderPizza{
SimplePizzaFactory mSimplePizzaFactory;

public OrderPizza(SimplePizzaFactory mSimplePizzaFactory){
setFactory(mSimplePizzaFactory);
}
public void setFactory(SimplePizzaFactory mSimplePizzaFactory){
Pizza pizza=null;
String orderType;

this.mSimplePizzaFactory=mSimplePizzaFactory;
do{
orderType=getType();
pizza = mSimplePizzaFactory.CreatePizza(orderType);
if(pizza!=null){
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}
}
}
}
//工厂方法
//抽象order类
public abstract class OrderPizza{
public OrderPizza(){
Pizza pizza = null;
String orderType;
do{
orderType=getType();
pizza=createPizza(oderType);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}while(true);
}

abstract Pizza createPizza(String oderType);
}
//具体order类
public class LDOrderPizza extends OrderPizza{
@Override
Pizza createPizza(String ordertype){
Pizza pizza=null;
if(ordertype.equals("cheese")){
pizza=new LDCheesePizza();
}else if(orderType.equals("pepper")){
pizza=newLDPepperPizza();
}
return pizza;
}
}

2、抽象工厂

//抽象工厂模式
//接口工厂类
public interface AbsFactory{
public Pizza CreatePizza(String oderType);
}
//具体工厂类封装了普通工厂方法里由具体order封装的动作
public class LDFactory implements AbsFactory{
@Override
Pizza createPizza(String ordertype){
Pizza pizza=null;
if(ordertype.equals("cheese")){
pizza=new LDCheesePizza();
}else if(orderType.equals("pepper")){
pizza=newLDPepperPizza();
}
return pizza;
}
}
//统一的order类
public class OrderPizza{
AbsFactory mFactory;

public OrderPizza(AbsFactory mFactory){
setFactory(mFactory);
}

public void setFactory(AbsFactory mFactory){
Pizza pizza = null;
String oderType;

this.mFactory=mFactory;
do{
orderType=gettype();
pizza=mFactory.CreatePizza(orderType);
if(pizza!=null){
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}
}while(true);
}
}
//工厂模式主要功能就是将对象实例化方法分离出来
//变量不持有具体类引用而是方法返回值，不继承具体类，不覆盖已实现方法

3、建造者模式（生成器）

/**生成器模式(建造者模式)：复杂对象生成问题（多个步骤）
*度假计划例子首先创建好假期的组成元素（单个假日），由假期调用方法增加单个假日，从而再在单个假日里设置具体行程，由不同的builder方式动态调用，最后director选择
*类似吃饭，每顿饭都要先做再吃后洗碗（特定流程方法），一天可以吃两顿也可以吃三顿（增加吃饭次数），builder超类严格遵循吃饭流程（一次调用方法），具体吃几顿builder类可以随意设置供主人选择（客人只需要选择吃几顿，而不用操心如何做饭洗碗）
*/
//度假计划例子
//单日行程构成类
public class VacationDay{
private Date mDate;
private String mHotels;
private ArrayList<String> mTickets = null;
private ArrayList<String> mEvents = null;

public VacationDay(Date date){
mDate=date;
mTickets=new ArrayList<String>();
mEvents=new ArrayList<String>();
}

public void setDate(Date date){
mDate=date;
}

public void setHotel(String mHotels){
this.mHotels=mHotels;
}

public void addTicket(String ticket){
mEvents.add(ticket);
}

public void addEvent(String event){
mEvents.add(event);
}

public String showInfo(){
//StringBuilder就是一个很好的生成器模式的范例
StringBuilder stb = new StringBuilder();
stb.append("Date:" + mDate.toString() + "\n");
stb.append("Hotel:" + mHotels + "\n");
stb.append("Tickets:" + mTickets.toString() + “\n”);
stb.append("Events" + mEvents.toString() + "\n");

return stb.toString();
}
}
//计划类
public class Vacation{
private ArrayList<VacationDay> mVacationDayList;
private Date mStDate;
private int mDays=0;  //总天数
private VacationDay mVacationDay;

public Vacation(String std){
mVacationDayList = new ArrayList<VacationDay>();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
try{
mStDate = sdf.parse(std);
mVacationDay = new VacationDay(mStDate);
mVacationDayList.add(mVacationDay);
mDays++;
}catch(ParseException e){
e.printStackTrace();
}
}

public void setStDate(String std){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
try{
mStDate = sdf.parse(std);
}catch(ParseException e){
e.printStackTrace;
}
}

public Date getStDate(){
return mStDate;
}

public void addDay(){
mVacationDay=new VacationDay(nextDate(mDays));  //下一天
mVacationDayList.add(mVacationDay);
mDays++;
}

public boolean setVacationDay(int i) {
if((i>0)&&(i<mVacationDayList.size())){
if((i>0)&&(i<mVacationDayList.size())){
mVacationDay = mVacationDayList.get(i);
}
mVacationDay = null;
return false;
}
}

public void setHotel(String mHotels){
mVacationDay.setHotel(mHotels);
}

public void addTicket(String ticket){
mVacationDay.addTicket(ticket);
}

public void addEvent(String event){
mVacationDay.addEvent(event);
}
public void showInfo(){
for(int i=0,len = mVacationDayList.size();i<len;i++){
System.out.println("****"+(i+1)+"day****");
System.out.println(mVacationDayList.get(i).showInfo());
}
}

private Date nextDate(int n){
Calendar cal = Calendar.getInstance();
cal.setTime(mStDate);
cal.add(Calendar.DATE, n);
return cal.getTime();
}
}
//生成器类
public abstract class AbsBuilder{
public Vacation mVacation;

public AbsBuilder(String std){
mVacation = new Vacation(std);
}

public abstract void buildVacation();

public abstract void buildDay(int i);

public abstract addHotel(String hotel);

public abstract addTicket(String ticket);

public Vacation getVacation(){
return mVacation;
}
}
//三天模式
//如果builder模式比较单一，可以省略抽象，甚至省略指导者，将builder的接口开放给用户高度自定义
public class Builder3d extends AbsBuilder{
public Builder3d(String std){
super(std);
}

@Override
public void buildDay(int i){
mVacation
c37e
.setVacationDay(i);
}

@Override
public void addhotel(String hotel){
mVacation.setHotel(hotel);
}

@Override
public void addTicket(String ticket){
mVacation.addTicket(ticket);
}

@Override
public void addEvent(String event){
mVacation.addEvent(event);
}

@Override
public void buildVacation(){
addTicket("A_Ticket");
addEvent("A1_Event");
addEvent("A2_Event");
addEvent("A3_Event");
addHotel("A_Hotel");

mVacation.addDay();
addTicket("B_Ticket");
addEvent("B_Event");
addHotel("B_Hotel");

mVacation.addDay();
addTicket("C_Ticket");
addEvent("go_home");
}

}
//指导者类
public class Director{
private AbsBuilder builder;

public Director(AbsBuilder builder)
{
this.builder=builder;
}
public void setBuilder(AbsBuilder builder)
{
this.builder=builder;
}
public void construct(){
builder.buildVacation();
builder.getVacation().showInfo();
}
}

4、单态模式（单例）

/**单例模式：确保一个类最多只有一个实例，并提供一个全局访问点
*构造函数私有
*静态方法调用
*/
public class Singleton{
private static Singleton uniqueInstance=null;
//确保只在类内部创建对象
private Singleton(){

}
//控制对象数量
public static Singleton getInstance(){
if(uniqueInstance==null){
uniqueInstance=new Singleton();
}
return uniqueInstance;
}
}
//巧克力工厂例子
public class ChocolateFactory{
private boolean empty;
private boolean boiled;
//控制单例
public static ChocolateFactory uniqueInstance=null;
//急切创建法，public static ChocolateFactory uniqueInstance=new ChocolateFactory();然后直接返回
public ChocolateFactory(){
empty=true;
boiled=false;
}
//线程安全可简答加synchronized关键字
public static ChocolateFactory getInstance(){
if(uniqueInstance==null){
uniqueInstance=new ChocolateFactory();
}
return uniqeInstance;
}
//双层检查加锁法
/*
public static synchronized ChocolateFactory getInstance(){
if(uniqueInstance==null){
sychronized(ChocolateFactory.class) {
if(uniqueInstance==null){
uniqueInstance=new ChocolateFactory();
}
}
}
return uniqeInstance;
}
*/

//添加操作
public void fill(){
if(empty){
//添加原料
empty==false;
}
}
//倒出操作
public void drain(){
if((!empty)&&boiled){
empty=true;
boiled=false;
}
}
//加热操作
public void boil(){
if((!empty)&&(!boiled)){
boiled=true;
}
}
}

5、原型模式

/**原型模式:通过复制现有实例来创建新的实例，无须知道相应类的信息
*优点：比new一个对象更有效，隐藏制造新实例的复杂性
*缺点：必备克隆方法，深层复制比较复杂
*/
//电子账单例子
public class EventTemplate{
private String eventSubject, eventContent;

public EventTemplate(String eventSubject, String eventContent) {
this.eventSubject = eventSubject;
this.eventContent = eventContent;
}

public String getEventSubject(){
return eventSubject;
}

public String getEventContent(){
return eventContent;
}
}

public class Mail implements Cloneable{
private String receiver;
private String subject;
private String content;
private String tail;

public Mail(EventTemplate et){
this.tail = et.getEventContent();
this.subject = et.getEventSubject();
}
//克隆方法
@Override
public Mail clone(){
Mail mail = null;
try {
mail = (Mail) super.clone();
}catch(CloneNotSupportedException){
e.printStackTrace;
}
return mail;
}
public String getReceiver(){
return receiver;
}

public void setReceiver(String receiver){

}

public void setSubject(String subject){
this.subject = subject;
}

public void setContent(String content){
this.content = content;
}

public String getContent(){
return content;
}

public String getTail(){
return tail;
}

public setTail(String tail){
this.tail=tail;
}
}

public class MainTest{
public static void main(String[] args){
int i = 0;
int MAX_COUNT = 10;
EventTemplate et = new EventTemplate("主题"，“内容”);

Mail mail = new Mail(et);

while(i < MAX_COUNT){
Mail cloneMail = mail.clone();
cloneMail.setContent(getRandString(5) + "content" + mail.getTail());
cloneMail.setReceiver(getRandString(5) + "@" + getRandString(8) + ".com");
sendMail(cloneMail);
i++;
}
}

public static String getRandString(int maxLength) {
String source = "abcdefghijklmnopqrskuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
StringBuffer sb = new StringBuffer();
Random rand = new Random();
for(int i=0; i<maxLength; i++){
sb.append(source.charAt(rand.nextInt(source.length())));
}
return sb.toString();
}

public static void sendMail(Mail mail){
System.out.println("title" + mail.getSubject() + "\t收件人：“
+ mail.getReceiver() + "\t内容" + mail.getContent()
+ "\t...发送成功！");
}
}
//注意事项：Obje类的clone方法只会拷贝对象中的基本数据类型，对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。如果要实现深拷贝，在重写clone()方法时要将对象的对象另行拷贝。如object01.object02=（Type02）this.object02.clone();