zoukankan      html  css  js  c++  java

  • 遇到多个构造器参数时要考虑用构建器

    遇到多个构造器参数时要考虑用构建器

    java
    effective java
    创建和销毁对象

    1. 构建器是什么？

    构建器也是一种获得类对象的方法，在前面我们介绍了通过 构造器 与 静态工厂方法 两种方式来获得类的对象。
    这里我们写一个 Person 类，并为这个类加上构建器:

    1. public class Person { 
    2. private final String name; 
    3. private final int age; 
    4.  
    5. private final String address; 
    6. private final String phone; 
    7.  
    8. public static class Builder{ 
    9. private final String name; 
    10. private final int age; 
    11.  
    12. private String address = null; 
    13. private String phone = null; 
    14.  
    15. public Builder(String name,int age){ 
    16. this.name = name; 
    17. this.age = age; 
    18. } 
    19.  
    20. public Builder address(String val){ 
    21. address = val; 
    22. return this; 
    23. } 
    24.  
    25. public Builder phone(String val){ 
    26. phone = val; 
    27. return this; 
    28. } 
    29.  
    30. public Person builder(){ 
    31. return new Person(this); 
    32. } 
    33. } 
    34.  
    35. private Person(Builder builder){ 
    36. this.name = builder.name; 
    37. this.age = builder.age; 
    38. this.address = builder.address; 
    39. this.phone = builder.phone; 
    40. } 
    41.  
    42. @Override 
    43. public String toString() { 
    44. return "name:"+name+" age:"+age+" address:"+address+" phone:"+phone; 
    45. } 
    46.  
    47. } 

    调用这个构建器的方式

    public class PersonTest {
    public static void main(String[] args) {
        Person p = new Person.Builder("tom", 18).address("深圳").phone("110").builder();
        System.out.println(p.toString());
    }
}

    2. 为什么使用构建器？

    2.1 参数的限制

    静态工厂方法与构造器都有一个共同的局限性，就是它们不能很好的扩展到大量的可选参数。就像我们上面的那个Person 类，在实际中我们会有许多的属性，性别、出生年月、爱好...对与这样的类。

    2.2 重叠构造器

    我们初学的时候都会选择 重叠构造器(telecoping constructor)模式 。在这种情况下，第一个构造器是实例化对象必须的参数，第二个会多一个参数，就这样叠加，最后是一个有所有参数的构造器

    1. public class Person { 
    2. private final String name; 
    3. private final int age; 
    4.  
    5. private final String address; 
    6. private final String phone; 
    7.  
    8. public Person(String name, int age) { 
    9. this(name,age,null); 
    10. } 
    11.  
    12.  
    13. public Person(String name, int age, String address) { 
    14. this(name,age,address,null); 
    15. } 
    16.  
    17. public Person(String name, int age, String address, String phone) { 
    18. super(); 
    19. this.name = name; 
    20. this.age = age; 
    21. this.address = address; 
    22. this.phone = phone; 
    23. } 
    24.  
    25. @Override 
    26. public String toString() { 
    27. return "name:"+name+" age:"+age+" address:"+address+" phone:"+phone; 
    28. } 
    29.  
    30. } 

    获得对象

    public class PersonTest {
    public static void main(String[] args) {
        Person p = new Person("tom",18,null,"110");
        System.out.println(p.toString());
    }
}

    在这个构造器中也许会有你不想要的参数，如果我们的参数变多了的话，情况就不会很好。
    总结一句话:重叠构造器可行，但当有很多的参数的时候，客户端的代码就会很难编写并且不容易阅读我们在使用的时候，必须很仔细的看每一个参数的位置和含义。

    2.3 JavaBeans模式

    2.3.1 创建JavaBeans模式

    这个时候我们还有一种替代的方式，这个就是JavaBeans模式。这种种模式下，使用无参的构造方法创建对象，然后调用setter 方法给属性设置值

    1. public class Person { 
    2. private String name; 
    3. private int age; 
    4.  
    5. private String address; 
    6. private String phone; 
    7.  
    8. public void setName(String name) { 
    9. this.name = name; 
    10. } 
    11. public void setAge(int age) { 
    12. this.age = age; 
    13. } 
    14. public void setAddress(String address) { 
    15. this.address = address; 
    16. } 
    17. public void setPhone(String phone) { 
    18. this.phone = phone; 
    19. } 
    20.  
    21. @Override 
    22. public String toString() { 
    23. return "name:"+name+" age:"+age+" address:"+address+" phone:"+phone; 
    24. } 
    25.  
    26. } 

    使用的方式，这个相比与重叠构造器更容易的创建了对象，同时让代码跟容易的阅读。

    public class PersonTest {
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("tom");
        p.setAge(18);
        p.setAddress("深圳");
        p.setPhone("110");
        System.out.println(p.toString());
    }
}

    2.3.2 JavaBeans模式的劣势

    • 构造的过程分到了几个调用中，在构造JavaBeans的时候可能会不一致

    • 类无法仅仅通过检验构造器参数的有效性来保证一致性！

    • 对象的不一致会导致失败，JavaBeans模式阻止了把类做为不可变的可能，需要程序员做额外努力来保证它线程安全。

    2.4 构建器

    • 构建器的创建对象就比较易于创建与阅读,线程安全

    • 等待所有的参数验证通过才会build()对象。

    • 与构造器相比，builder 的微略优势在，builder可以有多个可变(varargs)参数。构造器像方法一样，只有一个可变参数。因为builder利用单独的方法来设置每个参数，你想要多少个可变参数，他们就可以有多少个，知道每个setter方法都有一个可变参数。

    • builder模式非常灵活，可以理由单个builder构建多个对象。builder的参数可以在创建对象时进行调整

    • 设置了参数的builder生成一个很好的抽象工厂(Abstract Factory),也就是客户端可以将这样一个builder传给方法，使该方法能为客户端创建一个或者多个对象

    • builder也有自己的不足，就是创建对象就必须创建它的构建器。虽然创建构建器的开销在实践中可能不是很明显注意性能的情况先，这个就是问题了。

    • builder模式还比重叠构造器模式更加的冗长，因此它会在参数多的时候使用。但是我们要知道，我们可能会在设计之后还要添加参数，所以已开始就用构建器还是比较好的。

    3 总结

    如果类的构造器或者静态工厂中具有多个参数，设计这种类时，Builder模式就是不错的选择，特别是当大多数参数都是可选的时候。

    • 与重叠构造器相比，builder牧师的客户端更易与阅读和编写

    • 与JavaBeans相比，更加的安全
  • 相关阅读:
    Qt之加载QSS文件
    Qt之QSS（黑色炫酷）
    Sublime Text 2 快捷键
    QTablewidget 简单例子
    QTableview 只显示横向线
    Qt删除文件夹
    Ubuntu(Debian)apt-get
    C++中char*与wchar_t*之间的转换
    Qtl和JS、HTML通信/交互
    浅谈Socket编程
  • 原文地址：https://www.cnblogs.com/ybbzbb/p/5519258.html
Copyright © 2011-2022 走看看