Java设计模式-创造型设计模式

创建型设计模式

建造者设计模式

使用场景：构建器设计模式是构建复杂对象的另一种方法，仅当我们想要使用相同的对象构建过程构建不同类型的不可变对象时才应使用。
Builder模式：将复杂对象的构建与其表示分离，以便相同的构建过程可以创建多个不同的对象。

Builder代码
User.java

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);
}

java类似

StringBuilder builder = new StringBuilder("Temp");

String data = builder.append(1)
		.append(true)
		.append("friend")
		.toString();

优势：减少构造器的参数，高度可读的链式方法调用中，创建实例无需传递null。实例始终以完整状态实例化，使用链式方法调用逐步添加属性。可以构建不可变对象，无需复杂创建。
缺点：代码冗长

原型设计模式

使用场景
原型设计模式用于应用程序需要创建一个类的大量实例，这些实例具有几乎相同的状态或差异很小的场景。
理解
在构造实际对象之前，原型是任何对象的模板。在java中，它也具有相同的含义。原型设计模式用于应用程序需要创建一个类的多个实例，这些实例具有几乎相同的状态或差异很小的场景。
在这种设计模式中，实际对象的一个​​实例（即原型）在开始时被创建，之后每当需要一个新实例时，这个原型就会被克隆成另一个实例。这种模式的主要优点是具有最少的实例创建过程，这比克隆过程成本高得多。

案例

原型能力.java

public interface PrototypeCapable extends Cloneable
{
  public PrototypeCapable clone() throws CloneNotSupportedException;
}

Movie.java、Album.java 和 Show.java

import com.howtodoinjava.prototypeDemo.contract.PrototypeCapable;
 
public class Movie implements PrototypeCapable
{
  private String name = null;
  public String getName() {
    return name;
  }
  public void setName