设计模式系列 - 创建型模式
单例模式
懒汉式，线程不安全。
除非是单线程程序，否则不推荐使用。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}饿汉式，线程安全
当程序总是使用这个类的实例时，或者在资源和时间方面创建实例的成本不太大时，可以使用它。
可能导致资源浪费。因为类的实例总是被创建的，不管它是否必需。在创建实例时也会浪费CPU时间。
无法处理异常。
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}静态块，线程安全
对象是在静态块中创建的，这样我们就可以访问它的创建，比如异常处理。同样地，对象也是在类加载时创建的。
当在创建具有紧急初始化的对象时可能出现异常时，可以使用它。可能导致资源浪费。因为类的实例总是被创建的，不管它是否必需。
public class Singleton
{
// public instance
public static Singleton instance;
private Singleton()
{
// private constructor
}
{
// static block to initialize instance
instance = new Singleton();
}
}同步方式，线程安全
会导致性能下降
public class Singleton
{
// private instance, so that it can be
// accessed by only by getInstance() method
private static Singleton instance;
private Singleton()
{
// private constructor
}
//synchronized method to control simultaneous access
synchronized public static Singleton getInstance()
{
if (instance == null)
{
// if instance is null, initialize
instance = new Singleton();
}
return instance;
}
}双检方式，线程安全
克服了同步代码的开销问题。延迟初始化，可以用于高性能的多线程应用。
public class Singleton
{
// private instance, so that it can be
// accessed by only by getInstance() method
private static Singleton instance;
private Singleton()
{
// private constructor
}
public static Singleton getInstance()
{
if (instance == null)
{
//synchronized block to remove overhead
synchronized (Singleton.class)
{
if(instance==null)
{
// if instance is null, initialize
instance = new Singleton();
}
}
}
return instance;
}
}内部静态类方案，优方案
加载单例类时，不会加载内部类，因此在加载类时不会创建对象。只有在调用getInstance（）方法时才创建内部类。它是懒惰的初始化。
这是最广泛使用的方法，因为它不使用同步，性能更好。
public class Singleton
{
private Singleton()
{
// private constructor
}
// Inner class to provide instance of class
private static class BillPughSingleton
{
private static final Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance()
{
return BillPughSingleton.INSTANCE;
}
}枚举，优方案
自动支持序列化机制，绝对防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。
public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}工厂方法
是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
//定义车类
public enum CarType {
SMALL, SEDAN, LUXURY
}
//车的基类
public abstract class Car {
public Car(CarType model) {
this.model = model;
arrangeParts();
}
private void arrangeParts() {
// Do one time processing here
}
// Do subclass level processing in this method
protected abstract void construct();
private CarType model = null;
public CarType getModel() {
return model;
}
public void setModel(CarType model) {
this.model = model;
}
}
//豪华车
public class LuxuryCar extends Car {
LuxuryCar() {
super(CarType.LUXURY);
construct();
}
@Override
protected void construct() {
System.out.println("Building luxury car");
// add accessories
}
}
public class SmallCar extends Car {
SmallCar() {
super(CarType.SMALL);
construct();
}
@Override
protected void construct() {
System.out.println("Building small car");
// add accessories
}
}
public class SedanCar extends Car {
SedanCar() {
super(CarType.SEDAN);
construct();
}
@Override
protected void construct() {
System.out.println("Building sedan car");
// add accessories
}
}
public class CarFactory {
public static Car buildCar(CarType model) {
Car car = null;
switch (model) {
case SMALL:
car = new SmallCar();
break;
case SEDAN:
car = new SedanCar();
break;
case LUXURY:
car = new LuxuryCar();
break;
default:
// throw some exception
break;
}
return car;
}
}
public class TestFactoryPattern {
public static void main(String[] args) {
System.out.println(CarFactory.buildCar(CarType.SMALL));
System.out.println(CarFactory.buildCar(CarType.SEDAN));
System.out.println(CarFactory.buildCar(CarType.LUXURY));
}
}抽象工厂
围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
我们重用上一节的CarType
public abstract class Car {
public Car(CarType model, Location location){
this.model = model;
this.location = location;
}
protected abstract void construct();
private CarType model = null;
private Location location = null;
//getters and setters
@Override
public String toString() {
return "Model- "+model + " built in "+location;
}
}
public enum Location {
DEFAULT, USA, ASIA
}
public class LuxuryCar extends Car
{
public LuxuryCar(Location location)
{
super(CarType.LUXURY, location);
construct();
}
@Override
protected void construct() {
System.out.println("Building luxury car");
//add accessories
}
}
public class AsiaCarFactory
{
public static Car buildCar(CarType model)
{
Car car = null;
switch (model)
{
case SMALL:
car = new SmallCar(Location.ASIA);
break;
case SEDAN:
car = new SedanCar(Location.ASIA);
break;
case LUXURY:
car = new LuxuryCar(Location.ASIA);
break;
default:
//throw some exception
break;
}
return car;
}
}
public class DefaultCarFactory
{
public static Car buildCar(CarType model)
{
Car car = null;
switch (model)
{
case SMALL:
car = new SmallCar(Location.DEFAULT);
break;
case SEDAN:
car = new SedanCar(Location.DEFAULT);
break;
case LUXURY:
car = new LuxuryCar(Location.DEFAULT);
break;
default:
//throw some exception
break;
}
return car;
}
}
public class USACarFactory
{
public static Car buildCar(CarType model)
{
Car car = null;
switch (model)
{
case SMALL:
car = new SmallCar(Location.USA);
break;
case SEDAN:
car = new SedanCar(Location.USA);
break;
case LUXURY:
car = new LuxuryCar(Location.USA);
break;
default:
//throw some exception
break;
}
return car;
}
}
public class CarFactory
{
private CarFactory() {
//Prevent instantiation
}
public static Car buildCar(CarType type,Location location)
{
Car car = null;
//Use location specific car factory
switch(location)
{
case USA:
car = USACarFactory.buildCar(type);
break;
case ASIA:
car = AsiaCarFactory.buildCar(type);
break;
default:
car = DefaultCarFactory.buildCar(type);
}
return car;
}
}
public class TestFactoryPattern
{
public static void main(String[] args)
{
System.out.println(CarFactory.buildCar(CarType.SMALL,Location.USA));
System.out.println(CarFactory.buildCar(CarType.SEDAN,Location.USA));
System.out.println(CarFactory.buildCar(CarType.LUXURY,Location.ASIA));
}
}这两个工厂模式的代码还有很多switch，仅仅是演示而已
建造者模式
建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。
interface HousePlan
{
public void setBasement(String basement);
public void setStructure(String structure);
public void setRoof(String roof);
public void setInterior(String interior);
}
class House implements HousePlan
{
private String basement;
private String structure;
private String roof;
private String interior;
public void setBasement(String basement)
{
this.basement = basement;
}
public void setStructure(String structure)
{
this.structure = structure;
}
public void setRoof(String roof)
{
this.roof = roof;
}
public void setInterior(String interior)
{
this.interior = interior;
}
}
interface HouseBuilder
{
public void buildBasement();
public void buildStructure();
public void bulidRoof();
public void buildInterior();
public House getHouse();
}
class IglooHouseBuilder implements HouseBuilder
{
private House house;
public IglooHouseBuilder()
{
this.house = new House();
}
public void buildBasement()
{
house.setBasement("Ice Bars");
}
public void buildStructure()
{
house.setStructure("Ice Blocks");
}
public void buildInterior()
{
house.setInterior("Ice Carvings");
}
public void bulidRoof()
{
house.setRoof("Ice Dome");
}
public House getHouse()
{
return this.house;
}
}
class TipiHouseBuilder implements HouseBuilder
{
private House house;
public TipiHouseBuilder()
{
this.house = new House();
}
public void buildBasement()
{
house.setBasement("Wooden Poles");
}
public void buildStructure()
{
house.setStructure("Wood and Ice");
}
public void buildInterior()
{
house.setInterior("Fire Wood");
}
public void bulidRoof()
{
house.setRoof("Wood, caribou and seal skins");
}
public House getHouse()
{
return this.house;
}
}
class CivilEngineer
{
private HouseBuilder houseBuilder;
public CivilEngineer(HouseBuilder houseBuilder)
{
this.houseBuilder = houseBuilder;
}
public House getHouse()
{
return this.houseBuilder.getHouse();
}
public void constructHouse()
{
this.houseBuilder.buildBasement();
this.houseBuilder.buildStructure();
this.houseBuilder.bulidRoof();
this.houseBuilder.buildInterior();
}
}
class Builder
{
public static void main(String[] args)
{
HouseBuilder iglooBuilder = new IglooHouseBuilder();
CivilEngineer engineer = new CivilEngineer(iglooBuilder);
engineer.constructHouse();
House house = engineer.getHouse();
System.out.println("Builder constructed: "+ house);
}
}以上是做分部建造，还可以避免new product的过多参数，比如：
public User (String firstName, String lastName, int age, String phone){ ... }
public User (String firstName, String lastName, String phone, String address){ ... }
public User (String firstName, String lastName, int age){ ... }
public User (String firstName, String lastName){ ... }如果再多十几个属性怎么办？
public class User
{
//All final attributes
private final String firstName; // required
private final String lastName; // required
private final int age; // optional
private final String phone; // optional
private final String address; // optional
private User(UserBuilder builder) {
this.firstName = builder.firstName;
this.lastName = builder.lastName;
this.age = builder.age;
this.phone = builder.phone;
this.address = builder.address;
}
//All getter, and NO setter to provde immutability
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
public int getAge() {
return age;
}
public String getPhone() {
return phone;
}
public String getAddress() {
return address;
}
@Override
public String toString() {
return "User: "+this.firstName+", "+this.lastName+", "+this.age+", "+this.phone+", "+this.address;
}
public static class UserBuilder
{
private final String firstName;
private final String lastName;
private int age;
private String phone;
private String address;
public UserBuilder(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public UserBuilder age(int age) {
this.age = age;
return this;
}
public UserBuilder phone(String phone) {
this.phone = phone;
return this;
}
public UserBuilder address(String address) {
this.address = address;
return this;
}
//Return the finally consrcuted User object
public User build() {
User user = new User(this);
validateUserObject(user);
return user;
}
private void validateUserObject(User user) {
//Do some basic validations to check
//if user object does not break any assumption of system
}
}
}
public static void main(String[] args) {
User user1 = new User.UserBuilder("Lokesh", "Gupta")
.age(30)
.phone("1234567")
.address("Fake address 1234")
.build();
System.out.println(user1);
User user2 = new User.UserBuilder("Jack", "Reacher")
.age(40)
.phone("5655")
//no address
.build();
System.out.println(user2);
User user3 = new User.UserBuilder("Super", "Man")
//No age
//No phone
//no address
.build();
System.out.println(user3);
}原型模式
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。原型设计模式用于应用程序需要创建一个类的多个实例的场景中，这些实例几乎具有相同的状态或差别非常小。
在这个设计模式中，实际对象的一个实例（即prototype）是在启动时创建的，然后每当需要新实例时，就克隆这个原型以拥有另一个实例。这种模式的主要优点是具有最小的实例创建过程
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。
public interface PrototypeCapable extends Cloneable
{
public PrototypeCapable clone() throws CloneNotSupportedException;
}
public class Movie implements PrototypeCapable
{
private String name = null;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public Movie clone() throws CloneNotSupportedException {
System.out.println("Cloning Movie object..");
return (Movie) super.clone();
}
@Override
public String toString() {
return "Movie";
}
}
public class Album implements PrototypeCapable
{
private String name = null;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public Album clone() throws CloneNotSupportedException {
System.out.println("Cloning Album object..");
return (Album) super.clone();
}
@Override
public String toString() {
return "Album";
}
}
public class Show implements PrototypeCapable
{
private String name = null;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public Show clone() throws CloneNotSupportedException {
System.out.println("Cloning Show object..");
return (Show) super.clone();
}
@Override
public String toString() {
return "Show";
}
}
public class PrototypeCache
{
public static class ModelType
{
public static final String MOVIE = "movie";
public static final String ALBUM = "album";
public static final String SHOW = "show";
}
private static java.util.Map<String , PrototypeCapable> prototypes = new java.util.HashMap<String , PrototypeCapable>();
static
{
prototypes.put(ModelType.MOVIE, new Movie());
prototypes.put(ModelType.ALBUM, new Album());
prototypes.put(ModelType.SHOW, new Show());
}
public static PrototypeCapable getInstance(final String s) throws CloneNotSupportedException {
return ((PrototypeCapable) prototypes.get(s)).clone();
}
}
TestPrototypePattern
public class TestPrototypePattern
{
public static void main(String[] args)
{
try
{
String moviePrototype = PrototypeCache.getInstance(ModelType.MOVIE).toString();
System.out.println(moviePrototype);
String albumPrototype = PrototypeCache.getInstance(ModelType.ALBUM).toString();
System.out.println(albumPrototype);
String showPrototype = PrototypeCache.getInstance(ModelType.SHOW).toString();
System.out.println(showPrototype);
}
catch (CloneNotSupportedException e)
{
e.printStackTrace();
}
}
}Singleton