您的位置：首页 > 其它

设计模式九、十堂课

2016-03-28 18:28 363 查看

1单例模式（Singleton）
1）单例是指只拥有一个实例对象(全局可见)的类

2）问题解决

A.确保一个类只有一个或有限数量的实例对象

B.不同场景共享同一个实例对象

3）提供一个私有的构造方法，定义一个公共的静态方法控制创建的实例对象

4）缺点

eg Logger（昂贵对象）：无状态，占用大量存储空间

public class Logger {
private static Logger logger;
private Logger(){
System.out.println("Logger 实例化");
};
public static Logger getInstance(){
if(null == logger) //多线程不安全
logger = new Logger();
System.out.println("获取logger");
return logger;
}
}

public class Client {
public static void main(String []arg){
Logger g1 = Logger.getInstance();
Logger g2 = Logger.getInstance();
if(g1 == g2)
System.out.println("对象一致");
}
}

输出：

Logger 实例化
获取logger
获取logger
对象一致

解决多线程不安全的问题
（1）饿汉式: 类加载时创建对象
public class Logger {
private static Logger logger = new Logger();
private Logger(){
System.out.println("Logger 实例化");
};
public static Logger getInstance(){
System.out.println("获取logger");
return logger;
}
}

（2）懒汉式
public class Logger {
private static Logger logger;
private Logger(){
System.out.println("Logger 实例化");
};
synchronized public static Logger getInstance(){
if(null == logger)
logger = new Logger();
System.out.println("获取logger");
return logger;
}
}

改进版，双重锁定检查
public class Logger {
private static Logger logger;
private Logger(){
System.out.println("Logger 实例化");
};
public static Logger getInstance(){
if(null == logger){
synchronized (Logger.class) {
if(null == logger)
logger = new Logger();
}
}
System.out.p
4000
rintln("获取logger");
return logger;
}
}

(3)IoDH技术静态内部类
public class Logger {
private Logger(){
System.out.println("Logger 实例化");
};
private static class HolderClass{
private final static Logger logger = new Logger();
}
public static Logger getInstance(){
return HolderClass.logger;
}
}

2. The prototype pattern原型模式

1）原型是指一种对象，这种对象包括clone方法去拷贝类似的对象，用于减小类的数量

2）问题解决

A．如何减少类的数量并共享相似的行为和关系

3）解决

定义一个类代替相似的类（共享相似的行为和关系）。保存该类的原型，用该原型的clone方法生成新对象

public class C implements Cloneable{

           @override

           publicObject clone(){

                     ……

                    return (C) super.clone();

}

}

C o=new C();

C o1=o.clone();

C o2=o.clone();

C o3=o.clone();

class User
implements Cloneable{
    public Object clone(){
        User object = null;
        try{
             object = (User)super.clone();
        }catch (CloneNotSupportedException e) {
             e.printStackTrace();
        }
       return object;
    }
}
class Prototype
implements Cloneable{
    private String
name;
    private User
user;
    public Prototype(String name){
        this.name = name;
    }
    public Prototype clone(){
        Prototype object = null;
        try{
             object = (Prototype)super.clone();
             object.user=(User)this.user.clone();//深拷贝
        }catch (CloneNotSupportedException e) {
             e.printStackTrace();
        }
       return object;
    }
    public String toString(){
        return
name;
    }
}

2.flyweight 享元模式

1）享元：被不同客户端共享的对象

2）解决问题

A.减少实例的创建

B.共享实例，提高效率和资源利用率

3）解决

（1）抽象享元(Flyweight)角色：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。

（2）具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定出的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。

（3）复合享元(ConcreteCompositeFlyweight)角色：复合享元角色所代表的对象是不可以共享的，但是一个复合享元对象可以分解成为多个本身是单纯享元对象的组合。复合享元角色又称作不可共享的享元对象。

（4）享元工厂(FlyweightFactory)角色：本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。

public interface Flyweight {
 public
void operation(String state);
}
public class ConcreteFlyweightimplements Flyweight {
 private Character
intrinsicState = null;
 public ConcreteFlyweight(Characterstate){
 this.intrinsicState = state;
 }
 @Override
 public
void operation(String state) {
 System.out.println("Intrinsic State = " +this.intrinsicState);
 System.out.println("Extrinsic State = " + state);
 }
}
public classConcreteCompositeFlyweightimplements Flyweight {

 privateMap<Character,Flyweight>files =
new HashMap<Character,Flyweight>();
 public
void add(Character key , Flyweightfly){
 files.put(key,fly);
 }
 @Override
 public
void operation(String state) {
 Flyweight fly = null;
 for(Object o :
files.keySet()){
 fly = files.get(o);
 fly.operation(state);
 }
 }
}

public class FlyweightFactory {
 privateMap<Character,Flyweight>files =
new HashMap<Character,Flyweight>();
 public Flyweightfactory(List<Character> compositeState){
 ConcreteCompositeFlyweight compositeFly =
new ConcreteCompositeFlyweight();
 for(Character state :compositeState){
 compositeFly.add(state,this.factory(state));
 }
 return compositeFly;
 }
 public Flyweight factory(Characterstate){
 Flyweight fly = files.get(state);
 if(fly ==
null){
 fly = new ConcreteFlyweight(state);
 files.put(state, fly);
 }
 return fly;
 }
}
public class Client {
 public
static void main(String[] args) {
 List<Character> compositeState =
new ArrayList<Character>();
 compositeState.add('a');
 compositeState.add('b');
 FlyweightFactoryflyFactory =
new FlyweightFactory();
 FlyweightcompositeFly1 = flyFactory.factory(compositeState);
 FlyweightcompositeFly2 = flyFactory.factory(compositeState);
 compositeFly1.operation("CompositeCall");
 System.out.println("---------------------------------");
 System.out.println("复合享元模式是否共享对象：" + (compositeFly1 == compositeFly2));
 Character state = 'a';
 Flyweight fly1 =flyFactory.factory(state);
 Flyweight fly2 =flyFactory.factory(state);
 System.out.println("单纯享元模式是否共享对象：" + (fly1 == fly2));
 }
}

http://blog.sina.com.cn/s/blog_8e392fc20101c36y.html http://blog.sina.com.cn/s/blog_8e392fc20101c410.html
http://www.cnblogs.com/java-my-life/archive/2012/04/26/2468499.html

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航