浅谈Java中的设计模式

设计模式

什么是设计模式？

1. 基本定义：设计模式（Design pattern）是一套被反复使用的代码设计经验的总结。使用设计模式的目的是为了可重用代码、让代码更容易被他人理解。设计模式是是软件工程的基石脉络，如大厦的结构一样。
2. Design pattern的四大要素：模式名称（Name），问题（Question），解决方案（Solution），效果（Efftive）。

java 语言有23种设计模式

单例设计模式

Java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍两种：懒汉式单例、饿汉式单例。

特点

1. 单例类只能有一个实例。
2. 私有构造方法
3. 单例类必须自己创建自己的唯一实例。
4. 单例类必须给所有其他对象提供这一实例。

常用的单例模式写法

1. 懒汉式单例：在第一次调用的时候实例化自己；

   1. 懒汉式1：线程不安全

      public class Singleton {  
        private Singleton() {}//私有构造，避免类在外部被实例化
        private static Singleton single=null;  
        //静态工厂方法，判断是否存在实例，有返回，没有new一个返回
        public static Singleton getInstance() {  
             if (single == null) {    
                 single = new Singleton();  
             }    
            return single;  
        } 
      }

   2. 懒汉式2：在getInstance方法上加同步，使得线程安全

      public class Singleton {  
        private Singleton() {}//私有构造，避免类在外部被实例化
        private static Singleton single=null;  
        //静态工厂方法 加上了同步，使得线程安全
        public static synchronized Singleton getInstance() {  
             if (single == null) {    
                 single = new Singleton();  
             }    
            return single;  
        }
      }

   3. 懒汉式3：双重检查锁定，线程安全，建议使用懒汉单例使用

      public class Singleton {  
        private Singleton() {}//私有构造，避免类在外部被实例化
        private static Singleton single=null;
      
      public static Singleton getInstance() {  
            if (singleton == null) {    
                synchronized (Singleton.class) {//同步锁住，使得线程安全  
                   if (singleton == null) {    
                      singleton = new Singleton();   
                   }    
                }    
            }
            return singleton;   
      }
      }

   4. 懒汉式4：静态内部类，线程安全。因为内部在第一次调用的时候，类只会被加载一次。

      public class Singleton {
        private static class LazyHolder {
           private static final Singleton INSTANCE = new Singleton();   
        } 
        private Singleton (){}//私有构造函数
        public static final Singleton getInstance() {    
           return LazyHolder.INSTANCE;    
        }    
      }

2. 饿汉式单例：在类初始化时，已经自行实例化

   public class Singleton1 {  
      private Singleton1() {}//私有构造函数 
      private static final Singleton1 single = new Singleton1(); 
      //静态工厂方法   
      public static Singleton1 getInstance() {  
          return single;  
      }  
   }

简单工厂设计模式

简单工厂模式（Simple Factory Pattern）属于类的创新型模式，又叫静态工厂方法模式（Static FactoryMethod Pattern），是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类（或者父接口）。

简单工厂模式的 UML 图：

1. 抽象产品（Product）角色：简单工厂模式所创建的是所有对象的父类，注意，这里的父类可以是接口也可以是抽象类，它负责描述所有实例所共有的公共接口。
2. 具体产品（Concrete Product）角色：简单工厂所创建的具体实例对象，这些具体的产品往往都拥有共同的父类。
3. 工厂角色（Creator）：这是简单工厂模式的核心，由它负责创建所有的类的内部逻辑。当然工厂类必须能够被外界调用，创建所需要的产品对象。

代码示例：

代码：

1. 抽象产品角色：宠物

   /**
   * 抽象产品角色（Product）
   * 负责描述所有实例的公共接口
   */
   public interface Pet {
      public void eat();
   }

2. 具体产品角色：

   1. 猫
      public class Cat implements Pet {

        protected Cat() {
        }

          @Override
          public void eat() {
              System.out.println("猫咪正在吃东西...");
          }

      }

1. 狗

 public class Dog implements Pet {
        protected Dog() {
        }

          @Override
          public void eat() {
              System.out.println("狗狗正在吃东西");
          }
      }

1. 工厂角色：

     public class PetFactory {
               public static Pet createPet(String name){
                   if("cat".equals(name)){
                       return new Cat();
                   }else if("dog".equals(name)){
                       return new Dog();
                   }else{
                       return null;
                   }
               }
           }

1. 测试类：

      public class Client {
                public static void main(String[] args) {
                    Pet cat = PetFactory.createPet("cat");
                    cat.eat();
                    Dog dog = PetFactory.createPet("dog");
                    dog.eat();
                }
            }