创建类似结构体的对象是否完全违反了 Java 的方式？
class SomeData1 {
public int x;
public int y;
}
我可以看到一个带有访问器和修改器的类更像Java。
class SomeData2 {
int getX();
void setX(int x);
int getY();
void setY(int y);
private int x;
private int y;
}
第一个示例中的类在符号上很方便。
// a function in a class
public int f(SomeData1 d) {
return (3 * d.x) / d.y;
}
这不太方便。
// a function in a class
public int f(SomeData2 d) {
return (3 * d.getX()) / d.getY();
}
看起来很多Java开发人员不熟悉Sun Java编码规范，规范说明在Java中，如果一个类本质上是“struct”（也就是没有行为），使用公共实例变量是相当合适的。
人们倾向于认为Getter和Setter是Java的标志性特征，好像它们是Java核心的关键所在。但事实并非如此。如果你遵循Sun Java编码规范，在适当的情况下使用公共实例变量，你会写出比混杂着无用的Getter和Setter更好的代码。
Java Code Conventions 1999年发布至今未改变。
10.1 提供对实例和类变量的访问
没有充分的理由不要将任何实例或类变量设置为public。通常，实例变量不需要显式地设定或获取——通常这会随方法调用的副作用而发生。
一个合适的公共实例变量的例子是当类本质上是数据结构时(也就是说，如果Java支持struct，则使用类的实例变量是合适的）。
http://www.oracle.com/technetwork/java/javase/documentation/codeconventions-137265.html#177
http://en.wikipedia.org/wiki/Plain_old_data_structure
http://docs.oracle.com/javase/1.3/docs/guide/collections/designfaq.html#28
请理性思考。如果你有以下内容：
public class ScreenCoord2D{
public int x;
public int y;
}
那么将它们包装在getter和setter中没有太大的意义。你永远不会以其他方式存储完整像素的x、y坐标。getter和setter只会拖慢你的速度。
另一方面，使用：
public class BankAccount{
public int balance;
}
你可能希望在将来的某个时间更改余额计算方式。这应该使用getter和setter。
了解为什么要应用良好的实践是始终可取的，这样您就知道何时可以放松规则。
这是一个经常讨论的话题。在对象中创建公共字段的缺点是你无法控制设置给它的值。在有多个程序员使用相同代码的群体项目中，避免副作用非常重要。此外，有时最好返回字段对象的副本或以某种方式进行转换等。您可以在测试中模拟这些方法。如果您创建一个新类，则可能看不到所有可能的操作。这就像防御性编程 - 有一天，获取器和设置器可能会有帮助，并且创建/使用它们的成本并不高，因此有时它们非常有用。
实际上，大多数字段都有简单的getter和setter。可能的解决方案如下：
public property String foo;
a->Foo = b->Foo;
更新：在Java 7或者未来的版本中，加入对属性支持的可能性极小。不过，其他JVM语言像Groovy，Scala等现在已经支持了这一特性。- Alex Miller
private int _x;
public void x(int value) { _x = value; }
public int x() { return _x; } - Gordon为解决可变性问题，您可以将x和y声明为final。例如：
class Data {
public final int x;
public final int y;
public Data( int x, int y){
this.x = x;
this.y = y;
}
}
试图写入这些字段的调用代码将在编译时出现"field x is declared final; cannot be assigned"的错误。
客户端代码可以使用您在帖子中描述的"简写"便利性。
public class DataTest {
public DataTest() {
Data data1 = new Data(1, 5);
Data data2 = new Data(2, 4);
System.out.println(f(data1));
System.out.println(f(data2));
}
public int f(Data d) {
return (3 * d.x) / d.y;
}
public static void main(String[] args) {
DataTest dataTest = new DataTest();
}
}
case表达式中，我得到了“Case expressions must be constant expressions”的错误。如何解决这个问题？这里的惯用概念是什么？ - n611x007public 属性 当您确实需要包装类的内部行为时，请勿使用 public 属性。以 java.io.BufferedReader 为例，它具有以下字段：
private boolean skipLF = false; // If the next character is a line feed, skip it
skipLF 在所有读取方法中都会被读取和写入。如果一个在另一个线程中运行的外部类在读取过程中恶意修改了 skipLF 的状态，BufferedReader 将肯定出现故障。
public 字段以这个 Point 类为例：
class Point {
private double x;
private double y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public double getX() {
return this.x;
}
public double getY() {
return this.y;
}
public void setX(double x) {
this.x = x;
}
public void setY(double y) {
this.y = y;
}
}
Point a = new Point(5.0, 4.0);
Point b = new Point(4.0, 9.0);
double distance = Math.sqrt(Math.pow(b.getX() - a.getX(), 2) + Math.pow(b.getY() - a.getY(), 2));
这个类除了简单的getter和setter之外没有任何行为。当类仅表示数据结构，并且没有以及永远不会有任何行为时，使用公共字段是可以接受的（这里认为仅存在thin getters和setters不是行为）。可以用以下方式更好地编写：
class Point {
public double x;
public double y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
}
Point a = new Point(5.0, 4.0);
Point b = new Point(4.0, 9.0);
double distance = Math.sqrt(Math.pow(b.x - a.x, 2) + Math.pow(b.y - a.y, 2));
清理！
但请记住：不仅您的类必须没有行为，而且它将来也不应该有任何行为。
这正是此答案所描述的。引用《Java编程语言代码规范：10. 编程实践》的话：
公共实例变量的一个适当用法示例是，如果类本质上是一个数据结构，没有行为。换句话说，如果Java支持
struct，则使用struct而不是类是适当的，并且可以将类的实例变量设置为public。
因此，官方文档也接受这种做法。
此外，如果您非常确定上述Point类的成员应该是不可变的，那么您可以添加final关键字来强制执行：
public final double x;
public final double y;
java.awt.Point。它有公共字段x和y，可以自行查看。public final字段完成，就像在Brian的答案中所述，或者通过具有公共getter但没有公共setter来完成。也就是说，无论是使用字段还是访问器都是无关紧要的。 - ToolmakerSteve关于 aku, izb, John Topley 的回复...
注意可变性问题...
省略getter/setter可能看起来是明智的。在某些情况下，这实际上可能是可以接受的。这里所展示的提议模式的真正问题是可变性。
问题在于一旦你传递一个包含非final、公共字段的对象引用。任何其他使用该引用的东西都可以自由地修改这些字段。你不再对该对象的状态有任何控制。(想象一下如果字符串是可变的会发生什么。)
当该对象是另一个对象的重要内部状态时，情况就变得很糟糕了，你刚刚暴露了内部实现。为了防止这种情况，必须返回对象的副本。这样做是有效的，但可能会导致大量单次使用的副本产生巨大的GC压力。
如果你有公共字段，请考虑使类只读。将这些字段添加为构造函数的参数，并将它们标记为final。否则，请确保不要暴露内部状态，并且如果需要为返回值构造新实例，请确保不会被过度调用。
参见：Joshua Bloch的 "Effective Java" - 条款＃13：支持不可变性。
提示：同时请记住，现今所有的JVM都会尽可能地优化getMethod方法，从而只产生一条字段读取指令。
只要作者知道它们是structs（或数据传输器）而不是对象，那种类型的代码就没有问题。许多Java开发人员无法区分良好构造的对象（不仅仅是java.lang.Object的子类，而是特定领域中的真正对象）和菠萝之间的区别。因此，当他们需要对象时却编写了structs，反之亦然。