定义：这类模式的作用就是对实例化过程进行抽象，是对象的创建和使用相分离
简单工厂模式
这个模式就是包含元素：产品类、具体产品类、工厂类
以买品牌手机为例：
产品类
public interface Phone{
public void buy();
}
具体产品类
public class Apple implements Phone{
public void buy(){
System.out.println(“apple”);
}
}
public class Sam implements Phone{
public void buy(){
System.out.println(“sam”);
}
}
工厂类,根据传入参数来决定返回的手机
public class PhoneFactor{
public static Phone factory(String name){
if("apple".equals(name)){
return new Apple();
}else if("sam".equals(name)){
return new Sam();
}else{
return null;
}
}
}
优点：外界只需要传入参数即可得到想要的商品，简化了调用出代码的复杂度
缺点：里面的判断过多，如果新增一个商品则需要更改工厂类
工厂方法
将具体的创建实例放到了工厂类的子类，工厂类中只定义方法即可
包含元素：抽象产品、具体产品、抽象工厂、具体工厂
以灯泡为例
//抽象产品接口
public interface ILight
{
void TurnOn();
void TurnOff();
}
//具体产品类
public class BulbLight implements ILight
{
public void TurnOn()
{
Console.WriteLine("BulbLight turns on."); }
public void TurnOff()
{
Console.WriteLine("BulbLight turns off."); }
}
public class TubeLight implements ILight
{
public void TurnOn()
{
Console.WriteLine("TubeLight turns on."); }
public void TurnOff()
{
Console.WriteLine("TubeLight turns off."); }
}
//抽象工厂
public interface ICreator{
ILight CreateLight();
}
//具体工厂
public class BulbCreator implements ICreator
{
public ILight CreateLight()
{
return new BulbLight();
}
}
public class TubeCreator implements ICreator
{
public ILight CreateLight()
{
return new TubeLight();
}
}
//客户端调用
static void Main(string[] args)
{
//先给我来个灯泡
ICreator creator = new BulbCreator(); ILight light = creator.CreateLight(); light.TurnOn();
light.TurnOff();
//再来个灯管看看
creator = new TubeCreator(); light = creator.CreateLight(); light.TurnOn(); light.TurnOff();
}
优点：
向用户隐藏具体产品类被实例化这一细节，编写新的具体产品类时无需修改工厂类，自需要增加一个具体工厂类即可
缺点：编写新产品时，需要编写具体产品类，而且需要提供具体的工厂类，增加了系统的复杂度
抽象工厂模式
包含元素：抽象产品、具体产品、抽象工厂、具体工厂
为了了解区别这里我们需要认识两个概念：
产品等级结构: 产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类 有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间 构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。
产品族: 在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级 结构中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机 位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中。
与工厂方法的区别：
工厂方法模式针对的是一个产品等 级结构，而抽象工厂模式则需要面对多个产品等级结构，一个工厂等级结构可以负 责多个不同产品等级结构中的产品对象的创建 。当一个工厂等级结构可以创建出分 属于不同产品等级结构的一个产品族中的所有对象时，抽象工厂模式比工厂方法模 式更为简单、有效率。
两个工厂：一个生产手机，一个生产pad
代码实现：
//苹果接口
public interface Apple
{
void AppleStyle();
}
//三星接口
public interface Sumsung
{
void BangziStyle();
}
//苹果具体商品
public class iphone implements Apple
{
public void AppleStyle()
{
Console.WriteLine("Apple's style: iPhone!"); }
}
public class ipad implements Apple
{
public void AppleStyle()
{
Console.WriteLine("Apple's style: iPad!"); }
}
//三星具体商品
public class note2 implements Sumsung
{
public void BangziStyle()
{
Console.WriteLine("Bangzi's style : Note2!"); }
}
public class Tabs implements Sumsung
{
public void BangziStyle()
{
Console.WriteLine("Bangzi's style : Tab!"); }
}
//抽象工厂
public interface Factory
{
Apple createAppleProduct();
Sumsung createSumsungProduct();
}
//手机工厂
public class Factory_Phone implements Factory {
public Apple createAppleProduct()
{
return new iphone();
}
public Sumsung createSumsungProduct()
{
return new note2();
}
}
//pad工厂
public class Factory_Pad implements Factory {
public Apple createAppleProduct()
{
return new ipad();
}
public Sumsung createSumsungProduct()
{
return new Tabs();
}
}
//调用
public static void Main(string[] args)
{
//采购商要一台iPad和一台Tab
Factory factory = new Factory_Pad();
Apple apple = factory.createAppleProduct(); apple.AppleStyle();
Sumsung sumsung = factory.createSumsungProduct(); sumsung.BangziStyle();
//采购商又要一台iPhone和一台Note2
factory = new Factory_Phone();
apple = factory.createAppleProduct(); apple.AppleStyle();
sumsung = factory.createSumsungProduct(); sumsung.BangziStyle();
Console.ReadKey();
}
优点：
和工厂方法差不多，主要是增加新的具体工厂和产品族标胶方法，例如：apple增加macBook商品，这是只需要增加具体的工厂就行
缺点：如果添加新的产品对象，就需要改动抽象工厂了，例如加个Huawei,
单例模式
懒汉式
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
双重检验锁
public class Singleton {
private volatile static Singleton instance; //声明成 volatile private Singleton (){}
public static Singleton getSingleton() {
if (instance == null) {
synchronized (Singleton.class) { if (instance == null) {
instance = new Singleton();
}
} }
return instance;
}
}
饿汉式
public class Singleton{ //类加载时就初始化
private static final Singleton instance = new Singleton();
private Singleton(){}
public static Singleton getInstance(){
return instance;
}
}
静态内部类
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton(
);
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE; }
}
枚举
public enum EasySingleton{
INSTANCE;
}
总结：
一般来说，单例模式有五种写法:懒汉、饿汉、双重检验锁、静态内部类、枚举。 上述所说都是线程安全的实现，上文中第一种方式线程不安全，排除。
一般情况下直接使用饿汉式就好了，如果明确要求要懒加载(lazy initialization)倾 向于使用静态内部类。如果涉及到反序列化创建对象时会试着使用枚举的方式来实 现单例。
建造者模式
定义：将一个复杂对象的构建与它的表示分离，使得同样的构 建过程可以创建不同的表示。建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类 型和内容就可以构建它们，用户不需要知道内部的具体构建细节。
元素：Builder:抽象建造者
ConcreteBuilder：具体建造者
Director:指挥者
Product:产品角色
代码实现：
//产品角色
public abstract class Computer {
protected int mCpuCore = 1;
protected int mRamSize = 0;
protected String mOs = "Dos";
protected Computer() {
}
// 设置CPU核心数
public abstract void setCPU(int core);
// 设置内存
public abstract void setRAM(int gb);
// 设置操作系统
public abstract void setOs(String os);
@Override
public String toString() {
return "Computer [mCpuCore=" + mCpuCore + ", mRamSize="+ mRamSize + ", mOs=" + mOs + "]";
}
}
//苹果电脑
public class AppleComputer extends Computer {
protected AppleComputer() {
}
@Override
public void setCPU(int core) {
mCpuCore = core;
}
@Override
public void setRAM(int gb) {
mRamSize = gb;
}
@Override
public void setOs(String os) {
mOs = os; }
}
//Builder抽象类
public abstract class Builder {
// 设置CPU核心数
public abstract void buildCPU(int core);
// 设置内存
public abstract void buildRAM(int gb);
// 设置操作系统
public abstract void buildOs(String os);
// 创建Computer
public abstract Computer create();
}
//苹果Builder
public class ApplePCBuilder extends Builder {
private Computer mApplePc = new AppleComputer();
@Override
public void buildCPU(int core) {
mApplePc.setCPU(core);
}
@Override
public void buildRAM(int gb) {
mApplePc.setRAM(gb);
}
@Override
public void buildOs(String os) {
mApplePc.setOs(os);
}
@Override
public Computer create() {
return mApplePc;
}
}
//指挥者
public class Director {
Builder mBuilder = null;
/** *
* @param builder
*/
public Director(Builder builder) {
mBuilder = builder;
}
/**
* 构建对象
*
* @param cpu * @param ram * @param os */
public void construct(int cpu, int ram, String os) { mBuilder.buildCPU(cpu);
mBuilder.buildRAM(ram);
mBuilder.buildOs(os); }
}
//调用
public class Test {
public static void main(String[] args) {
// 构建器
Builder builder = new ApplePCBuilder();
// Director
Director pcDirector = new Director(builder);
// 封装构建过程, 4核, 内存2GB, Mac系统 pcDirector.construct(4, 2, "Mac OS X 10.9.1");
// 构建电脑, 输出相关信息
System.out.println("Computer Info : " + builder.create()
.toString()); }
}
链式
public class AlertDialog {
private final int icon;
private final String message;
private final String title;
private final View.OnClickListener listener;
private AlertDialog(Builder builder) {
icon = builder.icon;
message = builder.message;
title = builder.title;
listener = builder.listener;
}
public static Builder newBuilder() {
return new Builder();
}
public static final class Builder {
private int icon;
private String message;
private String title;
private View.OnClickListener listener;
private Builder() {
}
public Builder icon(int val) {
icon = val;
return this;
}
public Builder message(String val) {
message = val;
return this;
}
public Builder title(String val) {
title = val;
return this;
}
public Builder listener(View.OnClickListener val) {
listener = val;
return this;
}
public AlertDialog build() {
return new AlertDialog(this);
}
}
}
//调用
AlertDialog mDialog = AlertDialog.newBuilder()
.icon(R.mipmap.ic_launcher)
.title("标题")
.message("信息")
.listener(new View.OnClickListener() {
@Override
public void onClick(View v) {
}
}).build();
优点：良好的封装性，用户不知道产品内部的组成，容易扩展
缺点：会产生多余的Builder对象
网友评论