java设计模式（一）

JAVA设计模式：

一） 创建模式：创建模式分为了：单例模式，工厂模式，建造模式，已经原型模式。

    1）：单例模式: 为什么要有单利模式，使用单例模式干什么？ 以及怎么使用单例模式单例模式主要是为了让某一个类不想让其外部随意的NEW对象，使用单例，就是为了保证在程序运行期间，就只有一个实例，这样就能有效的节约系统资源，减少很大一部分的开销了，因此，第一步：将构造方法变为private的。将构造方法设置为private后，外部将不可能通过new来产生对象了，因此，我们必须在本类产生出一个对象出来，那么外部又该怎么来得到这个对象？ 因此该提供方法，返回这个对象，方法是静态的。
    总结为三步：1）构造方法私有化。 2）产生一个对象出来。3）提供取得这个对象的方法。

下面是代码的实现：
   

    public class Singleton{
        
       private Singleton(){}
  
       private static Singleton singleton = new Singleton();
 
       public static Singleton getSingleton(){
            return singleton;
       } 
    }

   

  上面的代码是在类加载的时间就产生出了singleton的对象，下面的这种实现方式，是在第一次调用的时间才会去产生对象，实现延迟加载。对于上面的代码，在某种特殊的情况下会产生多个对象，也就是在当前类，加载多次时，可能产生多个实例。
 

    public class Singleton{
        
       private Singleton(){}
  
       private static Singleton singleton = null;
 
       public static synchronized Singleton getSingleton(){
            if(singleton==null){
                singleton=new Singleton();
          } 
          return singleton;
       } 
    }
  

  

下面的代码实现双锁机制：
  

   public class Singleton{

	private Singleton() {}

	private static Singleton singleton;

	public static Singleton getSingleton() {
		if (singleton== null) {
		   synchronized (Singleton.class) {
			if (singleton== null) {
			   singleton= new Student();
			    }
		      }
		}
	return singleton;
	}

   }

   

 
    2）工厂模式：谈及到工厂模式毫无质疑的肯定是创建对象的，为什么要用工厂模式，使用工厂模式有什么样的好处，以及怎么使用工厂模式？ 使用工厂模式减少new对象，将客户类和工厂类进行分离，这便是为什么要使用工厂模式，使用工厂模式能有效的减少类与类之间的侵入性，降低耦合度。
       客户类：就是使用类对象的类。工厂类：当然就是创建对象的类。
    最原始的工厂模式：例如下面代码：

         public class  Factory(){
             
             public static Object getObject(int a){
                
                  if(1==a){
                      ClassA a = new ClassA();
                      return a;
                  }
                  if(2==a){
                    ClassB b = new ClassB();
                      return b;
                  }
             }
         }
      

像上面这段代码，如果当我们在新增一个类的时候，那么很明显，我们不得不修改代码，添加上if条件了，很明显的违背了开闭原则。那么应该怎么做，要去掉if，我们可以这么想，我们不在让一个超级工厂去建造所有的对象了，我们抽象出来一个大工厂，在定义一些小工厂，让小工厂实现抽象工厂，然后在写一些小的工厂让这些小的工厂去创建某一类的对象，这样当我们有新增类的时候，我们只需要添加一个工厂即可，满足了开闭原则。例如下面代码：
   

         public abstract class BaseFactory{
       
         public abstract void  create();
	public abstract BaseFactory getFactory();

        }     
   

  

        public class FactoryA extends BaseFactory {

	@Override
	public void create() {
		// TODO 自动生成方法存根
		System.out.println("工厂A开始生产了");
	}

	@Override
	public BaseFactory getFactory() {
		// TODO 自动生成方法存根
		 BaseFactory  fa = new FactoryA();
		return fa;
	}
   

       

        public class FactoryB extends BaseFactory {

	@Override
	public void create() {
		// TODO 自动生成方法存根
		System.out.println("工厂B开始生产了");
	}

	@Override
	public BaseFactory getFactory() {
		// TODO 自动生成方法存根
		 BaseFactory  fa = new FactoryB();
		return fa;
	}

}

        

  

     public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO 自动生成方法存根
           BaseFactory bf = new FactoryB();
         BaseFactory base =   bf.getFactory();
         base.create();
	}

}
   
  

        3)原型模型： 原型模式没有什么好说的，用原型模型来创建对象，可以节省对象的创建时间，减少系统资源的消耗。需要注意的是，利用原型模型创建出来的对象跟源对象是完完全全不同的两个对象，使用原型模式，需要注意的是实现Cloneable接口，重写object的Colne方法。在此随便提及一下，对于clone，分为深度克隆，和浅度克隆。所谓的深度克隆就是说将方法和行为全部克隆下来，浅度克隆是复制了引用而已，还是指向的是原对象。因此只做一个简单的例子测试。

  
  public class MyClone implements Cloneable {
 
	private String name;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	protected Object clone() throws CloneNotSupportedException {
		Object obj =null;
		 obj=super.clone();
		return obj;
	}      
}

   public class Test {

	public static void main(String[] args) throws CloneNotSupportedException {
		// TODO 自动生成方法存根
		MyClone my = new MyClone();
		my.setName("李四");
		MyClone myc = (MyClone) my.clone();
		myc.setName("张三");
		System.out.println(my.getName());
		System.out.println(myc.getName());
		System.out.println(myc == my);
	}

}

上面例子输出了，张三，李四，证明了Clone出来的完完全全是不同的两个对象；

      4）构建模式（builder）

构建模式主要要来把创建对象的的过程和部件的创建来进行分解开来，书写一个构建类，一个指挥类，以及产品类。 构建类抽象一个接口出来，一个指挥类，产品类抽象出来， 例如，生产奥拓和奥迪这两种牌子的车，他们两种车的零件几乎是相同，只是质量不一样，可以弄2个实现类，一个类生产奥拓，一个类生产奥迪。生产好了返回即可。 指挥类，就要来进行一个中转。