设计模式之装饰模式、工厂方法模式、抽象工厂模式浅析

最新推荐文章于 2020-05-04 06:14:02 发布
最新推荐文章于 2020-05-04 06:14:02 发布
阅读量601 收藏
点赞数
分类专栏： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/undergrowth/article/details/41653613
版权
        
装饰模式： 动态的为对象添加附加功能,提供了一种扩展机制，比继承更具有扩展性

简单工厂：在一个类中处理创建对象的细节

工厂方法模式：
 *   让子类决定初始化什么样的对象，即将类的实例化推迟到子类中进行
 * 工厂方法使用继承，将对象的创建委托给子类进行创建  

 抽象工厂模式：
 *   定义了一个接口，提供了创建依赖对象的家族，但是不指定具体创建什么类型  
 * 抽象工厂使用组合概念，构建对象的家族


1、装饰模式

/**
 * 设计原则： 开放-关闭原则： 对扩展开放，对修改关闭
 * 
 * 装饰模式： 动态的为对象添加附加功能,提供了一种扩展机制，比继承更具有扩展性
 * 
 * 涉及到的概念： 
 * 装饰者(为其他对象添加功能的对象)与被装饰者(被添加功能的对象)
         组合和委托可在运行时动态的加上新的行为
 * 装饰者中拥有被装饰者的超级父类，用于指向被装饰者，当对装饰者进行操作时，被装饰者即委托装饰者执行相关操作
 * 装饰者和被装饰者必须拥有相同的超级父类，用于装饰者替换被装饰者
 * 
 * 
 * 实例： 用于计算不同饮料与配料加起来的总费用 饮料： 咖啡(10元1杯)、茶叶(12元一杯)、奶茶(8元1杯) 配料：
 * 摩卡(4元1份)、蜂蜜(3元1份)、柠檬(2元1份)
 * 
 * 
 * 
 * @author Administrator
 * 
 */


先来看饮料父类

package com.undergrowth.decorate;

/**
 * 设计原则： 开放-关闭原则： 对扩展开放，对修改关闭
 * 
 * 装饰模式： 动态的为对象添加附加功能,提供了一种扩展机制，比继承更具有扩展性
 * 
 * 涉及到的概念： 
 * 装饰者(为其他对象添加功能的对象)与被装饰者(被添加功能的对象)
         组合和委托可在运行时动态的加上新的行为
 * 装饰者中拥有被装饰者的超级父类，用于指向被装饰者，当对装饰者进行操作时，被装饰者即委托装饰者执行相关操作
 * 装饰者和被装饰者必须拥有相同的超级父类，用于装饰者替换被装饰者
 * 
 * 
 * 实例： 用于计算不同饮料与配料加起来的总费用 饮料： 咖啡(10元1杯)、茶叶(12元一杯)、奶茶(8元1杯) 配料：
 * 摩卡(4元1份)、蜂蜜(3元1份)、柠檬(2元1份)
 * 
 * 
 * 
 * @author Administrator
 * 
 */
public abstract class Baverage {
	/**
	 * 用于对饮料的描述
	 */
	public String description;

	/**
	 * 用于计算不同饮料的价钱
	 * 
	 * @return
	 */
	public abstract double cost();

	public String getDescription() {
		return description;
	}

}

用于用于子类重写的cost方法

接下来是两种饮料 咖啡和茶叶

package com.undergrowth.decorate;

public class Coffee extends Baverage {

	public Coffee(){
		description=Coffee.class.getSimpleName();
	}
	
	@Override
	public double cost() {
		// TODO Auto-generated method stub
		return Price.CoffeePrice;
	}

}


package com.undergrowth.decorate;

public class Tea extends Baverage {

	public Tea(){
		description=Tea.class.getSimpleName();
	}
	
	@Override
	public double cost() {
		// TODO Auto-generated method stub
		return Price.TeaPrice;
	}

}


当饮料构建完后  接下来构建配料  配料的父类

package com.undergrowth.decorate;

public abstract class IngredientBaverage extends Baverage {

	public abstract String getDescription();
	

}

getDescription方法抽象的原因 是为了获得更为详细的描述

接下来是摩卡和蜂蜜的两种配料

package com.undergrowth.decorate;

public class MochaIngredient extends IngredientBaverage {
    
	Baverage baverage;
	
	public MochaIngredient(Baverage baverage){
		this.baverage=baverage;
	}
	
	
	
	@Override
	public String getDescription() {
		// TODO Auto-generated method stub
		return MochaIngredient.class.getSimpleName()+"\t"+baverage.getDescription();
	}

	@Override
	public double cost() {
		// TODO Auto-generated method stub
		return Price.MochaPrice+baverage.cost();
	}

}



package com.undergrowth.decorate;

public class HoneyIngredient extends IngredientBaverage {

	Baverage baverage;
	
	public HoneyIngredient(Baverage baverage)
	{
		this.baverage=baverage;
	}
	
	@Override
	public String getDescription() {
		// TODO Auto-generated method stub
		return HoneyIngredient.class.getSimpleName()+"\t"+baverage.getDescription();
	}

	@Override
	public double cost() {
		// TODO Auto-generated method stub
		return Price.HoneyPrice+baverage.cost();
	}

}


最后一个 价格常量类

package com.undergrowth.decorate;

public class Price {
	public static final double CoffeePrice=10;
	public static final double TeaPrice=12;
	public static final double MochaPrice=4;
	public static final double HoneyPrice=3;
}


测试类

package com.undergrowth.decorate.test;

import static org.junit.Assert.*;

import org.junit.Test;

import com.undergrowth.decorate.Coffee;
import com.undergrowth.decorate.HoneyIngredient;
import com.undergrowth.decorate.MochaIngredient;
import com.undergrowth.decorate.Tea;

import com.undergrowth.decorate.Baverage;

public class MochaIngredientTest {

	@Test
	public void test() {
		//现在我要2份摩卡的咖啡 算算多少钱
		Baverage baverage=new Coffee();
		baverage=new MochaIngredient(baverage);
		baverage=new MochaIngredient(baverage);
		System.out.println(baverage.getDescription()+"\t价格:"+baverage.cost());
	    
		//一份摩卡 一份蜂蜜的茶叶
		baverage=new Tea();
		baverage=new MochaIngredient(baverage);
		baverage=new HoneyIngredient(baverage);
		System.out.println(baverage.getDescription()+"\t价格:"+baverage.cost());
	}

}

结果输出 

MochaIngredient	MochaIngredient	Coffee	价格:18.0
HoneyIngredient	MochaIngredient	Tea	价格:19.0


上面即使装饰模式的实例    在java类库中 装饰模式也用于很多地方  如IO流 集合

  再来看一个io流中的例子

字符输入流装饰者  用于对输入的字符进行转换 将输入的字符全部转为大写

package com.undergrowth.decorate.util;

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
/**
 * 字符输入流装饰者  用于对输入的字符进行转换 将输入的字符全部转为大写
 * @author Administrator
 *
 */
public class CharacterInputStreamDecorate extends FilterInputStream {

	protected CharacterInputStreamDecorate(InputStream in) {
		super(in);
		// TODO Auto-generated constructor stub
	}

	@Override
	public int read() throws IOException {
		// TODO Auto-generated method stub
		int c=super.read();
		return (c==-1)?c:Character.toUpperCase(c);
	}

	@Override
	public int read(byte[] b, int off, int len) throws IOException {
		// TODO Auto-generated method stub
		int result=super.read(b, off, len);
		if(result!=-1){
			for (int i = off; i < off+result; i++) {
				b[i]=(byte) Character.toUpperCase(b[i]);
			}
		}
		return result;
	}
	
	

}


测试类

package com.undergrowth.decorate.util;

import static org.junit.Assert.*;

import java.awt.im.InputContext;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

import org.junit.Test;

public class CharacterInputStreamDecorateTest {

	@Test
	public void test() {
		int c;
		try {
			String pathname="data.txt";
			InputStream is=new CharacterInputStreamDecorate(new BufferedInputStream(new FileInputStream(new File(CharacterInputStreamDecorateTest.class.getResource(pathname).getFile()))));
			while ((c=is.read())>=0) {
				System.out.print((char)c);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}

}
测试数据： 

what's you want from learn design pattern?
may be,it is something...

结果: 

WHAT'S YOU WANT FROM LEARN DESIGN PATTERN?
MAY BE,IT IS SOMETHING...



2、简单工厂、工厂方法模式、抽象工厂模式

/**
 * 设计原则：
 * 		依赖倒置原则：依赖于抽象，而非具体实现
 * 
 * 所有的工厂都是用于封装对象的创建
 * 用于将客户程序与具体应用解耦
 * 
 * 简单工厂：在一个类中处理创建对象的细节
 * 
 * 工厂方法模式：
 *   让子类决定初始化什么样的对象，即将类的实例化推迟到子类中进行
 * 工厂方法使用继承，将对象的创建委托给子类进行创建  
 *   
 * 抽象工厂模式：
 *   定义了一个接口，提供了创建依赖对象的家族，但是不指定具体创建什么类型  
 * 抽象工厂使用组合概念，构建对象的家族 
 * 
 * 
 * 实例：
 * 披萨店的加盟模式
 *    披萨店可以有很多加盟店
 *     不同的加盟店做的披萨可以口味不同 但是制作披萨的流程与原料都必须是一致的
 * @author Administrator
 *
 */

先来看看最简单的简单工厂 

package com.undergrowth.factory;

/**
 * 设计原则：
 * 		依赖倒置原则：依赖于抽象，而非具体实现
 * 
 * 所有的工厂都是用于封装对象的创建
 * 用于将客户程序与具体应用解耦
 * 
 * 简单工厂：在一个类中处理创建对象的细节
 * 
 * 工厂方法模式：
 *   让子类决定初始化什么样的对象，即将类的实例化推迟到子类中进行
 * 工厂方法使用继承，将对象的创建委托给子类进行创建  
 *   
 * 抽象工厂模式：
 *   定义了一个接口，提供了创建依赖对象的家族，但是不指定具体创建什么类型  
 * 抽象工厂使用组合概念，构建对象的家族 
 * 
 * 
 * 实例：
 * 披萨店的加盟模式
 *    披萨店可以有很多加盟店
 *     不同的加盟店做的披萨可以口味不同 但是制作披萨的流程与原料都必须是一致的
 * @author Administrator
 *
 */

public  class PizzaStore {
	
	/**
	 * 定披萨
	 */
	public void orderPizza(String type){
		
		//简单工厂方式让我们还是依赖 于一个特定的实现  我们需要依赖于抽象
		Pizza pizza=PizzaSimpleFactory.createPizza(type);
		
		//Pizza pizza=createPizza(type);
		//保证制作披萨的流程一致
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
	}
	/**
	 * 使用工厂方法模式  将对象的创建推迟到子类中
	 * @return
	 */
	//public abstract Pizza createPizza(String type);
	
}


将对象的创建放置在一个类中

package com.undergrowth.factory;


/**
 * 简单工厂 创建披萨
 * @author Administrator
 *
 */
public class PizzaSimpleFactory {
	
	public static Pizza createPizza(String type){
		Pizza pizza=null;
		switch (type) {
		case "NYCheese":
			pizza=new NYCheesePizza();
			break;
		default:
			pizza=new CaliforniaCheesePizza();
			break;
		}
		return pizza;
	}
	
}


但是简单工厂让让我们的代码  还是依赖与实现 而非抽象 为了达到这一原则  使用工厂方法模式  让子类负责创建对象 让对象的创建与逻辑代码解耦

修改披萨工厂类 如下

package com.undergrowth.factory;

/**
 * 设计原则：
 * 		依赖倒置原则：依赖于抽象，而非具体实现
 * 
 * 所有的工厂都是用于封装对象的创建
 * 用于将客户程序与具体应用解耦
 * 
 * 简单工厂：在一个类中处理创建对象的细节
 * 
 * 工厂方法模式：
 *   让子类决定初始化什么样的对象，即将类的实例化推迟到子类中进行
 * 工厂方法使用继承，将对象的创建委托给子类进行创建  
 *   
 * 抽象工厂模式：
 *   定义了一个接口，提供了创建依赖对象的家族，但是不指定具体创建什么类型  
 * 抽象工厂使用组合概念，构建对象的家族 
 * 
 * 
 * 实例：
 * 披萨店的加盟模式
 *    披萨店可以有很多加盟店
 *     不同的加盟店做的披萨可以口味不同 但是制作披萨的流程与原料都必须是一致的
 * @author Administrator
 *
 */

public abstract class PizzaStore {
	
	/**
	 * 定披萨
	 */
	public void orderPizza(String type){
		
		//简单工厂方式让我们还是依赖 于一个特定的实现  我们需要依赖于抽象
		//Pizza pizza=PizzaSimpleFactory.createPizza(type);
		
		Pizza pizza=createPizza(type);
		//保证制作披萨的流程一致
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
	}
	/**
	 * 使用工厂方法模式  将对象的创建推迟到子类中
	 * @return
	 */
	public abstract Pizza createPizza(String type);
	
}


纽约的披萨工厂

package com.undergrowth.factory;

public class NYPizzaStore extends PizzaStore {

	@Override
	public Pizza createPizza(String type) {
		// TODO Auto-generated method stub
		Pizza pizza=null;
		if("Cheese".equals(type))
			pizza=new NYCheesePizza();
		else if("Clam".equals(type)){
			pizza=new NYClamPizza();
		}
		return pizza;
	}

}

哈喇披萨

package com.undergrowth.factory;

/**
 * 纽约披萨
 * @author Administrator
 *
 */
public class NYClamPizza extends Pizza {
	public NYClamPizza(){
		setName(NYClamPizza.class.getSimpleName());
	}

	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		System.out.println(NYClamPizza.class.getSimpleName()+"\t准备做披萨...");
	}
}



测试类 

package com.undergrowth.factory;

import static org.junit.Assert.*;

import org.junit.Test;

public class PizzaStoreTest {

	@Test
	public void test() {
		PizzaStore ps=null;
		//简单工厂测试
		/*ps=new PizzaStore();
		ps.orderPizza("NYCheese");*/
		
		//工厂方法模式
		ps=new NYPizzaStore();
		ps.orderPizza("Clam");
		
		//抽象工厂模式
	    //创建披萨的原料从抽象工厂中获取
		/*ps=new NYPizzaStore();
		ps.orderPizza("Cheese");*/
	}

}

结果 

NYClamPizza	准备做披萨...
NYClamPizza	对披萨进行烘烤
NYClamPizza	对披萨进行切片
NYClamPizza	对披萨进行装盒



当我为了确保原料一致时，我做披萨产生的原料都从原料工厂取 这样就能保证披萨的原料是一致的了  使用抽象工厂解决此问题

皮萨类

package com.undergrowth.factory;

/**
 * 披萨 用于构建披萨
 * @author Administrator
 *
 */
public  abstract class Pizza {
	private String name;
	 Dough dough;
	 Cheese cheese;
	 Clam clam;
	/**
	 * 构建披萨的原料从抽象工厂中获取
	 */
	public abstract void prepare();
	public void bake(){
		System.out.println(getName()+"\t"+"对披萨进行烘烤");
	}
	public void cut(){
		System.out.println(getName()+"\t"+"对披萨进行切片");
	}
	public void box(){
		System.out.println(getName()+"\t"+"对披萨进行装盒");
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	
}

纽约奶酪披萨 

package com.undergrowth.factory;

/**
 * 纽约披萨
 * @author Administrator
 *
 */
public class NYCheesePizza extends Pizza {
	
	IngredientFactory ingredientFactory=new NYIngredientFactory();
	public NYCheesePizza(){
		setName(NYCheesePizza.class.getSimpleName());
	}
	

	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		System.out.println("开始准备做披萨");
		System.out.println("面粉:"+ingredientFactory.createDough());
		System.out.println("奶酪:"+ingredientFactory.createCheese());
		System.out.println("哈喇:"+ingredientFactory.createClam());
	}
}


原料工厂

package com.undergrowth.factory;

public interface IngredientFactory {
	public Dough createDough();
	public Clam createClam();
	public Cheese createCheese();
}

纽约原料工厂 

package com.undergrowth.factory;

public class NYIngredientFactory implements IngredientFactory {

	@Override
	public Dough createDough() {
		// TODO Auto-generated method stub
		return new ThinDough();
	}

	@Override
	public Clam createClam() {
		// TODO Auto-generated method stub
		return new FreshClam();
	}

	@Override
	public Cheese createCheese() {
		// TODO Auto-generated method stub
		return new SweetCheese();
	}

}
相关的原料接口与实现类 

package com.undergrowth.factory;

public interface Dough {
	
}

package com.undergrowth.factory;

public class ThinDough implements Dough {

	@Override
	public String toString() {
		return "ThinDough [toString()=" + super.toString() + "]";
	}
	
}


package com.undergrowth.factory;

public interface Clam {

}


package com.undergrowth.factory;

public class FreshClam implements Clam {

	@Override
	public String toString() {
		return "FreshClam [toString()=" + super.toString() + "]";
	}
	
}



package com.undergrowth.factory;

public interface Cheese {

}


package com.undergrowth.factory;

public class SweetCheese implements Cheese {

	@Override
	public String toString() {
		return "SweetCheese [toString()=" + super.toString() + "]";
	}
	
}

测试类 

package com.undergrowth.factory;

import static org.junit.Assert.*;

import org.junit.Test;

public class PizzaStoreTest {

	@Test
	public void test() {
		PizzaStore ps=null;
		//简单工厂测试
		/*ps=new PizzaStore();
		ps.orderPizza("NYCheese");*/
		
		//工厂方法模式
		/*ps=new NYPizzaStore();
		ps.orderPizza("Clam");*/
		
		//抽象工厂模式
	    //创建披萨的原料从抽象工厂中获取
		ps=new NYPizzaStore();
		ps.orderPizza("Cheese");
	}

}

结果 

开始准备做披萨
面粉:ThinDough [toString()=com.undergrowth.factory.ThinDough@1e064c]
奶酪:SweetCheese [toString()=com.undergrowth.factory.SweetCheese@328c40]
哈喇:FreshClam [toString()=com.undergrowth.factory.FreshClam@3cfaab]
NYCheesePizza	对披萨进行烘烤
NYCheesePizza	对披萨进行切片
NYCheesePizza	对披萨进行装盒


上面即使简单工厂 工厂方法  抽象工厂的简单实现

     简单工厂----使用简单，但使逻辑代码依赖于具体实现

   工厂方法---时逻辑代码依赖于抽象，让子类负责对象的创建

  抽象工厂----加强版的工厂方法，可用于创建依赖对象的家族



记录学习的脚步

undergrowth
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java设计模式之抽象工厂模式.docx
10-25
一个具体工厂创建一个产品族，一个产品族是不同系列产品的组合，产品的创建的逻辑分在在每个具体工厂类...如果没有应对“多系列对象创建”的需求变化，则没有必要使用抽象工厂模式，这时候使用简单的静态工厂完全可以。
【C# · 设计模式 · 创建型模式】工厂方法 / 抽象工厂
stuXuan的博客
08-04 443
用渐进式的几个例子描述工厂模式的使用场景和解决的问题。
【大话设计模式】--建造者模式VS装饰模式/抽象工厂
向阳而生
02-17 1139
装饰模式？建造者模式？ 建造者模式（Builder）： 趣味理解：MM最爱听的就是“我爱你”这句话了，见到不同地方的MM，要能够用她们的方言跟她说这句话哦，我有一个多钟语言翻译机，上面每种语言都有一个按键，见到MM，我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了饿，国外的MM也可以轻松搞定，这就是我的“我爱你”Builde 定义：将一个复杂对象的构...
学习笔记：结构型之装饰模式，创造型模式之工厂模式、抽象工厂模式
weixin_44217000的博客
05-04 233
目录装饰模式工厂模式抽象工厂模式 装饰模式 工厂模式 抽象工厂模式
设计模式（二）（装饰者模式、工厂方法模式、抽象工厂模式）
吃四碗饭的嘤嘤怪的博客
10-19 4223
三：装饰者模式 装饰者模式动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。 意图：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。 主要解决：一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。 何时使用：在不想增加很多子类的情况下扩展类。 如何解决：将具体功能职...
设计模式分析之抽象工厂
11-19
抽象工厂设计模式原理分析 案例case 实例运行
c++设计模式-抽象工厂方法
06-04
c++设计模式-创建型-抽象工厂方法-最简单源码-qt工程
23种设计模式之抽象工厂模式Java示例代码
最新发布
04-16
本文介绍了抽象工厂模式的定义、使用场景、主要角色以及相应的类图，并提供了Java示例代码以帮助读者更好地理解该模式的实现方法。抽象工厂模式为创建一组相关或相互依赖的对象提供了一个接口，而不需要指定它们的...
PHP设计模式之抽象工厂模式实例分析
10-17
主要介绍了PHP设计模式之抽象工厂模式,结合实例形式分析了php抽象工厂模式的概念、原理、使用方法及相关操作注意事项,需要的朋友可以参考下
简单工厂、工厂方法、抽象工厂
核桃的博客——JavaWeb技术分享
07-09 553
结合简单示例和UML图，讲解工厂模式简单原理。   一、引子 话说十年前，有一个爆发户，他家有三辆汽车（Benz（奔驰）、Bmw（宝马）、Audi（奥迪）），还雇了司机为他开车。不过，爆发户坐车时总是这样：上Benz车后跟司机说“开奔驰车！”，坐上Bmw后他说“开宝马车！”，坐上 Audi后他说“开奥迪车！”。 你一定说：这人有病！直接说开车不就行了？！而当把这个爆发户的行为放
设计模式之复合模式和总结篇
undergrowth的专栏
12-27 1775
/** * * 复合模式-->在一个解决方案中结合两个或者多个模式，以解决一般或者重复发生的问题 * 模式-->是在某种情境下，针对某种问题的某种解决方案 * 模式类目完整的描述设计模式 * 三次规则：当你的模式在真实世界中的三个方案中成功的运用 * * OO原则 * 封装变化 * 多用组合 少用继承 * 针对接口编程 而非实现 * 为交互对象之间的松耦合设计而努力
设计模式之迭代器模式浅析
undergrowth的专栏
12-16 645
迭代器提供一种方式遍历集合，而又无需暴露集合的实现 /** * 设计原则： * 单一原则：一个类应该只有一个引起变化的原因 * 内聚--用来衡量一个类或者模块紧密的达到单一目的或责任 * 高内聚--表示一个类或者模块只支持一个/一组相关功能 * * 迭代器模式： * 提供一种顺序访问聚合对象元素的方法，而又不暴露其内部元素 * 迭代器将遍历聚合对象的任务封装到一
设计模式之策略模式、观察者模式浅析
undergrowth的专栏
11-29 577
策略模式：将算法簇封装起来，使使用算法的客体和算法之间相互独立 设计原则：1、针对接口编程，而非实现 2、多用组合，少用继承 3、封装变化 观察者模式： 当交互对象之间存在一对多的依赖，一的一方状态一旦发生改变，多的一方即会收到通知，进行状态的更新 对应的即是： 主题(1)与观察者(n) 或者说是可观察者(1)与观察者(n) 主题的作用是 注册、移除、通知观察者 观察者的作用是接收到特定主题的通知，进行状态或者数据的更新 设计原则：为交互对象之间的松耦合度而
设计模式之单例模式、命令模式浅析
undergrowth的专栏
12-04 536
/** * 单例模式： * 确保类只有一个实例，并提供一个全局的访问点 * * 经典的单例模式 * 1、将构造器私有化 * 2、提供一个私有的类的对象的静态成员变量 * 3、提供一个静态的公有的获取对象的方法 * * 经典单例模式中 存在一个问题 当在多线程的环境中 可能会有多个ClassicSingleton的对象 * 当然 可以在getInstance上加上sync
设计模式之适配器模式、外观模式浅析
undergrowth的专栏
12-08 528
外观模式强调统一和简化接口，而适配器模式强调转换接口 1、适配器模式 /** * * 适配器模式 * 将一种接口转换为用户所期望的另一种接口 * * 对象适配器--使用组合拥有被适配者接口，使用实现实现目的接口 * 类适配器--使用继承拥有被适配者与目的类 * * 目的接口：用户所期望的接口 * 被适配器接口：待转换的接口 * 适配器：实现目的
设计模式之组合模式浅析
undergrowth的专栏
12-17 501
/** * * * 组合模式: 可以使组合对象形成树形结构，以表现出整体/部分的结构，并提供一致的方法访问整体和局部 * 组合结构内任意对象称为组件，组件可以是组合，也可以是叶节点 * 客户可以将对象的集合以及个别的对象一视同仁 * * 运用了递归迭代的思想 * * 外部迭代器必须维护它在遍历中的位置，以便外部客户可以通过调用hasNext和next方法来驱动遍历
设计模式之代理模式浅析
undergrowth的专栏
12-21 499
/** * 代理模式： * 为另一个对象提供一个占位符或者替身，以控制对这个对象的访问 * * 按照控制方式的不同： * 远程代理-->控制访问远程对象(不在同一个JVM的对象) * 虚拟代理-->控制访问大开销资源的对象(网络或者IO对象) * 保护代理-->基于权限控制对资源的访问(不同的权限，对资源的访问层次不同) * 缓存代理-->为开销大的运算结果提
软件设计模式工厂方法抽象工厂组合实例
11-30
以下是一个软件设计模式工厂方法抽象工厂组合实例： ```java // 抽象产品接口 interface Product { void show(); } // 具体产品类A class ConcreteProductA implements Product { @Override public void show()...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值