在类中声明方法的首选方法

Question

我对类中用于设置信息的方法创建有怀疑。

1. 创建用于设置每个属性

   class Address{ 
       private String name; 
       private String city; 
   
       public setName(String name) { ... } 
       public setCity(String name) { ... } 
   } 
   

2. 用于设置所有创建单个方法不同的方法属性

   class Address{ 
       private String name; 
       private String city; 
   
       public setAddress(String name,String city) { ... } 
   } 
   

从以上两种方式

这在存储器点优选视图？

Answer 1

这不是一个明确的问题。你的意思是说，你宁愿有两种方法，如setFoo(String)和setBar(int)，或者一种方法如setFooBar(String, int)？这实际上取决于这些属性在逻辑上是不同的，在这种情况下，您需要单独的方法，或者它们是否经常（或仅）有意义将它们设置在一起。你可以提供两者。

对记忆没有任何影响，没有。

Answer 2

我看不出这两种方法是不同的记忆方式。

选择在班级界面中最有意义的方法。

如果两个属性在逻辑上强相关，或者有一些不想暂时中断（甚至是暂时）的类不变，我会推荐使用方法2。

在你的Address的例子中，我肯定会用两个设置方法，因为当谈到地址时，名字和城市是非常不相关的。

---

对于一般方法我会说，你是否一分为二的方法了对内存的消耗影响很小。每个对象都没有获得自己分配的一组方法。包含这些方法的内存在类的所有实例之间共享。

---

经验法则：力求使您的类的界面干净，符合逻辑的。

Answer 3

您通常会为每个属性编写一个setter和getter方法。

当一种方法足以设置所有属性时，我并不真正看到这种情况。在这种情况下，所有属性应该具有相同的值？或者你总是必须传递所有属性的参数。这两种情况都不是你想要的。所以你应该更喜欢你的第一种方法。

Answer 4

为什么不使用2

不建议你的第二个例子，因为如果添加一个新的领域地址类方法＃，那么你将它添加到现有的setter方法还是你创建新的setter方法？如果将它添加到现有的setter方法中，那么调用该方法的任何类都将被打破。如果你创建了一个新的setter方法，那么任何想要使用这个类的人都会感到困惑，为什么某些字段以这种方式组合在一起，而另一些则不是。

使用为您希望揭露

常见的做法是，在你的类，你想公开的每个字段一个setter方法每场单独的setter方法（即你的第一个例子） 。这是否是一种好的做法是值得商榷的，因为它迫使一个班级成为mutable.如果可能的话，最好让一个对象不可变，for a number of reasons。

使用构造

的一种方法，使一类不可变的初始化你的领域是摆脱的setter方法，而是让你的领域通过您的类的构造函数可设置，如下图所示。以这种方式实现它的缺点是，如果你的类有很多字段，它可能会导致大的，不可读的构造函数调用。

public class Address { 
    public String name; 
    public String city; 

    private Address(String name, String city) { 
     this.name = name; 
     this.city = city; 
    } 
} 

初始化使用Builder模式

下面是一个完全的替代实现（通过this article启发），这是Builder模式的变化你的领域。它模拟对象可变性而不牺牲可读性。

Address address = new Address.Builder() 
     .name("Mansoor's address") 
     .city("Toronto") 
     .build(); 

哪种方法使用更多的内存：

public class Address { 
    public String name; 
    public String city; 

    private Address() {} 

    private void setName(String name) { 
     this.name = name; 
    } 

    private void setCity(String city) { 
     this.city = city; 
    } 

    static class Builder { 
     private Address address = new Address(); 

     public Builder name(String name) { 
      address.setName(name); 
      return this; 
     } 

     public Builder city(String city) { 
      address.setCity(city); 
      return this; 
     } 

     public Address build() { 
      return address; 
     } 
    } 
} 

有了上面的类，你可以按如下方式创建Address类的不变实例？

从内存的角度来看，应该没有什么区别，因为内存中类的大小取决于类中的字段。由于所有三个实现都具有相同的字段，因此无论使用哪种方法，它们都应占用相同的内存空间量。

Answer 5

JavaBean标准是每个属性都有getter和setter：http://en.wikibooks.org/wiki/Java_Programming/Java_Beans。如果你不想遵循这个标准惯例，那么它对你的商店最有意义。根据这个线程的其他答案，如果有的话，可能会有最小的内存增量。

Answer 6

Nb.1毫无疑问。

而你不用手写代码，只声明你的字段。

然后你让Eclipse为你休息。

在Eclipse中使用Source - > generate getters and setters。

在对象构造函数中完成了与＃2非常相似的构造。

关于内存的更新问题。在生产代码中，不要担心这两种方式之间的内存差异。

Answer 7

常见的做法是使用JavaBean风格的

class Address { 
    private String name; 
    private String city; 

    public setName(String name){ 
    this.name = name; 
    } 

    public String getName() { 
    return name; 
    } 

    public setCity(String city){ 
    this.city = city; 
    } 

    public getCity() { 
    return city; 
    } 

}

另一种常见的做法，这是相当类似于您第二种方法是创建不可变对象。参数传递给构造函数而不是大的setter方法。

class Address { 
    private final String name; 
    private final String city; 

    public Address(String name, String city) { 
     this.name = name; 
     this.city = city; 
    } 

    public String getName() { 
    return name; 
    } 

    public getCity() { 
    return city; 
    } 
} 

从视图存储器点，差异将是第二个例子是设置在构造所有属性和所有这些属性是不可变的。一般来说，用这种方法构建的对象在被多个线程使用时更安全。

在第二示例中，没有必要进行同步。当使用标准JavaBean对象的多线程时，您需要处理同步/内存问题。