【Java基础】Java设计模式简介

什么是设计模式

　　设计模式（Design pattern）是一套被反复使用、被多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式不是一种方法和技术，而是一种思想设计模式，和具体的语言无关，但是本文以Java为语言基础来讲解，学习设计模式就是要建立面向对象的思想，尽可能的面向接口编程，低耦合，高内聚，使设计的程序可复用。设计模式大概可以归纳为如下几类：

　　• 创建型模式：对象的创建

　　• 结构型模式：对象的组成(结构)

　　• 行为型模式：对象的行为

下面分别介绍一些简单的常用设计模式。

单例模式（Singleton Pattern）

　　单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。下面是单例模式的设计示例：

package cn.pattern;

/**
 * Created by lili on 15/12/14.双重锁式
 */
public class SingletonClass {

    //全局单例对象instance,为了防止外部改变instance,将instance私有,不支持外界赋值和访问
    //static修饰是因为对外公开的方法是静态的,所以在静态方法中访问外部的成员变量也必须是静态的.
    private static SingletonClass instance = null;

    // 构造方法私有化,防止外界随意造对象,所以这样一来,此类只能内部造对象
    private SingletonClass() {
    }
    
    //不需要造对象就可以访问,必须将该方法设置为静态
    // 
    public static SingletonClass getInstance() {
        if (instance == null) {
            //只有此处可以造对象,所以为了防止并发造多个对象,这里采取了同步代码块
            synchronized (SingletonClass.class) {
                if (instance == null) {
                    instance = new SingletonClass();
                }
            }
        }
        return instance;
    }

}

上述的写法是双重锁式，还有另外两种写法，分别是懒汉式和饿汉式：

/**
 * 懒汉式，只有调用获取实例方法的时候才开始创建对象，比较懒
 */
public class SingletonClass {
    private static SingletonClass instance = null;

    private SingletonClass() {
    }

    public static synchronized SingletonClass getInstance() {
        if (instance == null) {
            instance = new SingletonClass();
        }
        return instance;
    }
}

/**
 * 饿汉式，类加载的时候就创建了，很饥饿
 */
public class SingletonClass {

    private static final SingletonClass instance = new SingletonClass();

    private SingletonClass() {
    }

    public static SingletonClass getInstance() {
        return instance;
    }
}

 　　具体开发中多用饿汉式，例如JDK中的Runtime就是饿汉式的设计。

简单工厂模式

　　简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。这种简单模式的优点在于外界避免了创建对象的尴尬工作，只需要消费即可。但是这种模式的所有创建逻辑都在工厂类中，违背了高内聚的原则，而且当产品类多的时候，判断逻辑将和产品类型的判断相互交错会弄得很复杂，不利于维护和扩展。

　　下面的例子是简单工厂的示例，Animal是产品对象的抽象接口，Dog和Cat是具体产品，工厂内部提供静态方法供外界调用，从而根据外界传入参数的不同来返回不同产品对象。

public class AnimalFactory {

    private AnimalFactory() {
    }
    public static Animal createAnimal(String type) {
        if ("dog".equals(type)) {
            return new Dog();
        } else if ("cat".equals(type)) {
            return new Cat();
        } else {
            return null;
        }
    }
}

工厂方法模式

　　工厂方法模式（FACTORY METHOD）是一种常用的对象创建型设计模式,此模式的核心精神是封装类中不变的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的，这一定程度上解决了简单工厂模式的弊端。工厂方法模式的核心结构有四个角色，分别是抽象工厂，具体工厂，抽象产品，具体产品。

　　工厂方法模式对简单工厂模式进行了抽象。有一个抽象的Factory类（可以是抽象类和接口），这个类将不再负责具体的产品生产，而是只制定一些规范，具体的生产工作由其子类去完成。在这个模式中，工厂类和产品类往往可以依次对应。即一个抽象工厂对应一个抽象产品，一个具体工厂对应一个具体产品，这个具体的工厂就负责生产对应的产品。

　　下面借用一个简单示例来讲解：

　　抽象工厂，只负责定义规范，具体生产由子类完成。

public interface Factory {
    public abstract Animal createAnimal();
}

　　具体工厂，每个产品对应一个具体工厂，犹如生产线一样，但是每个产品的生产线上都有工厂的一些共性，例如生产产品。

public class CatFactory implements Factory {
    @Override
    public Animal createAnimal() {
        return new Cat();
    }
}

public class DogFactory implements Factory {
    @Override
    public Animal createAnimal() {
        return new Dog();
    }
}

　　最后，我们在用的时候，调用不同的具体工厂来生产对应的产品即可。

public class AnimalDemo {
    public static void main(String[] args) {
        Factory f = new DogFactory();
        Animal a = f.createAnimal();
        a.eat();
        
        f = new CatFactory();
        a = f.createAnimal();
        a.eat();
    }
}