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

看上去写的非常好。但在自己执行时，就会发现还是有错误，尽管知道是线程的原因，却没有深究。

大概知道那么回事。看看大神的准确解答：在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 map = new HashMap();

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 map = new HashMap();

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;

}

}