-
构造者模式的定义
通俗的说,假如你要创建一个人类的对象,那么各个实例的属性不同,也就是人的高矮胖瘦不一样.这个时候可以考虑用构造者模式。
-
构造者模式的角色分类
- 具体的产品(要建造的东西)
- 抽象构造者：一个包含创建产品各个子部件的抽象方法的接口,还要包含一个返回产品的方法.
- 具体构造者：实现了抽象构造者,重新其中的抽象方法.
- 指挥官：用来指挥如何生成产品.
-
构造者模式的两种分类
构造者模式一共有四个角色,如果省掉其中的指挥者和抽象构造者,只有一个具体的构造者,那么就是简单的构造者模式.
1、正常构造者模式
- 假如我们要创建人类这个种产品.属性有很多,我们随意选几个来做演示. 产品的信息如下:
public class Person {
private String eyes; //眼睛
private String mouth; //嘴
private String legs; //腿
// 省略get和set方法
}
- 抽象构造者,在这个抽象的类中,定义一些要用的方法
/**
* 抽象构造者
*/
public abstract class AbstractBuilder {
//创建人类对象(产品)
protected Person person = new Person();
public abstract void buildEyes();
public abstract void buildMouth();
public abstract void buildLegs();
//返回对象
public Person getPerson(){
return person;
}
}
- 具体构造者
/**
* 具体构造者
*/
public class GirlPerson extends AbstractPersonBuilder {
@Override
public void buildEyes() {
person.setEyes("大眼睛");
}
@Override
public void buildMouth() {
person.setMouth("小嘴巴");
}
@Override
public void buildLegs() {
person.setLegs("大长腿");
}
}
- 指挥者
/**
* 指挥者
*/
public class Director {
//抽象构造者
private AbstractPersonBuilder abstractPersonBuilder;
public Director(AbstractPersonBuilder abstractPersonBuilder) {
this.abstractPersonBuilder = abstractPersonBuilder;
}
//开始建造
public Person instance(){
abstractPersonBuilder.buildEyes();
abstractPersonBuilder.buildMouth();
abstractPersonBuilder.buildLegs();
return abstractPersonBuilder.getPerson();
}
}
- 测试类
public static void main(String[] args) {
GirlPerson girlPerson = new GirlPerson();
Director director = new Director(girlPerson);
Person instance = director.instance();
System.out.println(instance.toString());
//log输出
//Person{eyes='大眼睛', mouth='小嘴巴', legs='大长腿'}
}
建造者（Builder）模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定，所以它通常在以下场合使用：
- 创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的。
- 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。
假如我们现在需要重新添加一个男人的对象.那么只需要新建一个类继承抽象构造者即可.越是复杂的对象,用构造模模式创建会很舒服.简单的对象不适用.
2、简单构造者模式
这个构造模式是除去了指挥者和抽象构造者而产生的.
它的作用在于可以在创建对象的时候,可以通过内类的一个构造者.来灵活的创建。
public class User{
String name;
int age;
String email;
String address;
public User(){
}
//想要有名字和邮箱的构造器
public User(String name, String email){
this.name = name;
this.email = email;
}
//想要有名字和地址的构造器
public User(String name, String address){
this.name = name;
this.address = address;
}
}
在上面代码中，很容易可以发现，在我们正常的需求下，Java构造器的编写将会出问题，由于参数个数和类型一样无法构成重载，所以这样写是不行的，那么Builder模式就是为了解决这种情况而出现的。
Builder模式的实现：
public class User {
String name;
int age;
String phone;
String email;
String address;
//注意无参构造器私有，避免外界使用构造器创建User对象
private User() {
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + ", phone=" + phone + ",
email=" + email + ", address=" + address
+ "]";
}
public static class Builder {
private String name;
private int age;
private String phone;
private String email;
private String address;
public Builder() {
}
public Builder setName(String name) {
this.name = name;
return this;
}
public Builder setAge(int age) {
this.age = age;
return this;
}
public Builder setPhone(String phone) {
this.phone = phone;
return this;
}
public Builder setEmail(String email) {
this.email = email;
return this;
}
public Builder setAddress(String address) {
this.address = address;
return this;
}
public User build() {
User user = new User();
user.name = name;
user.age = age;
user.email = email;
user.phone = phone;
user.address = address;
return user;
}
}
}
根据上面的代码，我们可以看出来，就是在User内部创建一个内部类，并且拥有和User一样的字段（属性），并且提供set方法，最重要的是要提供一个能够返回User对象的方法（build），这样才能通过Builder来创建User对象。
Builder设计模式还有一个好处，那便是我们可以随意组合输入的参数，不仅避免了重载出错的问题，还不需要写过多的构造器。
调用：
public class UserTest {
public static void main(String[] args) {
User u = new User.Builder().setName("bob").setAge(22).build();
System.out.println(u);
}
}
转载出处：https://www.jianshu.com/p/65dead47cd18
标签：String,建造,模式,email,User,构造,public,name From： https://www.cnblogs.com/PCBullprogrammer/p/16784818.html