码迷,mamicode.com
首页 > 编程语言 > 详细

java之 ------ 几种常见的简单设计模式

时间:2015-08-21 00:10:59      阅读:298      评论:0      收藏:0      [点我收藏+]

标签:java设计模式   单例模式   工厂模式   值对象模式   装饰模式   

前言:

设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。用于解决特定环境下、重复出现的特定问题的解决方案。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式是软件工程的基石,如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题,每种模式在现在中都有相应的原理来与之对应,每一个模式描述了一个在我们周围不断重复发生的问题,以及该问题的核心解决方案,这也是它能被广泛应用的原因。(引用---点击打开链接


一、单例模式(Singleton Pattern

a、单例模式:是一种常见的设计模式。为了保证一个类在内存中只能有一个对象。

思路:1、如果其他程序能够随意用new创建该类对象,那么就无法控制个数。因此,不让其他程序用new创建该类的对象。
    2、既然不让其他程序new该类对象,那么该类在自己内部就要创建一个对象,否则该类就永远无法创建对象了。
    3、该类将创建的对象对外(整个系统)提供,让其他程序获取并使用。

步骤:1、将该类中的构造函数私有化。
    2、在本类中创建一个本类对象。
    3、定义一个方法,返回值类型是本类类型。让其他程序通过该方法就可以获取到该类对象。

单例模式中又有:饿汉式和懒汉式两种

1、饿汉式:不管你需不需要,都在类内部直接先生成一个对象。因为构造方法为私有的,所以外面无法new新的对象,只能通过getInstance来获得这个唯一的对象,从而实现单例模式

/*饿汉式*/
public class Single {
	private static final Single s=new Single();
	private Single(){
	}
	public static Single getInstance(){
		return s;
	}
}
2、懒汉式:与饿汉式不同之处在于,不是直接生成一个对象,而是在需要对象是才会生成,也就是只有当调用getInstance这个方法是才会产生这个唯一对象。(也可以说是单例的延迟加载方式)

/*懒汉式*/
public class Single2 {
	private static Single2 s;
	private Single2(){
	}
	public static Single2 getInstance(){
		if(s==null){
			s = new Single2();
		}
		return s;
	}
}
这个类可以满足基本要求,但是,像这样毫无线程安全保护的类,如果我们把它放入多线程的环境下,肯定就会出现问题了(问题就是假如有多个线程同时到达if(s==null)时,这个条件都成立,那么就会产生多个对象了,就违背了我们的本意),如何解决?我们首先会想到对getInstance方法加synchronized关键字。所以该为下面这句即可。

public static synchronized Single2 getInstance();
但是,synchronized关键字锁住的是这个对象,这样的用法,在性能上会有所下降,因为每次调用getInstance(),都要对对象上锁,事实上,只有在第一次创建对象的时候需要加锁,之后就不需要了,所以,这个地方需要改进:
public static synchronized Single2 getInstance(){
		if(s==null){
			synchronized (s) {  
                <span style="white-space:pre">		</span>if (s == null) {  
                   <span style="white-space:pre">			</span> s = new Single2();  
                <span style="white-space:pre">		</span>}  
            <span style="white-space:pre">		</span>}  
		}
		return s;
}
看上去写的很好,但在自己运行时,就会发现还是有错误,虽然知道是线程的原因,却没有深究。大概知道那么回事。看看大神的准确解答:在Java指令中创建对象和赋值操作是分开进行的,也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序,也就是说有可能JVM会为新的Singleton实例分配空间,然后直接赋值给instance成员,然后再去初始化这个Singleton实例。这样就可能出错了。

b、单例变形-----多例     (“单例+缓存”技术)

★ 缓存在单例中的使用

缓存在编程中使用很频繁,有着非常重要的作用,它能够帮助程序实现以空间换取时间,通常被设计成整个应用程序所共享的一个空间,现要求实现一个用缓存存放单例对象的类。
说明:该缓存中可以存放多个该类对象,每个对象以一个key值标识,key值相同时所访问的是同一个单例对象。

import java.util.HashMap;
import java.util.Map;
public class A {
	//定义一个缓存(集合),用来存放数据的容器
	private static Map<String,A> map = new HashMap<String,A>();
	public static A getInstance(String key){
		A a = map.get(key);
		//判断a是否存在,不存在则是null
		if(a==null){
			a = new A();//新建一个对象
			map.put(key, a);//把新对象放入缓存
		}
		return a;
	}
	
}
★ 单例变形——多例模式 (“单例+缓存+控制实例个数”技术)

把上面缓存的单例实现,做成一个能够控制对象个数的共享空间,供整个应用程序使用。在缓存中维护指定个数的对象,每个对象的key值由该类内部指定,有外部请求时直接返回其中一个对象出去。
说明:相当于维护一个指定数量的对象池,当请求个数超过控制的总数时,开始循环重复使用 。

import java.util.HashMap;
import java.util.Map;
public class Multiple {
	private static Map<Integer,Multiple> map = new HashMap<Integer,Multiple>();
	private static int num=1;
	private static int count=3;//控制实例的个数:3
	public static Multiple getInstance(){
		Multiple m = map.get(num);
		if(m==null){
			m = new Multiple();
			map.put(num, m);
		}
		num++;
		//如果num超过所控制的个数,则重新设为1,以进行循环重复使用缓存中的对象
		if(num>count){
			num=1;
		}
		return m;
	}
}

二、工厂模式(Factory Pattern

工厂模式:Java程序开发讲究面向接口编程,通过建立一个工厂类,隐藏具体的实现类。

首先创建公共接口:

public interface Api {
	public abstract String t1();
}
然后创建实现类:

public class Impl implements Api {
	@Override
	public String t1() {
		return "11111111111111";
	}
}
public class Impl2 implements Api {
	@Override
	public String t1() {
		return "222222";
	}
}
最后创建工厂类:

public class DepFactory {
	public static Api createApi(){
		return new Impl2();//通过配置文件+类反射,让我们的程序依赖字符串
	}
}
测试:

public class Client {
	public static void main(String[] args) {
		Api obj = DepFactory.createApi();//new Impl();
		String str = obj.t1();
		System.out.println(str);
	}

}
结果:222222

三、值对象模式(Value Object Pattern

值对象模式:简单的说就是封装数据,方便各个模块之间的数据的交流。

★ 基本的编写步骤:

1、写一个类,实现可序列化(如果以后数据是往数据库里存的,那么可以不序列化,节省资源)

2、私有化所有属性,保持一个默认构造方法(public无参)

3、为每个属性提供get()、set()方法(如果是boolean型变量,最好把get改成is)

4、推荐覆盖实现equals()、hashCode()和toString()方法

public class UserModel implements Serializable {
	private String id,name,address;
	private boolean man;
	public UserModel(String name){
		this.name = name;
	}
	public UserModel(){
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public boolean isMan() {
		return man;
	}
	public void setMan(boolean man) {
		this.man = man;
	}
	
	//hashCode和equals一般只用“主键”来生成
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((id == null) ? 0 : id.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		UserModel other = (UserModel) obj;
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		return true;
	}
	@Override
	public String toString() {
		return "UserModel [id=" + id + ", name=" + name + ", address="
				+ address + ", man=" + man + "]";
	}
	
}

四、装饰模式(Decorator Pattern

装饰模式:在不必改变原类文件和使用继承的情况下,动态地扩展一个对象的功能。它是通过创建一个包装对象,也就是装饰来包裹真实的对象。

例:写一个MyBufferedReader类,使它能够对字符流(如FileReader、InputStreamReader和PipedReader等)进行功能增强:

(1) 提供带缓冲的myRead()方法,对原有的read()方法进行增速;

(2)提供一个能够每次读取一行字符的myReadLine()方法。

思路:一般要实现一个类的功能就想到继承这个类。但是这里要实现多个类的功能,而继承只能继承一个。那就不得不写多个类了,这样就会显得臃肿。

另一种方法就是封装,不用继承,但是缺点和上面一样。

所以想到把二者结合起来,从而达到要求。也就是装饰模式。

import java.io.IOException;
import java.io.Reader;

public class MyBufferedReader extends Reader{ //※※※让加强类融入到体系中
	private Reader r;//封装
	private char[] buf = new char[1024];
	private int count=0;//记录当前缓冲区中字符的个数
	private int pos=0;//数组元素的下标,当前所读的位置
	
	public MyBufferedReader(Reader r){
		this.r = r;
	}
	
	public int myRead() throws IOException{
		if(count==0){
			count = r.read(buf);
			pos=0;
		}
		if(count==-1){
			return -1;
		}
		char ch = buf[pos];
		pos++;
		count--;
		return ch;
	}
	
	public String myReadLine() throws IOException{
		StringBuilder sb = new StringBuilder();
		int ch=0;
		while((ch=myRead())!=-1){
			if(ch=='\r'){
				continue;
			}
			if(ch=='\n'){
				return sb.toString();
			}
			
			sb.append((char)ch);
		}
		if(sb.length()!=0)
		   return sb.toString();
		return null;
	}
	
	
	public void close() throws IOException{
		r.close();
	}

	@Override
	public int read(char[] cbuf, int off, int len) throws IOException {
		
		return 0;
	}
}








版权声明:本文为博主原创文章,未经博主允许不得转载。

java之 ------ 几种常见的简单设计模式

标签:java设计模式   单例模式   工厂模式   值对象模式   装饰模式   

原文地址:http://blog.csdn.net/u011479875/article/details/47816985

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!