java设计模式---2013-07-31

设计原则：(重要)
1.
逻辑代码独立到单独的方法中，注重封装性--易读，易复用。
不要在一个方法中，写下上百行的逻辑代码。把各小逻辑代码独立出来，写于其它方法中，易读其可重复调用。
2.
写类，写方法，写功能时，应考虑其移植性，复用性：防止一次性代码！
是否可以拿到其它同类事物中应用？是否可以拿到其它系统中应用？
3.
熟练运用继承的思想：
找出应用中相同之处，且不容易发生变化的东西，把它们抽取到抽象类中，让子类去继承它们；
继承的思想，也方便将自己的逻辑建立于别人的成果之上。如ImageField extends JTextField；
熟练运用接口的思想：
找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。





工厂模式主要是为创建对象提供了接口

1. 简单工厂模式(Simple Factory)
2. 工厂方法模式(Factory Method)
3. 抽象工厂模式(Abstract Factory)




适用工厂模式的两种情况：（面向接口编程）
1.在编码时不能预见需要创建哪种类的实例。
2.系统不应依赖于产品类实例如何被创建、组合和表达的细节

分离业务逻辑



Simple Factory

将程序中创建对象的操作，单独出来处理



1、直接实例化接口为需要“产品”

直接——>接口____ 实现（1）

                   |______实现（2）

2、通过工厂方法拿到“产品”

——>工厂方法（逻辑判断）___产品1___

   |                 |____________________产品2__|

   |___ 接口_______________________ | 

//产品 
public interface Tree{ 
    public void growUp();} 

public Apple implements Tree(){ 
    public void growUp(){ 
        System.out.println("apple tree grow up"); 
    } 
} 

public Orange implements Tree(){ 
    public void growUp(){ 
        System.out.println("orange tree grow up"); 
    } 
} 

//工厂 
public class Plant{ 
    public static Tree plantTree(String tree){ 
        if(tree.equals("apple")){ 
            return new Apple(); 
        }else if(tree.equals("orange")){ 
            return new Orange(); 
        } 
    } 
} 

//测试 
public class Test{ 
    public static void main(String[] msg){ 
    Tree tree = Plant.plantTree("apple"); 
    tree.growUp(); 
    } 
} 

缺点：增加新种类时，要修改工厂方法的逻辑，



Factory Method

抽象工厂角色作为核心来代替在简单工厂模式中使用具体类作为核心

多层次的树状结构

//工厂 
public interface Plant{ 
    public Tree treePlant(); 
} 

public ApplePlant implements Plant(){ 
    public Tree treePlant(){ 
    return new Apple(); 
    } 
} 

public OrangePlant implements Plant(){ 
    public Tree treePlant(){ 
        return new Orange(); 
    } 
} 

//测试 
public class Test{ 
    public static void main(String[] msg){ 
        Plant plant = new ApplePlant(); 
        Tree tree = plant.treePlant(); 
        tree.growUp(); 
    } 
} 

 
新增对象 完全松耦合。。(*^__^*)  



Abstract Factory

它和工厂方法模式的区别就在于需要创建对象的复杂程度上

这个不知道理解的对不对

就是这个种植园 既种树 也种花

原来是一个只种树的种植园

现在种树变成了其中一条生产线

//工厂 
public interface Plant{ 
    public Tree treePlant(); 
    public Flower flowerPlant(); 
}  

 面向对象中耦合关系有三种：零耦合、抽象耦合、具体耦合。依赖反转原则的本质意图就是将具体耦合削弱为抽象耦合。从下面两张图上可以看出，在互相依赖的模块中加入一层“抽象层”后，上层业务逻辑、下层具体实现的变化都受抽象类的隔离，变化就相对不容易在各层之间扩散。

 
****************************************************************************************************************

策略模式

策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

找出应用中相同之处，且不容易发生变化的东西，把它们抽取到抽象类中，让子类去继承它们； 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

继承 好处:共同部分,可以复用.避免重复编程.         不好:耦合性高.一旦超类添加一个新方法,子类都继承,拥有此方法,                         若子类相当部分不实现此方法,则要进行大批量修改.                          继承时,子类就不可继承其它类了. 接口 好处:解决了继承耦合性高的问题.                          且可让实现类,继承或实现其它类或接口.          不好:不能真正实现代码的复用.

可用以下的策略模式来解决.



1、抽象类--共同部分 并声明接口对象

2、接口实现类（独立逻辑）

3、子类继承抽象类 并实例化接口对象--通过接口实现类

      在构造方法中 实例化

     通过setter方法----动态的变化，比较灵活









****************************************************************************************************************
单例模式

保证一个类仅有一个实例，并提供一个访问他的全局访问点

单例模式的实现

一个类的对象产生是由类构造函数来完成的，如果想限制对象的产生，一个办法就是将构造函数私有化（or受保护的），外面的类不能通过引用来产生对象，同时，为了保证类的可用性，必须提供一个自己的对象以及访问这个对象的静态方法。

单例模式可分为有状态的和无状态的。

有状态的单例对象一般也是可变的单例对象，多个单态对象在一起就可以作为一个状态仓库一样向外提供服务。

没有状态的单例对象也就是不变单例对象，仅用做提供工具函数。

实现

//饿汉式 
public class Singleton {  
    //在自己内部定义自己一个实例 
   //注意这是private只供内部调用 
   private static Singleton instance = new Singleton(); 
    //如上面所述，将构造函数设置为私有 
   private Singleton(){} 
    //静态工厂方法，提供了一个供外部访问得到对象的静态方法 
   public static Singleton getInstance() { 
         return instance; 
    }  
}   

 

//懒汉式 
public class Singleton { 
    //和上面有什么不同？ 
   private static Singleton instance = null; 
    //设置为私有的构造函数 
   private Singleton(){ 
     } 
    //静态工厂方法  
   public static synchronized Singleton getInstance() { 
    //这个方法比上面有所改进 
       if (instance==null)  
          instance＝new Singleton();  
          return instance; 
    }  
}