在 java 中使用 static 和编写代码的正确方法是什么

Question

我有 2 个片段：
在一个中，它全部包含在主要 class 中，并且方法和 classes 都被声明为静态的。在第二个片段中，classes 在主 class 之外，只有方法被声明为静态的。我的问题是：

什么是正确的做事方式？
因为如果它们在 main 中，则所有内容都必须是静态的，而在外部只有方法必须是静态的？

class main{  

     static class  numeri{
        int a;
        int b;
        static int result;
        
        static  void  sommaNumeri(int a, int b){
            System.out.println("contenuto della superclasse " + (a + b));
            result = ( a + b);
            System.out.println(result);
        }// end metodo sommaNumeri
    }//end class numeri

    static class  numeri2 extends numeri  {
        int c;
        int d;

        static  void  sommaNumeri2( int a, int b, int c ,int d){
            System.out.println("contenuto della sottoclasse " + (a + b + c + d));
        }// end metodo numeri2
    }// end class numeri2

    public static void main ( String args[]){
        numeri.sommaNumeri(3,5 );
        numeri2.sommaNumeri2(4, 6, 7, 9 );
        numeri2.sommaNumeri(8, 9 );
    }// end main method
}// end main class


class  numeri{
        int a;
        int b;
        static int result;
        
        static  void  sommaNumeri(int a, int b){
            System.out.println("contenuto della superclasse " + (a + b));
            result = ( a + b);
            System.out.println(result);
        }// end metodo sommaNumeri
    }//end class numeri

     class  numeri2 extends numeri  {
        int c;
        int d;

        static  void  sommaNumeri2( int a, int b, int c ,int d){
            System.out.println("contenuto della sottoclasse " + (a + b + c + d));

        }// end metodo numeri2
    }// end class numeri2


    class main{  

    public static void main ( String args[]){
        numeri.sommaNumeri(3,5 );

        numeri2.sommaNumeri2(4, 6, 7, 9 );

        numeri2.sommaNumeri(8, 9 );


    }// end main method
}// end main class

Answer 1

首先：遵守 class 名称以大写字母开头的约定。真的对我和其他人有帮助。

内部 classes 应该是静态的。示例：

class Outer {

    private int answer = 42;
    private void r() { }

    static class StaticInner {

        void p() {
            // Cannot use <var>answer</var>.
        }
    }
    
    class EmbeddedInner {

        void q() {
            answer %= 13;
            Outer.this.answer += 39;
            Outer.this.r();
        }
    }
}

Outer o = new Outer();
StaticInner si = new StaticInner();
EmbeddedInner ei = o.new EmbeddedInner();

一个非静态嵌入式 class 对象除了它的 this (EmbeddedInner.this) 外还有一个外部 class (Outer.this)。

这意味着有时了解其容器对象很有用，非静态内部 class 会自动提供这一点。但如果不需要，静态内部 class 会保留 Outer.this。事实上，序列化一个内部对象总是会序列化外部对象。

Answer 2

My question are: -what is the right way to do things? -because if they are in main everything must be static while outside only the methods must be?

做事没有唯一正确的方法，但是随着程序变得越来越复杂，您会发现通常要避免 static、非 final 变量，结果, 使用范围 static 方法将减少。

请注意，在您的示例代码中，必须为static 的唯一方法是main.main()。您选择制作各种sommaNummeri 方法static，因此能够将它们作为静态方法调用。（或者你可能决定将它们作为静态方法调用，然后发现编译器实际上要求它们 be static 才能工作。）

到 bootstrap 从 main() 方法的静态上下文到非静态上下文，您实例化一个或多个对象并在它们上调用实例方法。示例：

class Numeri {
    int result;
        
    void sommaNumeri(int a, int b) {
        System.out.println("contenuto della superclasse " + (a + b));
        result = ( a + b);
        System.out.println(result);
    }
}

class Numeri2 extends Numeri  {

    void sommaNumeri2(int a, int b, int c, int d) {
        System.out.println("contenuto della sottoclasse " + (a + b + c + d));
   }
}

class Main {  

    public static void main(String args[]) {
        Numeri2 num = new Numeri2();

        num.sommaNumeri(3, 5);
        num.sommaNumeri2(4, 6, 7, 9);
        num.sommaNumeri(8, 9);
    }
}

另请注意，根据通常的 Java 编码约定，class 名称应以首字母大写开头，如图所示。

Answer 3

在第一个片段中，您定义了所谓的内部 class。由于 class 是静态的，它的方法也是静态的，您可以使用 main.numeri 访问它，使用 main.numeri.sommaNumeri

访问它

在第二个片段中，您没有定义内部 class。您可以使用 numeri.sommaNumeri.

访问它

我想你是 Java 新人，所以你可能需要遵循 Java 基本最佳实践并在他们的 public class 中定义方法和方法自己的独立文件。它们都必须是 public 才能从定义了 main 的文件中访问。例如：

Numeri.java

public class Numeri {
    public void sommaNumeri(int a, int b) {
        System.out.println("contenuto della sottoclasse " + (a + b + c + d));
    }
}

然后你可以这样访问它：

Main.java

import my.package.Numeri;

public class Main {
    public static void main (String args[]){
         Numeri.sommaNumeri(3, 5);
    }
}

要点：class名称必须以大写字母开头。如果不遵循此命名约定，您可能会深深伤害 Java 人！

Answer 4

Java 应该是面向对象的。 static 没有什么是面向对象的。新程序员使用静态作为拐杖来避免学习 OO。作为学习者，尽可能避免静电。

新程序员使用 static 关键字的指南：

您必须将它用作入口点（main 方法），因为尚未创建任何对象。
不要相互嵌套 class。真正有用的案例很少，大多数情况下你只会让自己感到困惑。这样你就永远不需要写“static class”
仅对常量字段使用 static final。不要在需要更改的静态字段中放置任何内容。不要搞乱复杂的东西，比如懒惰的单例或持有者，也不要使用静态字段在 class 之间传递数据，因为你懒得给对象彼此引用。
对返回值是操作输入的结果的方法使用静态，这些方法没有依赖关系也没有副作用（例如，写入数据库是副作用）。
不要对任何需要覆盖的内容使用静态。静态不做多态。
如果这是上面不允许的任何其他情况，请不要对其使用静态。

Answer 5

TLDR： 'Static' 关键字应用于方法仅意味着您可以调用此方法而无需先创建 class 的实例。由于片段 1 和片段 2 都将方法声明为静态（static void sommaNumeri(int a, int b) 和 static void sommaNumeri2( int a, int b, int c ,int d)），因此这里没有真正的区别。

详细：在面向对象编程中（OOP), objects contain data and methods to operate on that data. One principal of OOP is encapsulation，它指的是访问对象的数据，它旨在通过使字段private和定义getters和setters来帮助防止不正确地使用对象。

在您的示例中，您有 2 个 class，它们都只有一个方法，并且由于该方法是静态的，您可以调用方法 sommaNumeri1 和 sommaNumeri2 而无需创建 numeri 和 numeri2 的实例。回想一下 class 是对象的蓝图，因此我们可以尝试实例化对象：

class Num { 
    private int a;
    private int b;

    public num(int a, int b) {
        this.a = a;
        this.b = b;
    }

    public void print() {
        System.out.println("sum: " + (a+b));
    }
}
...
// somewhere in a main class
public static void main(String[] args) {
    Num num1 = new Num(4,5);
    Num num2 = new Num(7,8);
    num1.print() // this should print 'sum: 9'
    num2.print() // this should print 'sum: 15'
}

但是，如果您有一个静态方法，则不需要创建任何对象（正如您在代码片段 1 和 2 中看到的，永远不要调用 new 关键字！）。

现在您在片段 1 中也有静态嵌套的 classes。这意味着 classes numeri 和 numeri2 是嵌套的，但无法访问其他成员外层 class class main。如果您要从片段 1 中 numeri 和 numeri2 的 class 定义中删除 static 关键字，对象将能够访问外部 class main.

我认为这里的答案真的取决于你想要发生什么。由于两个 classes 都只有一个静态方法，因此您可以摆脱 numeri 和 numeri2 并将方法 sommaNumeri 和 sommaNumeri2 保留在 main class。然而，嵌套 classes "is a way of logically grouping classes that are only used in one place"，所以如果你真的觉得需要嵌套 classes 你可以把它们留在那里。

如果您确实将 class 保留在 main 中，您可能需要考虑是否要将 class 保留为 static，并且这些方法是否需要是静态的（问题是，你想访问这些方法而不先创建对象吗？换句话说，你需要访问方法内部对象的数据吗？）。

希望对您有所帮助！如果有什么不清楚的地方请告诉我:D

(N.B：真正帮助我思考 java 对象的是 mathematical objects。当我意识到这一点时，我真的重新思考了很多关于 OOP 的事情！Java objects are just like vectors. Vector [1,2,3] 包含信息，表示 x=1, y=2, z=3. 你可以对向量进行操作，比如乘以 2: 2*[1 ,2,3] = [2,4,6]。要对向量执行操作，您需要一个向量。在 java 中，如果方法不是静态的，那也是一样的，您需要一个 OBJECT调用那个方法，就像你需要一个向量来做标量乘法一样。）

在 java 中使用 static 和编写代码的正确方法是什么

Which is the correct method to use static in java and to write code

java

static