14

我正在对一位同事（另一位学生）的 Java 代码进行“静态”代码演练

对我来说，这没有意义。从上到下读取这些“组件”对象在声明之前被实例化（然后在构造函数中使用）。但是，代码可以愉快地编译和运行。这是不好的做法吗？

Public Class theObject {

    private static final long aVariable = 123123123123123;

    public theObject(...){

        componentOne = new Component(...);
        componentTwo = new Component(...);

        ...
        ...
        componentOne.doSomething(...);
    }

    private Component componentOne;
    private Component componentTwo;
}
4

7 回答 7

46

Sun Microsystems（现在由 Oracle 接管）于 1998 年发布了其Java 编码风格指南，其中他们推荐了一个特定的组织来分类声明：

  1. 静态变量字段声明
  2. 实例变量字段声明
  3. 静态初始化器
  4. 静态成员内部类声明 [*]
  5. 静态方法声明
  6. 实例初始化器
  7. 实例构造函数声明
  8. 实例成员内部类声明 [*]
  9. 实例方法声明

请注意，这会将数据声明放在文件的顶部。（1997 年的早期 Sun 出版物并未涵盖上述列表中的所有内容。）唯一重要的顺序是在静态字段和实例字段内，并且仅当字段包含引用其他字段的初始化程序时。在初始化之前，您不能在初始化程序中使用字段。类似地，初始化器（第 3 项或第 6 项）不能对字段进行前向引用，除非作为赋值的目标。（有关此类前向引用的更多信息，请参阅Java 语言规范的第 8.3.3 节。）据我所知，顺序无关紧要。

[*] 上面列表中的术语（从 1998 年指南逐字记录）对于第 4 和第 8 项已经过时。具体来说，来自Java 嵌套类教程：

术语：嵌套类分为两类：静态和非静态。声明的嵌套类static称为静态嵌套类。非静态嵌套类称为内部类。

在现代用法中，没有“静态成员内部类”之类的东西。

于 2012-04-22T01:28:26.403 回答
10

java中的一般声明顺序，（参考：Java Coding Style Guide）

     public class DeclarationOrder {

        // Class (static) variables
        public static int publicClassVariable;
        protected static int protectedClassVariable;
        static int defaultClassVariable;
        private static int privateClassVariable;

        // Instance variables
        public int publicInstanceVariable;
        protected int protectedInstanceVariable;
        int defaultInstanceVariable;
        private int privateInstanceVariable;

        // Constructors
        public DeclarationOrder() {
            // Public Constructor
        }
        protected DeclarationOrder(int var) {
            // Protected Constructor
        }
        DeclarationOrder(String var) {
            // Default Constructor
        }
        private DeclarationOrder(Double var) {
            // private Constructor
        }

        // Class (static) Methods
        public static void publicClassMethod(){}
        protected static void protectedStaticMethod(){}
        static void defaultStaticMethod() {}
        private static void privateStaticMethod(){}

        // Instance Methods
        public void publicInstaceMethod() {}
        protected void protectedInstanceMethod() {}
        void defaultInstanceMethod() {}
        private void privateInstanceMethod() {}
    }

每组内的顺序应该是，

  1. 上市
  2. 受保护
  3. 包级别（无访问修饰符）
  4. 私人的
于 2016-09-01T07:41:18.733 回答
9

对此没有真正的共识。大多数人会在类实现的顶部声明类变量，然后是方法，但这不是必需的。一些像 Code Complete 这样的书建议在第一次使用时尽可能地声明变量。这有助于将变量的范围缩小到最小。

于 2012-04-22T01:23:43.777 回答
5

不，它们在声明之前没有被实例化。初始化的顺序在 Java 中是固定的，在代码中放置声明和构造函数的位置无关紧要。

至于约定，这实际上取决于您对什么感到满意。虽然事实上惯例是先声明文件，然后是构造函数，但您的方法与其他方法一样有效，只要它不违反您的性质或公司规定。

此外，在代码中放入更多危险的东西会降低可读性，例如单字母变量或广泛使用不太常见的结构（例如，用于复杂条件的三元运算符）。组织代码是次要问题之一，因为任何体面的 IDE 都可以通过您放置的任何设置重新组织代码。

于 2012-04-22T01:24:21.013 回答
3

声明类成员（方法、属性）的顺序无关紧要。按照惯例，通常首先声明所有属性和常量，然后声明方法。

例如，在您的代码中：可以在构造函数中初始化属性然后声明属性，这仅仅是因为编译类时将考虑所有属性声明，然后当实际调用构造函数时，属性会被发现。请注意，在编译时不会访问构造函数中的属性，这就是它们不会产生错误的原因；它们只能在运行时访问。

于 2012-04-22T01:21:13.070 回答
2

它违反了正常的约定，并且（因此）对于那些期望遵循正常约定的人来说，它使代码的可读性降低了……即大多数 Java 程序员。

另一方面，如果代码始终如一地执行此操作，并且遵循商定的本地编码约定，那么读者就会习惯它。

因此， “这是不好的做法吗？”这个问题的答案。是它取决于您同意的编码约定，以及它对此的说法。

但元答案是，在没有商定的编码约定的情况下进行代码审查是一个非常糟糕的主意。如果没有编码约定，就没有审查代码风格的客观依据。你很可能会得到一个糟糕的结果。

于 2012-04-22T01:26:36.643 回答
2

主要 Java 语言规范在第 8.1.1、8.3.1 和 8.4.3 节中定义了我们必须使用的以下流程：

  1. 上市
  2. 受保护
  3. 私人的
  4. 抽象的
  5. 静止的
  6. 最终的
  7. 短暂的
  8. 易挥发的
  9. 同步的
  10. 本国的
  11. 严格的fp

当我们用 Java 编写代码时，我们必须使用这个顺序；）

链接到 Java 语言规范

于 2016-04-25T09:08:08.237 回答