Java方法参数太多怎么办—Part3—Builder模式

最新推荐文章于 2023-10-17 09:24:15 发布
最新推荐文章于 2023-10-17 09:24:15 发布
阅读量666 收藏 1
点赞数
分类专栏： java学习

在前两篇文章中，我分别使用了自定义类型和参数对象方法来减少构造器或方法调用传入的参数数量。本文关注的是Builder模式。我认为它不仅能够帮助构造函数“瘦身”，甚至可以对非构造函数也能发挥同样的作用。

在Effective Java第二版中，Josh Bloch在第二章中就提到使用Builder模式处理需要很多参数的构造函数。他不仅展示了Builder的使用，也描述了相这种方法相对使用带很多参数的构造函数带来的好处。在本文的结尾我将进一步总结Builde模式的优点。需要指出的是Josh Bloch已经在他的书本贯穿了这一思想。

为了说明这种方法的优点，我会继续使用Person类。需要指出的是，为了更好地聚焦于类构造本身我只添加了个别方法。

Person.java （非Builder模式）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package dustin.examples;
 
/**
  * Person class used as part of too many parameters demonstration.
  *
  * @author Dustin
  */
public class Person
{
    private final String lastName;
    private final String firstName;
    private final String middleName;
    private final String salutation;
    private final String suffix;
    private final String streetAddress;
    private final String city;
    private final String state;
    private final boolean isFemale;
    private final boolean isEmployed;
    private final boolean isHomewOwner;
 
    public Person(
       final String newLastName,
       final String newFirstName,
       final String newMiddleName,
       final String newSalutation,
       final String newSuffix,
       final String newStreetAddress,
       final String newCity,
       final String newState,
       final boolean newIsFemale,
       final boolean newIsEmployed,
       final boolean newIsHomeOwner)
    {
       this .lastName = newLastName;
       this .firstName = newFirstName;
       this .middleName = newMiddleName;
       this .salutation = newSalutation;
       this .suffix = newSuffix;
       this .streetAddress = newStreetAddress;
       this .city = newCity;
       this .state = newState;
       this .isFemale = newIsFemale;
       this .isEmployed = newIsEmployed;
       this .isHomewOwner = newIsHomeOwner;
    }
}

这样写的类构造器也无可厚非，但当有许多参数时编写客户端代码会很困难。这时，如果使用Builder模式会有效提高代码的可读性。在我的博客中曾写过使用NetBeans能方便地实现代码重构。下面就是使用NetBeans重构过的代码。

PersonBuilder.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
package dustin.examples;
 
public class PersonBuilder
{
    private String newLastName;
    private String newFirstName;
    private String newMiddleName;
    private String newSalutation;
    private String newSuffix;
    private String newStreetAddress;
    private String newCity;
    private String newState;
    private boolean newIsFemale;
    private boolean newIsEmployed;
    private boolean newIsHomeOwner;
 
    public PersonBuilder()
    {
    }
 
    public PersonBuilder setNewLastName(String newLastName) {
       this .newLastName = newLastName;
       return this ;
    }
 
    public PersonBuilder setNewFirstName(String newFirstName) {
       this .newFirstName = newFirstName;
       return this ;
    }
 
    public PersonBuilder setNewMiddleName(String newMiddleName) {
       this .newMiddleName = newMiddleName;
       return this ;
    }
 
    public PersonBuilder setNewSalutation(String newSalutation) {
       this .newSalutation = newSalutation;
       return this ;
    }
 
    public PersonBuilder setNewSuffix(String newSuffix) {
       this .newSuffix = newSuffix;
       return this ;
    }
 
    public PersonBuilder setNewStreetAddress(String newStreetAddress) {
       this .newStreetAddress = newStreetAddress;
       return this ;
    }
 
    public PersonBuilder setNewCity(String newCity) {
       this .newCity = newCity;
       return this ;
    }
 
    public PersonBuilder setNewState(String newState) {
       this .newState = newState;
       return this ;
    }
 
    public PersonBuilder setNewIsFemale( boolean newIsFemale) {
       this .newIsFemale = newIsFemale;
       return this ;
    }
 
    public PersonBuilder setNewIsEmployed( boolean newIsEmployed) {
       this .newIsEmployed = newIsEmployed;
       return this ;
    }
 
    public PersonBuilder setNewIsHomeOwner( boolean newIsHomeOwner) {
       this .newIsHomeOwner = newIsHomeOwner;
       return this ;
    }
 
    public Person createPerson() {
       return new Person(newLastName, newFirstName, newMiddleName, newSalutation, newSuffix, newStreetAddress, newCity, newState, newIsFemale, newIsEmployed, newIsHomeOwner);
    }
 
}

相对于之前的写法，我更趋向于将builder作为它构建类的静态成员类（嵌套类）。即便是NetBeans自动生成的Builder使用起来也很方便。另一个区别在于，我希望Builder实现一个包含了必要字段的构造函数，而不是一个无参构造函数。

下面显示的是改进后的代码。

Person.java（Person.Builder嵌套类）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
package dustin.examples;
 
/**
  * Person class used as part of too many parameters demonstration.
  *
  * @author Dustin
  */
public class Person
{
    private final String lastName;
    private final String firstName;
    private final String middleName;
    private final String salutation;
    private final String suffix;
    private final String streetAddress;
    private final String city;
    private final String state;
    private final boolean isFemale;
    private final boolean isEmployed;
    private final boolean isHomewOwner;
 
    public Person(
       final String newLastName,
       final String newFirstName,
       final String newMiddleName,
       final String newSalutation,
       final String newSuffix,
       final String newStreetAddress,
       final String newCity,
       final String newState,
       final boolean newIsFemale,
       final boolean newIsEmployed,
       final boolean newIsHomeOwner)
    {
       this .lastName = newLastName;
       this .firstName = newFirstName;
       this .middleName = newMiddleName;
       this .salutation = newSalutation;
       this .suffix = newSuffix;
       this .streetAddress = newStreetAddress;
       this .city = newCity;
       this .state = newState;
       this .isFemale = newIsFemale;
       this .isEmployed = newIsEmployed;
       this .isHomewOwner = newIsHomeOwner;
    }
 
    public static class PersonBuilder
    {
       private String nestedLastName;
       private String nestedFirstName;
       private String nestedMiddleName;
       private String nestedSalutation;
       private String nestedSuffix;
       private String nestedStreetAddress;
       private String nestedCity;
       private String nestedState;
       private boolean nestedIsFemale;
       private boolean nestedIsEmployed;
       private boolean nestedIsHomeOwner;
 
       public PersonBuilder(
          final String newFirstName,
          final String newCity,
          final String newState)
       {
          this .nestedFirstName = newFirstName;
          this .nestedCity = newCity;
          this .nestedState = newState;
       }
 
       public PersonBuilder lastName(String newLastName)
       {
          this .nestedLastName = newLastName;
          return this ;
       }
 
       public PersonBuilder firstName(String newFirstName)
       {
          this .nestedFirstName = newFirstName;
          return this ;
       }
 
       public PersonBuilder middleName(String newMiddleName)
       {
          this .nestedMiddleName = newMiddleName;
          return this ;
       }
 
       public PersonBuilder salutation(String newSalutation)
       {
          this .nestedSalutation = newSalutation;
          return this ;
       }
 
       public PersonBuilder suffix(String newSuffix)
       {
          this .nestedSuffix = newSuffix;
          return this ;
       }
 
       public PersonBuilder streetAddress(String newStreetAddress)
       {
          this .nestedStreetAddress = newStreetAddress;
          return this ;
       }
 
       public PersonBuilder city(String newCity)
       {
          this .nestedCity = newCity;
          return this ;
       }
 
       public PersonBuilder state(String newState)
       {
          this .nestedState = newState;
          return this ;
       }
 
       public PersonBuilder isFemale( boolean newIsFemale)
       {
          this .nestedIsFemale = newIsFemale;
          return this ;
       }
 
       public PersonBuilder isEmployed( boolean newIsEmployed)
       {
          this .nestedIsEmployed = newIsEmployed;
          return this ;
       }
 
       public PersonBuilder isHomeOwner( boolean newIsHomeOwner)
       {
          this .nestedIsHomeOwner = newIsHomeOwner;
          return this ;
       }
 
       public Person createPerson()
       {
          return new Person(
             nestedLastName, nestedFirstName, nestedMiddleName,
             nestedSalutation, nestedSuffix,
             nestedStreetAddress, nestedCity, nestedState,
             nestedIsFemale, nestedIsEmployed, nestedIsHomeOwner);
       }
    }
}

使用Builder模式时，如果结合我前两篇文章介绍的自定义类型和参数对象方法一起使用效果会更好。示例代码如下。

Person.java （嵌套类Builder，自定义类型加参数对象）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
package dustin.examples;
 
/**
  * Person class used as part of too many parameters demonstration.
  *
  * @author Dustin
  */
public class Person
{
    private final FullName name;
    private final Address address;
    private final Gender gender;
    private final EmploymentStatus employment;
    private final HomeownerStatus homeOwnerStatus;
 
    /**
     * Parameterized constructor can be private because only my internal builder
     * needs to call me to provide an instance to clients.
     *
     * @param newName Name of this person.
     * @param newAddress Address of this person.
     * @param newGender Gender of this person.
     * @param newEmployment Employment status of this person.
     * @param newHomeOwner Home ownership status of this person.
     */
    private Person(
       final FullName newName, final Address newAddress,
       final Gender newGender, final EmploymentStatus newEmployment,
       final HomeownerStatus newHomeOwner)
    {
       this .name = newName;
       this .address = newAddress;
       this .gender = newGender;
       this .employment = newEmployment;
       this .homeOwnerStatus = newHomeOwner;
    }
 
    public FullName getName()
    {
       return this .name;
    }
 
    public Address getAddress()
    {
       return this .address;
    }
 
    public Gender getGender()
    {
       return this .gender;
    }
 
    public EmploymentStatus getEmployment()
    {
       return this .employment;
    }
 
    public HomeownerStatus getHomeOwnerStatus()
    {
       return this .homeOwnerStatus;
    }
 
    /**
     * Builder class as outlined in the Second Edition of Joshua Bloch's
     * <em><span class="wp_keywordlink"><a href="http://www.amazon.com/gp/product/B000WJOUPA/ref=as_li_qf_sp_asin_il_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=B000WJOUPA&linkCode=as2&tag=job0ae-20" title="Effective Java" rel="nofollow" target="_blank" class="external">Effective Java</a></span></em> that is used to build a {@link Person} instance.
     */
    public static class PersonBuilder
    {
       private FullName nestedName;
       private Address nestedAddress;
       private Gender nestedGender;
       private EmploymentStatus nestedEmploymentStatus;
       private HomeownerStatus nestedHomeOwnerStatus;
 
       public PersonBuilder(
          final FullName newFullName,
          final Address newAddress)
       {
          this .nestedName = newFullName;
          this .nestedAddress = newAddress;
       }
 
       public PersonBuilder name( final FullName newName)
       {
          this .nestedName = newName;
          return this ;
       }
 
       public PersonBuilder address( final Address newAddress)
       {
          this .nestedAddress = newAddress;
          return this ;
       }
 
       public PersonBuilder gender( final Gender newGender)
       {
          this .nestedGender = newGender;
          return this ;
       }
 
       public PersonBuilder employment( final EmploymentStatus newEmploymentStatus)
       {
          this .nestedEmploymentStatus = newEmploymentStatus;
          return this ;
       }
 
       public PersonBuilder homeOwner( final HomeownerStatus newHomeOwnerStatus)
       {
          this .nestedHomeOwnerStatus = newHomeOwnerStatus;
          return this ;
       }
 
       public Person createPerson()
       {
          return new Person(
             nestedName, nestedAddress, nestedGender,
             nestedEmploymentStatus, nestedHomeOwnerStatus);
       }
    }
}

最后2段代码列表展示了Builder构建对象的常见方法。实际上，《在Effective Java 第二版》第2条中就是用Builder来创建和销毁对象。此外，Builder能更简单地通过参数对象传递间接实现了一个非构造函数方法。在上面最后一段代码中，这些方法都接收了一些参数对象。诚然，即使使用了Builder构建参数对象还是比较枯燥的。但每一次Builder构建都是间接让非构造函数方法受益，因为参数对象使用确实有效减少了方法参数的数量。

下面重新定义的FullName和Address类既能做参数本身也使用了Builder模式。

FullName.java（使用Builder）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
package dustin.examples;
 
/**
  * Full name of a person.
  *
  * @author Dustin
  */
public final class FullName
{
    private final Name lastName;
    private final Name firstName;
    private final Name middleName;
    private final Salutation salutation;
    private final Suffix suffix;
 
    private FullName(
       final Name newLastName,
       final Name newFirstName,
       final Name newMiddleName,
       final Salutation newSalutation,
       final Suffix newSuffix)
    {
       this .lastName = newLastName;
       this .firstName = newFirstName;
       this .middleName = newMiddleName;
       this .salutation = newSalutation;
       this .suffix = newSuffix;
    }
 
    public Name getLastName()
    {
       return this .lastName;
    }
 
    public Name getFirstName()
    {
       return this .firstName;
    }
 
    public Name getMiddleName()
    {
       return this .middleName;
    }
 
    public Salutation getSalutation()
    {
       return this .salutation;
    }
 
    public Suffix getSuffix()
    {
       return this .suffix;
    }
 
    @Override
    public String toString()
    {
       return  this .salutation + " " + this .firstName + " " + this .middleName
             + this .lastName + ", " + this .suffix;
    }
 
    public static class FullNameBuilder
    {
       private final Name nestedLastName;
       private final Name nestedFirstName;
       private Name nestedMiddleName;
       private Salutation nestedSalutation;
       private Suffix nestedSuffix;
 
       public FullNameBuilder(
          final Name newLastName, final Name newFirstName)
       {
          this .nestedLastName = newLastName;
          this .nestedFirstName = newFirstName;
       }
 
       public FullNameBuilder middleName( final Name newMiddleName)
       {
          this .nestedMiddleName = newMiddleName;
          return this ;
       }
 
       public FullNameBuilder salutation( final Salutation newSalutation)
       {
          this .nestedSalutation = newSalutation;
          return this ;
       }
 
       public FullNameBuilder suffix( final Suffix newSuffix)
       {
          this .nestedSuffix = newSuffix;
          return this ;
       }
 
       public FullName createFullName()
       {
          return new FullName(
             nestedLastName, nestedFirstName, nestedMiddleName,
             nestedSalutation, nestedSuffix);
       }
    }
}

Address.java （使用Builder）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
package dustin.examples;
 
/**
  * Representation of a United States address.
  *
  * @author Dustin
  */
public final class Address
{
    private final StreetAddress streetAddress;
    private final City city;
    private final State state;
 
    private Address( final StreetAddress newStreetAddress, final City newCity, final State newState)
    {
       this .streetAddress = newStreetAddress;
       this .city = newCity;
       this .state = newState;
    }
 
    public StreetAddress getStreetAddress()
    {
       return this .streetAddress;
    }
 
    public City getCity()
    {
       return this .city;
    }
 
    public State getState()
    {
       return this .state;
    }
 
    @Override
    public String toString()
    {
       return this .streetAddress + ", " + this .city + ", " + this .state;
    }
 
    public static class AddressBuilder
    {
       private StreetAddress nestedStreetAddress;
       private final City nestedCity;
       private final State nestedState;
 
       public AddressBuilder( final City newCity, final State newState)
       {
          this .nestedCity = newCity;
          this .nestedState = newState;
       }
 
       public AddressBuilder streetAddress( final StreetAddress newStreetAddress)
       {
          this .nestedStreetAddress = newStreetAddress;
          return this ;
       }
 
       public Address createAddress()
       {
          return new Address(nestedStreetAddress, nestedCity, nestedState);
       }
    }
}

由于用了Builder，新的Person实例可以通过下面这种方式创建。当然为了比较，也给出了传统的Person实例化方法。

1
2
3
4
5
6
7
8
9
10
11
12
final Person person1 = new Person.PersonBuilder(
    new FullName.FullNameBuilder(
       new Name( "Dynamite" ), new Name( "Napoleon" )).createFullName(),
    new Address.AddressBuilder(
       new City( "Preston" ), State.ID).createAddress()).createPerson();
 
final Person person2 = new Person.PersonBuilder(
    new FullName.FullNameBuilder(
       new Name( "Coltrane" ), new Name( "Rosco" )).middleName( new Name( "Purvis" )).createFullName(),
    new Address.AddressBuilder(
       new City( "Hazzard" ), State.GA).createAddress())
       .gender(Gender.MALE).employment(EmploymentStatus.EMPLOYED).createPerson();

实例化Person（不使用Builder）

final person = new Person(“Coltrane”, “Rosco”, “Purvis”, null, “Hazzard”, “Georgia”, false, true, true);

看完代码高下立判，调用传统JAVA构造器的客户端代码的可读性远不如使用了Builder的客户端代码。同一类型的变量和空放置在一起被调用将会导致一些微妙的错误。（试想，如果客户端不小心颠倒了其中的几个参数顺序，编译不会出错但在运行时肯定出错）

Builder模式好处和优点

使用Builder模式必然会导致写两遍相关属性的代码和SETTER方法，看起来有点吃力不讨好。然而需要看到的是，客户端代码的可用性和可读性得到了大大提高。与此同时，构造函数的参数数量明显减少调用起来非常直观。

Builder方法另外一个优势在于，单个builder构建多个对象时Builder参数可在创建期间进行调整，还可以根据对象不同而进行改变。这就像我越来越推崇的以“不变”应“万变”。Builder模式特别适合那些属性个数很多的类，我认为没有必要给那些本不需要设置值传递参数（设置null）。

Builder模式在提高代码可读性的同时，使用IDE提供的代码补全功能也更加容易。Builder模式在与构造函数一起使用带来的更大优势在Josh Bloch的Effective Java第二版第2条中有详细阐述。

Builder模式的代价和缺点

使用Builder模式是肯定会增加代码量的。此外，尽管客户端的代码可读性明显改善，但随之而来的客户端代码变得更加冗长。我还是坚持这一观点：相比较参数数量的增加，相同类型的参数混在一起，可选参数的增加而言，改善代码可读性更有价值。

Builder会增加个类代码，这也意味着开发者在给类增加属性时有时会忘记给该属性添加支持的builder。为了克服这个问题，通常我会将builder嵌套到类中，这样可以很容易地发现哪个相关的builder需要更新。尽管忘记的风险依旧存在，但是这风险就像忘记给类的新属性增加toString()、 equals(Object)、 hashCode()或其他类基于是所有属性的方法一样。

在我的Builder实现中，我会用Builder的构造函数而不是set方法传递客户需要的属性。这样做的好处在于，对象总是能被一次完整的实例化，而不是靠开发人员调用时用set方法补充额外的属性完成实例化。这也体现了不可变性带来的好处。然而，相应地也会造成自己设定的属性方法可读性降低。

正如它名字表示的那样，Builder只是一个替代构造器的选择不能直接用于降低非构造函数方法的参数数量，但是结合参数对象的使用就能达到这一点。有关更多反对用Builder来进行对象构建的讨论可以参见 A dive into the Builder pattern上的相关评论。

总结

构建对象时，如果碰到类有很多参数——其中很多参数类型相同而且很多参数可以为空时，我更喜欢Builder模式来完成。当参数数量不多、类型不同而且都是必须出现时，通过增加代码实现Builder往往无法体现它的优势。在这种情况下，理想的方法是调用传统的构造函数。再者，如果不需要保持不变，那么就使用无参构造函数调用相应的set方法吧。

打不赢jiu跑
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java enum 参数过多_Java方法参数太多怎么办—Part 1—自定义类型
weixin_35927318的博客
02-13 975
本文由ImportNew-王村平翻译自dzone。如需转载本文，请先参见文章末尾处的转载要求。本文是这个系列的第一篇文章，介绍了采用自定义类型处理参数过多的问题。如果你也希望参与类似的系列文章翻译，可以加入我们的Android开发和技术翻译小组。我认为构造函数和方法过长的传递参数列表是一种红色警告(”redflag“)。在开发过程中，从逻辑的和功能的角度来看并非错误，但是通常意味着...
举例讲解Java设计模式编程中模板方法模式的运用实例
09-02
模板方法模式是面向对象设计模式中的一种，它属于行为模式，主要目的是为了实现代码复用，同时保持算法的结构不变。...在Java等支持多态性的语言中，模板方法模式是构建可维护和可扩展软件的重要手段。
静态初始化工厂
kuyuyingzi的专栏
11-30 1647
在实例化过程中，通过不同的描述性方法名来显示哪些参数需要传递。在一些情况下，哪些参数可以由方法名知道无需传递。新手可能会觉得这种方法无法用于对象实例化和初始化，理由是Java中类的构造函数必须与类同名相同。这意味着构造函数仅能通过同名函数重载。幸运的是，Josh Bloch在每一版Effective Java的第一章都会解释这个问题。按照Bloch的说法，我们可以使用静态初始化工厂实例化类。这
Java方法参数太多怎么办—Part 2—引入参数对象
whaixhcx的专栏
02-07 786
在前一篇文章中，我关注了一些关于构造函数或方法参数过多的问题。文中我讨论了用自定义类型代替基本、内置类型以获得良好的可读性和安全性。然而这并不能减少参数的数量。这次，我将用参数对象方法给构造函数和方法的参数“瘦身”。 通常你会看到一组特定参数，它们关系紧密并且总是一起传给方法或构造函数，有可能好几个函数都使用这一组参数。这些函数可能属于同一个类，也可能属于不同的类。 这时，《重构》这本
Java方法参数太多怎么办—Part4—重载
whaixhcx的专栏
02-07 716
在Java编程中，如果一个方法带太多的参数被会给调用者带来很多困扰。调用者必须考虑是否按照正确的参数顺序给传入合适的值。在前面的文章中，先后探讨了通过自定义类型、参数对象、Builder模式来解决这个问题。还有一种方法，也是今天探讨的主题——通过方法重载来应对各种不同需求。与往常一样，在文章最后我会对重载的优缺点进行总结。 Java支持方法重载，可以通过方法签名来区分同名方法之间是否重载。请
Java方法参数过多
evilcry2013的博客
12-21 5131
Java方法参数过多   西门狂野 关注 2016.04.15 16:08* 字数 764 阅读 1003评论 1喜欢 4 重构--Java方法参数过多 示例方法 public void getNews(Context context, Callback callback,
疯狂Java讲义(第3版).part2
02-08
疯狂Java讲义(第3版).part2疯狂Java讲义(第3版).part2疯狂Java讲义(第3版).part2疯狂Java讲义(第3版).part2疯狂Java讲义(第3版).part2疯狂Java讲义(第3版).part2疯狂Java讲义(第3版).part2疯狂Java讲义(第3版).part2...
疯狂Java讲义 第3版.part3
10-18
疯狂Java讲义 第3版.part3
Java与模式(清晰书签版).part3
03-21
共三部分 Java与模式(清晰书签版).part3
设计模式 t06Builder
06-11
在Java中应用建造者模式，可以帮助我们更好地控制对象的创建，特别是在对象的构造过程复杂时，避免了在构造函数中传递大量参数的尴尬。 建造者模式的核心结构包括四个部分： 1. **产品（Product）**：这是要构建的...
【JVM和性能优化】4. 编写高效优雅Java代码常用方法
12-22
文章目录1. 构造器参数太多怎么办2. 不需要实例化的类构造器要私有化3. 不要创建不必要对象4. 避免使用终结方法5. 类跟成员的可访问性最小化6. 使可变性最小化7. 优先使用复合胜过继承8.接口优于抽象类9. 可变参数谨慎使用10. 尽量不要返回NULL,尽量返回零数组或集合11.优先使用标准异常12.尽量使用枚举替换int13. 局部变量作用域最小化14. 对于精度技术不用float或double15.字符串操作少用String16.对资源的close建议分开操作17. 数据类型转换18. 不用的对象记得置NULL19. if判断常量在前20. 字符串变量比较的时候21. 同步方法跟同
java的方法参数很多_Java方法参数太多怎么办
weixin_32701893的博客
02-16 1407
展开全部引入参数对象Person.classpublic class Person {public FullName fullName;public Address address;public boolean isFemale;public boolean isEmployed;public boolean isHomeOwner;public Person(FullName fullName,...
Java方法中的参数太多，第8部分：工具
最佳 Java 编程
05-18 627
在我的系列文章的前七篇文章中，有关处理Java方法中期望的参数过多的内容集中在减少方法或构造函数期望的参数数量的替代方法上。 在本系列的第八篇文章中，我将介绍一些工具，这些工具可帮助您确定可能存在过多参数的情况，并在出现这种情况时帮助对其进行处理。 对于方法或构造函数中过多的参数，实际上并没有硬性规定 。 在许多方面，这都是一个问题，在某种程度上取决于这些参数是什么，它们是否使用自定义类...
java.函数参数太多,Java方法参数太多怎么办—Part 2—引入参数对象，javapart
weixin_39653311的博客
03-21 514
Java方法参数太多怎么办—Part 2—引入参数对象，javapart目录自定义类型引入参数对象本文是这个系列的第二篇文章，介绍了通过引入参数对象应对参数过多的问题。如果你也希望参与类似的系列文章翻译，可以加入我们的Android开发 和 技术翻译 小组。在前一篇文章中，我关注了一些关于构造函数或方法参数过多的问题。文中我讨论了用自定义类型代替基本、内置类型以获得良好的可读性和安全性。然而这并不...
effective java 当构造方法参数过多时使用 builder 模式的理解
yinhaoh的博客
05-15 189
java builder 模式Builder 模式Java return this 在effactive java上看到说当构造方法参数过多时使用builder模式，然后发现提供的set模板的Builder只需要return this。所以想了解一下细节以及差异。 JavaBeans模式本身有严重的缺陷。由于构造方法被分割成多次调用，所以在构造过程中JavaBean可能处于不一致状态。该类仅有通过检查构造函数参数的有效性，而没有强制的一致性措施。在不一致的状态下尝试使用对象可能导致一些错误，这些错误与平
java类中方法中的参数过多如何处理
热门推荐
evilcry2012的专栏
11-20 1万+
java类中方法中的参数过多如何处理 [问题点数：30分，结帖人nihao6154]             不显示删除回复           显示所有回复            显示星级回复           显示得分回复            只显示楼主          收藏 nihao6154 nihao6154 
JAVA解决:传入的请求具有过多的参数。该服务器支持最多 2100 个参数。请减少参数的数目，然后重新发送该请求。
最新发布
monicateacat的博客
10-17 868
JAVA解决:传入的请求具有过多的参数。该服务器支持最多 2100 个参数。请减少参数的数目，然后重新发送该请求。
重构思路-java方法参数过多
weixin_43599827的博客
12-14 1435
参数个数件衣4个或以下，参数过多时要考虑减少参数。
java 方法参数过多解决方法
saydo
01-06 5483
http://www.importnew.com/8926.html
掌握Java建造者模式：概念、代码示例与应用
建造者模式是一种在软件设计中广泛应用的创建型设计模式，其核心目标是将复杂对象的构建过程与其实现细节解耦。该模式允许开发者在构造过程中逐步添加组件，同时保持代码的灵活性和可读性，特别适用于构建具有复杂...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值