一 、工场方法模式

工厂类负责定义创建对象的接口，具体对象创建由继承工场类的具体类实现。
优点：每个类有不同的责任，不影响现有代码，后期维护容易，增强扩展性。
确定：写起来麻烦。

举个栗子：

/** 抽象汽车类，里面有驾驶的抽象方法**/
public abstract class Car{
  public abstract void drive();
}
/** 工场类接口，抽象的创建汽车类方法**/
public interface Factory{
  public abstract Car createCar();
}
/**具体的大众车类，重写抽象方法**/
public class Das extends Car{
  public void drive(){
    System.out.println("DasAuto");
  }
}
/**大众工场类，实现工场的抽象方法，返回一个大众对象**/
public class DasFactory implements Factory{
  public Car createCar(){
    return new Das();
  }
}
/**具体的宝马车类，重写抽象方法**/
public calss BMW extends Car{
   public void drive(){
    System.out.println("BMW");
  }
  public void expensive(){
    System.out.println("我很贵");
  }
}
/**宝马工场类，实现工场的抽象方法，返回一个宝马对象**/
public class BMWFactory implements Factory{
   public Car createCar(){
    return new BMW():
  }
}
public class TestDemo{
  public static void main(String[] args){
    //生产一个大众车
    Factory f = new DasFactory();
    Car car = f.createCar();
    car.driver();//DasAuto
    //生产一个大众车
    f = new BMWFactory();
    car = f.createCar();
    car.driver();//BMW
    car.expensive();//我很贵
  }
}

二、单例设计模式

类在内存中只有一个对象，并且自动创建，并对外提供。

1.饿汉模式

/**思想是唯一的**/
public class Idea{
  private Idea(){}
  private static Idea idea = new Idea();//自己构建一个对象，其他类不能直接访问
  public static Idea getIdea(){return idea;}//对外提供生成的对象
}
public class TestDemo{
  public static void main(String[] arg){
    Idea idea1 = Idea.getIdea();//得到对象
    Idea idea2 = Idea.getIdea();//得到对象
    System.out.println(idea1 == idea2);//输出为true
  }
}

1.懒汉模式

public class Shit{
  private Shit(){}
  private static Shit s = null;
  public synchronized static Shit getShit(){
    if(s==null) s = new Shit();
    return s;
  }
}

public class TestDemo{
  public static void main(String[] arg){
    Shit s1 = Shit.getShit();
    Shit s2 = Shit.getShit();
    System.out.println(s1 == s2);//输出为true
  }
}

比较：

饿汉模式是不会出现问题的单例模式
懒汉模式有线程安全的问题（多线程环境，有共享数据，有多投语句操作共享数据）