Java设计模式

   Java设计模式：

（一）、工厂模式      

问题：工厂模式
分析：（一）、工厂模式是我们在java设计模式中是随处可见的模式，例如著名的Jive论坛就使用了大量的工厂模式
为什么工厂模式会如此受到？因为工厂模式相当于创建实例对象的NEW，我们常常根据类Class生成实例对象，
例如：A a=new A();因此，以后若创建多个实例对象，可以考虑使用工厂模式。
(二)、在简单创建实例化对象（A a=new A()）的情况下，我们考虑实例化参数之类，方便修改，就可以不再实例化对象
再去做修改。
（三）、在创建实例化对象时，是根据需求而创建，例如，一个妈妈她今年生了一个儿子，可以实例化一个对象，若明年她接着又
生两个儿子，不可能又实例化，就可以把妈妈这个类抽象成一个接口对象类，不管她生多少个儿子，都可以实现这个接口对象类即可。
如：Simpole son=new SonSimple(),Simpole son2=new Son2Simpole();
以上的例子都是传统的程序，若是考虑到现在的工厂设计模式，就不会那么繁琐及死板。
结果：代码示例

public class Factory{

　　public static Sample creator(int which){

　　//getClass 产生Sample 一般可使用动态类装载装入类。
　　if (which==1)
　　　　return new SampleA();
　　else if (which==2)
　　　　return new SampleB();

　　}

}

（二）、抽象工厂模式

问题：抽象工厂
分析：在刚刚操作完工厂模式实例之后，我们有时需要改变需求，就是不知只有一个妈妈这个抽象接口，还新增了一个妈妈抽象接口，则其需要用
到抽象工厂模式来封装在一个接口类中。再去继承该接口实现其中的属性方法。
结果：代码示例：

public abstract class Factory{

　　public abstract Sample creator();

　　public abstract Sample2 creator(String name);

}

public class SimpleFactory extends Factory{

　　public Sample creator(){
　　　　.........
　　　　return new SampleA
　　}

　　public Sample2 creator(String name){
　　　　.........
　　　　return new Sample2A
　　}

}

public class BombFactory extends Factory{

　　public Sample creator(){
　　　　......
　　　　return new SampleB 
　　}

　　public Sample2 creator(String name){
　　　　......
　　　　return new Sample2B
　　}

}

（三）、单例模式

问题：单例模式
分析：单例模式在程序中的作用是保证在Java应用中，一个类只有一个实例存在，在以后项目的很多操作中，比如
数据库的连接都需要这样单线程操作。还有，单例模式能够被状态化，这样，多个单态类在一起可以做一个状态仓库
一样向外提供服务。比如，你在一个论坛游览器评论了一条信息，每次游览该论坛都会计数，单态类能保持这个状态
计数，并且单线程能自动加1。你可以在不修改单态接口的情况下方便做到。

结果：代码示例：

public class Singleton {

　　private Singleton(){}
　　//在自己内部定义自己一个实例，是不是很奇怪？
　　//注意这是private 只供内部调用

　　private static Singleton instance = new Singleton();

　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 } 
}

第二种形式：
public class Singleton {
　　private static Singleton instance = null;

　　public static synchronized Singleton getInstance() {

　　if (instance==null)
　　　　instance＝new Singleton();
　　return instance; 　　}

}

（四）、建造者模式

  问题:建造者模式
  分析：建造者模式是一步一步创建的一个复杂对象，该模式类似于抽象工厂模式，是为了构建复杂的过程和部件
，是解耦过程和部件。因为一个复杂对象有很多复杂部分组成，例如：汽车是由方向盘、轮胎等部件组成完成的。

  结果：代码示例：

  

public interface Builder {
　　//创建部件A　　比如创建汽车车轮
　　void buildPartA(); 
　　//创建部件B 比如创建汽车方向盘
　　void buildPartB(); 
　　//创建部件C 比如创建汽车发动机
　　void buildPartC(); 

　　//返回最后组装成品结果 (返回最后装配好的汽车)
　　//成品的组装过程不在这里进行,而是转移到下面的Director类中进行.
　　//从而实现了解耦过程和部件
　　Product getResult();

}
------
public class Director {

　　private Builder builder;

　　public Director( Builder builder ) { 
　　　　this.builder = builder; 
　　} 
　　// 将部件partA partB partC最后组成复杂对象
　　//这里是将车轮 方向盘和发动机组装成汽车的过程
　　public void construct() { 
　　　　builder.buildPartA();
　　　　builder.buildPartB();
　　　　builder.buildPartC();

　　}

}
---
public class ConcreteBuilder implements Builder {

　　Part partA, partB, partC; 
　　public void buildPartA() {
　　　　//这里是具体如何构建partA的代码

　　}; 
　　public void buildPartB() { 
　　　　//这里是具体如何构建partB的代码
　　}; 
　　 public void buildPartC() { 
　　　　//这里是具体如何构建partB的代码
　　}; 
　　 public Product getResult() { 
　　　　//返回最后组装成品结果
　　}; 
}
----

public static void main(String[] args) {

ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director( builder );

director.construct();
Product product = builder.getResult();

}

（五）、原型模式

问题：原型模式
分析：定义:指定创建对象的种类，并且通过拷贝这些原型创建新对象，原型模式允许一个对象可以创建宁一个对象，根本无须知道它创建的过程，
而工作原理是通过原型对象传给那个要创建对象的对象，这个要发动创建对象的对象通过请求原型对象拷贝它们来创建对象。

结果：代码示例：

public abstract class AbstractSpoon implements Cloneable
{ 
　　String spoonName; 

　　public void setSpoonName(String spoonName) {this.spoonName = spoonName;}
　　public String getSpoonName() {return this.spoonName;}

　　public Object clone() 
　　{
　　　　Object object = null;
　　　　try {
　　　　　　object = super.clone();
　　　　} catch (CloneNotSupportedException exception) {
　　　　　　System.err.println("AbstractSpoon is not Cloneable");
　　　　}
　　　　return object;
　　}
}
---- 具体实现类
public class SoupSpoon extends AbstractSpoon
{ 
　　public SoupSpoon()
　　{
　　　　setSpoonName("Soup Spoon"); 
　　}
}

 今晚，就暂时阐述这些设计模式，明天再继续。