为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。
单例模式的定义：一个类只能有一个实例，且该类能自行创建这个实例的一种模式。 单例模式的特点：
单例类只能有一个实例对象；该单例对象必须由单例类自行创建；单例类对外提供一个访问该单例的全局访问点；单例模式的实现原理：单例模式是设计模式中最基础的模式之一。通常一个普通类的构造方法是公有方法，外部类可以通过new构造方法来生成很多的实例。但是如果将构造函数设为私有方法，外部类就无法调用该构造方法，也就无法生成多个实例。该类必须定义一个静态私有实例，并且向外提供一个静态的公有函数用于创建或获取该静态私有实例。
单例模式的实现： 单例模式通常有俩种实现形式：
懒汉模式 这个模式下的特点是，只有当第一次调用getInstance方法的时候，才会创建这个单例。 public class Singleton { private static volatile Singleton instance = null;//保证instance在线程中同步 private Singleton() { //私有化构造方法避免被外部调用 } public static synchronized Singleton getInstance() { //getInstance方法前加同步 if(instance == null) { instance = new Singleton(); } return instance; } }如果编写的是多线程程序，则不要删除上例代码中的关键字 volatile 和 synchronized，否则将存在线程非安全的问题。如果不删除这两个关键字就能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。
饿汉模式 该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了 public class Singleton { private static final Singleton instance = new Singleton(); //类被加载后就创建一个单例 private Singleton() {} public static Singleton getInstance() { return instance; } }饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题。
工厂模式主要是为创建对象提供了接口。工厂模式按照《Java与模式》中的提法分为三类：
简单工厂模式(Simple Factory)工厂方法模式(Factory Method)抽象工厂模式(Abstract Factory)这个模式本身很简单，而且使用在业务较简单的情况下，它由三种角色组成：
工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。抽象产品角色：
public interface Car { //车可以跑起来 void run(); //车可以加油 void addOil(); }具体产品角色类：
public class BmwCar implements Car{ @Override public void run() { System.out.println("开宝马"); } @Override public void addOil() { System.out.println("加柴油"); } } public class BenzCar implements Car{ @Override public void run() { System.out.println("开奔驰"); } @Override public void addOil() { System.out.println("加汽油"); } }工厂类角色类:
public class CarSimpleFactory { public static Car createCar(String type) { Car car = null; if("Benz".equals(type)) { car = new BenzCar(); }else if("Bwm".equals(type)){ car = new BmwCar(); } return car; } }测试：
public class Test { public static void main(String[] args) { Car car = CarSimpleFactory.createCar("Benz"); car.run(); car.addOil(); } }上面的简单工厂虽然用法简单，但不利于扩展。当我们新增一种新车型时，我们需要修改简单工厂的代码，这不符合开闭原则，而且当 简单工厂创建的对象经常改变，种类繁多时，也就不符合单一职责。
在工厂模式里，创建了更多的对象，拆分了功能，使其职能单一，并且符合开闭原则，但是让系统代码结构更加复杂化，其组成如下：
抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。抽象工厂角色类：
public interface CarFactory { Car CreateInstance(); }具体工厂角色类：
public class BenzCarFactroy implements CarFactory{ @Override public Car CreateInstance() { return new BenzCar(); } } public class BmwCarFactory implements CarFactory{ @Override public Car CreateInstance() { return new BmwCar(); } }抽象产品角色类：
public interface Car { //车可以跑起来 void run(); //车可以加油 void addOil(); }具体产品角色类：
public class BenzCar implements Car{ @Override public void run() { System.out.println("开奔驰"); } @Override public void addOil() { System.out.println("加汽油"); } } public class BmwCar implements Car{ @Override public void run() { System.out.println("开宝马"); } @Override public void addOil() { System.out.println("加柴油"); } }测试：
public class Test2 { public static void main(String[] args) { CarFactory carFactory = new BenzCarFactroy(); Car car = carFactory.CreateInstance(); car.addOil(); car.run(); } }抽象工厂模式（Abstract Factory）是一个比较复杂的创建型模式。
抽象工厂模式和工厂方法不太一样，它要解决的问题比较复杂，不但工厂是抽象的，产品是抽象的，而且有多个产品需要创建，因此，这个抽象工厂会对应到多个实际工厂，每个实际工厂负责创建多个实际产品。
抽象产品角色类：
public interface ICar { //轿车 void roadPeople(); } public interface ITruck { //卡车 void roadGood(); } public interface IVan { //货车 void roadShipment(); }抽象工厂：
public abstract class AbstractFactory { //抽象工厂 protected abstract ICar createCar(); protected abstract ITruck createTruck(); protected abstract IVan creatVan(); }具体产品角色类：
public class BmwCar implements ICar{ @Override public void roadPeople() { System.out.println("宝马轿车"); } } public class BmwTruck implements ITruck{ @Override public void roadGood() { System.out.println("宝马卡车"); } } public class BmwVan implements IVan{ @Override public void roadShipment() { System.out.println("宝马货车"); } }具体工厂角色类：
public class BmwFactory extends AbstractFactory{ //宝马工厂 @Override protected ICar createCar() { return new BmwCar(); } @Override protected ITruck createTruck() { return new BmwTruck(); } @Override protected IVan creatVan() { return new BmwVan(); } }测试：
public class Test { public static void main(String[] args) { AbstractFactory factory = new BmwFactory(); factory.createTruck().roadGood(); } }抽象工厂模式结构较复杂，理解难度大，当工厂新增一个产品时，需要修改工厂的方法，不符合开闭原则。
