package com.wp.java.builder;
import org.junit.Test;
public class DoDoContactDemo {
@Test
public void test(){
DoDoContact contact = new DoDoContact.Builder("jack").address("lundun").safeID(5).age(10).build();
}
}
class DoDoContact {
private int age;
private int safeID;
private String name;
private String address;
public int getAge() {
return age;
}
public int getSafeID() {
return safeID;
}
public String getName() {
return name;
}
public String getAddress() {
return address;
}
static class Builder{
private int age=0;
private int safeID =0;
private String name=null;
private String address = null;
public Builder(String name){
this.name = name;
}
public Builder age(int age){
this.age = age;
return this;
}
public Builder safeID(int safeID){
this.safeID = safeID;
return this;
}
public Builder address(String address){
this.address = address;
return this;
}
public DoDoContact build(){
return new DoDoContact(this);
}
}
private DoDoContact(Builder b){
age = b.age;
name = b.name;
safeID = b.safeID;
address = b.address;
}
}
package com.wp.java.builder; import org.junit.Test;
/**
* Builder 模式
* */
public class CardDemo {
@Test
public void test(){
Card con = new ConcreteCard();
Director dir = new Director(con);
dir.construct();
}
} interface Card {
void createPardA();
void createPardB();
void createPardC();
} class ConcreteCard implements Card{ @Override
public void createPardA() { } @Override
public void createPardB() { } @Override
public void createPardC() { } } class Director {
private Card card; public Director(Card card) {
super();
this.card = card;
} public void construct(){
card.createPardA();
card.createPardB();
card.createPardC();
}
}
上面都是简单的测试案例,下面将接触到的框架中原样,Universal-Image-Loader,相信有部分搞android开发的哥们是有点眼熟的,看代码吧
package com.nostra13.universalimageloader.core; import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory.Options;
import android.graphics.drawable.Drawable;
import android.os.Handler;
import com.nostra13.universalimageloader.core.listener.ImageLoadingListener;
import com.nostra13.universalimageloader.core.assist.ImageScaleType;
import com.nostra13.universalimageloader.core.display.BitmapDisplayer;
import com.nostra13.universalimageloader.core.display.SimpleBitmapDisplayer;
import com.nostra13.universalimageloader.core.download.ImageDownloader;
import com.nostra13.universalimageloader.core.process.BitmapProcessor; public final class DisplayImageOptions { private final int imageResOnLoading;
private final int imageResForEmptyUri;
private final int imageResOnFail;
private final Drawable imageOnLoading;
private final Drawable imageForEmptyUri;
private final Drawable imageOnFail;
private final boolean resetViewBeforeLoading;
private final boolean cacheInMemory;
private final boolean cacheOnDisk;
private final ImageScaleType imageScaleType;
private final Options decodingOptions;
private final int delayBeforeLoading;
private final boolean considerExifParams;
private final Object extraForDownloader;
private final BitmapProcessor preProcessor;
private final BitmapProcessor postProcessor;
private final BitmapDisplayer displayer;
private final Handler handler;
private final boolean isSyncLoading; private DisplayImageOptions(Builder builder) {
imageResOnLoading = builder.imageResOnLoading;
imageResForEmptyUri = builder.imageResForEmptyUri;
imageResOnFail = builder.imageResOnFail;
imageOnLoading = builder.imageOnLoading;
imageForEmptyUri = builder.imageForEmptyUri;
imageOnFail = builder.imageOnFail;
resetViewBeforeLoading = builder.resetViewBeforeLoading;
cacheInMemory = builder.cacheInMemory;
cacheOnDisk = builder.cacheOnDisk;
imageScaleType = builder.imageScaleType;
decodingOptions = builder.decodingOptions;
delayBeforeLoading = builder.delayBeforeLoading;
considerExifParams = builder.considerExifParams;
extraForDownloader = builder.extraForDownloader;
preProcessor = builder.preProcessor;
postProcessor = builder.postProcessor;
displayer = builder.displayer;
handler = builder.handler;
isSyncLoading = builder.isSyncLoading;
} public boolean shouldShowImageOnLoading() {
return imageOnLoading != null || imageResOnLoading != 0;
} public boolean shouldShowImageForEmptyUri() {
return imageForEmptyUri != null || imageResForEmptyUri != 0;
} public boolean shouldShowImageOnFail() {
return imageOnFail != null || imageResOnFail != 0;
} public boolean shouldPreProcess() {
return preProcessor != null;
} public boolean shouldPostProcess() {
return postProcessor != null;
} public boolean shouldDelayBeforeLoading() {
return delayBeforeLoading > 0;
} public Drawable getImageOnLoading(Resources res) {
return imageResOnLoading != 0 ? res.getDrawable(imageResOnLoading) : imageOnLoading;
} public Drawable getImageForEmptyUri(Resources res) {
return imageResForEmptyUri != 0 ? res.getDrawable(imageResForEmptyUri) : imageForEmptyUri;
} public Drawable getImageOnFail(Resources res) {
return imageResOnFail != 0 ? res.getDrawable(imageResOnFail) : imageOnFail;
} public boolean isResetViewBeforeLoading() {
return resetViewBeforeLoading;
} public boolean isCacheInMemory() {
return cacheInMemory;
} public boolean isCacheOnDisk() {
return cacheOnDisk;
} public ImageScaleType getImageScaleType() {
return imageScaleType;
} public Options getDecodingOptions() {
return decodingOptions;
} public int getDelayBeforeLoading() {
return delayBeforeLoading;
} public boolean isConsiderExifParams() {
return considerExifParams;
} public Object getExtraForDownloader() {
return extraForDownloader;
} public BitmapProcessor getPreProcessor() {
return preProcessor;
} public BitmapProcessor getPostProcessor() {
return postProcessor;
} public BitmapDisplayer getDisplayer() {
return displayer;
} public Handler getHandler() {
return handler;
} boolean isSyncLoading() {
return isSyncLoading;
} /**
* Builder for {@link DisplayImageOptions}
*/
public static class Builder {
private int imageResOnLoading = 0;
private int imageResForEmptyUri = 0;
private int imageResOnFail = 0;
private Drawable imageOnLoading = null;
private Drawable imageForEmptyUri = null;
private Drawable imageOnFail = null;
private boolean resetViewBeforeLoading = false;
private boolean cacheInMemory = false;
private boolean cacheOnDisk = false;
private ImageScaleType imageScaleType = ImageScaleType.IN_SAMPLE_POWER_OF_2;
private Options decodingOptions = new Options();
private int delayBeforeLoading = 0;
private boolean considerExifParams = false;
private Object extraForDownloader = null;
private BitmapProcessor preProcessor = null;
private BitmapProcessor postProcessor = null;
private BitmapDisplayer displayer = DefaultConfigurationFactory.createBitmapDisplayer();
private Handler handler = null;
private boolean isSyncLoading = false; @Deprecated
public Builder showStubImage(int imageRes) {
imageResOnLoading = imageRes;
return this;
} public Builder showImageOnLoading(int imageRes) {
imageResOnLoading = imageRes;
return this;
} public Builder showImageOnLoading(Drawable drawable) {
imageOnLoading = drawable;
return this;
} public Builder showImageForEmptyUri(int imageRes) {
imageResForEmptyUri = imageRes;
return this;
} public Builder showImageForEmptyUri(Drawable drawable) {
imageForEmptyUri = drawable;
return this;
} public Builder showImageOnFail(int imageRes) {
imageResOnFail = imageRes;
return this;
} public Builder showImageOnFail(Drawable drawable) {
imageOnFail = drawable;
return this;
} public Builder resetViewBeforeLoading() {
resetViewBeforeLoading = true;
return this;
} public Builder resetViewBeforeLoading(boolean resetViewBeforeLoading) {
this.resetViewBeforeLoading = resetViewBeforeLoading;
return this;
} @Deprecated
public Builder cacheInMemory() {
cacheInMemory = true;
return this;
} public Builder cacheInMemory(boolean cacheInMemory) {
this.cacheInMemory = cacheInMemory;
return this;
} @Deprecated
public Builder cacheOnDisc() {
return cacheOnDisk(true);
} @Deprecated
public Builder cacheOnDisc(boolean cacheOnDisk) {
return cacheOnDisk(cacheOnDisk);
} /** Sets whether loaded image will be cached on disk */
public Builder cacheOnDisk(boolean cacheOnDisk) {
this.cacheOnDisk = cacheOnDisk;
return this;
} public Builder imageScaleType(ImageScaleType imageScaleType) {
this.imageScaleType = imageScaleType;
return this;
} public Builder bitmapConfig(Bitmap.Config bitmapConfig) {
if (bitmapConfig == null) throw new IllegalArgumentException("bitmapConfig can't be null");
decodingOptions.inPreferredConfig = bitmapConfig;
return this;
} public Builder decodingOptions(Options decodingOptions) {
if (decodingOptions == null) throw new IllegalArgumentException("decodingOptions can't be null");
this.decodingOptions = decodingOptions;
return this;
} public Builder delayBeforeLoading(int delayInMillis) {
this.delayBeforeLoading = delayInMillis;
return this;
} public Builder extraForDownloader(Object extra) {
this.extraForDownloader = extra;
return this;
} public Builder considerExifParams(boolean considerExifParams) {
this.considerExifParams = considerExifParams;
return this;
} public Builder preProcessor(BitmapProcessor preProcessor) {
this.preProcessor = preProcessor;
return this;
} public Builder postProcessor(BitmapProcessor postProcessor) {
this.postProcessor = postProcessor;
return this;
} public Builder displayer(BitmapDisplayer displayer) {
if (displayer == null) throw new IllegalArgumentException("displayer can't be null");
this.displayer = displayer;
return this;
} Builder syncLoading(boolean isSyncLoading) {
this.isSyncLoading = isSyncLoading;
return this;
} public Builder handler(Handler handler) {
this.handler = handler;
return this;
} /** Sets all options equal to incoming options */
public Builder cloneFrom(DisplayImageOptions options) {
imageResOnLoading = options.imageResOnLoading;
imageResForEmptyUri = options.imageResForEmptyUri;
imageResOnFail = options.imageResOnFail;
imageOnLoading = options.imageOnLoading;
imageForEmptyUri = options.imageForEmptyUri;
imageOnFail = options.imageOnFail;
resetViewBeforeLoading = options.resetViewBeforeLoading;
cacheInMemory = options.cacheInMemory;
cacheOnDisk = options.cacheOnDisk;
imageScaleType = options.imageScaleType;
decodingOptions = options.decodingOptions;
delayBeforeLoading = options.delayBeforeLoading;
considerExifParams = options.considerExifParams;
extraForDownloader = options.extraForDownloader;
preProcessor = options.preProcessor;
postProcessor = options.postProcessor;
displayer = options.displayer;
handler = options.handler;
isSyncLoading = options.isSyncLoading;
return this;
} /** Builds configured {@link DisplayImageOptions} object */
public DisplayImageOptions build() {
return new DisplayImageOptions(this);
}
} public static DisplayImageOptions createSimple() {
return new Builder().build();
}
}