java：静态和非静态函数调用方法

我有一门课：

public class C1{
  public int v=10;
  public int myFunction1(){
       // some code
  }
}

要调用

myFunction1（）

，我们使用：

C1 ob = new C1();
ob.myFunction1();
ob.v;

C1.myFunction1();
C1.v;

“静态”也是这样：

public class C1{
  public static int v=10;
  public static int myFunction1(){
       // some code
  }
}

要调用

myFunction1（）

，我们使用：

C1 ob = new C1();
ob.myFunction1();
ob.v;

C1.myFunction1();
C1.v;

---

所以我的问题是这两种方法的区别是什么。什么时候使用

静态方法好？两者的技术优势和劣势是什么？
静态
成员由所有实例共享，因此如果创建两个实例，则两个htem将共享v的值。静态/非静态没有任何优点和缺点，这取决于需要。如果希望一个属性的值由所有实例共享，则将其标记为静态；如果希望每个实例都有自己的属性值，则将其标记为非静态。
static
成员由所有实例共享，因此如果创建两个实例，则两个htem都将共享v的值。静态/非静态没有任何优点和缺点，这取决于需要。如果希望一个属性的值由所有实例共享，则将其标记为静态；如果希望每个实例都有自己的属性值，则将其标记为非静态。
static
成员由所有实例共享，因此如果创建两个实例，则两个htem都将共享v的值。静态/非静态没有任何优点和缺点，这取决于需要。如果希望一个属性的值由所有实例共享，则将其标记为静态；如果希望每个实例都有自己的属性值，则将其标记为非静态。
static
成员由所有实例共享，因此如果创建两个实例，则两个htem都将共享v的值。静态/非静态没有任何优点和缺点，这取决于需要。如果希望所有实例共享属性值，则将其标记为静态；如果希望每个实例都有自己的属性值，则将其标记为非静态。
如果
C1
没有要在实例之间变化的内部状态（字段），则没有太多差异。但是您应该使用a（因为
C1
的所有实例基本相同）。如果
v
在实例之间会有所不同，或者如果子类化可能会在
C1
的实例之间产生差异，那么
静态
方法通常效果不佳

使用单例而不是
静态
方法的主要原因是可以声明单例来实现各种接口

有关更多讨论，请参阅和。
如果
C1
没有内部状态（字段），您希望在不同实例之间进行更改，则不会有太大的差异。但是您应该使用a（因为
C1
的所有实例基本相同）。如果
v
在实例之间会有所不同，或者如果子类化可能会在
C1
的实例之间产生差异，那么
静态
方法通常效果不佳

使用单例而不是
静态
方法的主要原因是可以声明单例来实现各种接口

有关更多讨论，请参阅和。
如果
C1
没有内部状态（字段），您希望在不同实例之间进行更改，则不会有太大的差异。但是您应该使用a（因为
C1
的所有实例基本相同）。如果
v
在实例之间会有所不同，或者如果子类化可能会在
C1
的实例之间产生差异，那么
静态
方法通常效果不佳

使用单例而不是
静态
方法的主要原因是可以声明单例来实现各种接口

有关更多讨论，请参阅和。
如果
C1
没有内部状态（字段），您希望在不同实例之间进行更改，则不会有太大的差异。但是您应该使用a（因为
C1
的所有实例基本相同）。如果
v
在实例之间会有所不同，或者如果子类化可能会在
C1
的实例之间产生差异，那么
静态
方法通常效果不佳

使用单例而不是
静态
方法的主要原因是可以声明单例来实现各种接口

有关更多讨论，请参见和。
如果我稍微更改一下您的示例，则可以最好地说明这种差异：

public class C1{
    private final int v;

    public C1(final int v) {
        this.v = v;
    }

    public int getV(){
       return v;
    }
}

在这种情况下，当您创建
C1
时，您给它一个内部状态，即
v
。现在你可以做了

final C1 firstC1 = new C1(10);
final C1 secondC1 = new C1(20);

使用
静态
方法无法做到这一点，因为它们绑定到
类
实例，而不是
对象
实例-因此状态的任何更改都会被所有方法调用看到

通常，在OO设计中，最好避免使用静态的
。它有它的位置，它通常用于实用程序类和常量（尽管在Java
enum中，s更适合用于常量）。
如果我稍微更改一下您的示例，可以最好地说明这一差异：

public class C1{
    private final int v;

    public C1(final int v) {
        this.v = v;
    }

    public int getV(){
       return v;
    }
}

在这种情况下，当您创建
C1
时，您给它一个内部状态，即
v
。现在你可以做了

final C1 firstC1 = new C1(10);
final C1 secondC1 = new C1(20);

使用
静态
方法无法做到这一点，因为它们绑定到
类
实例，而不是
对象
实例-因此状态的任何更改都会被所有方法调用看到

通常，在OO设计中，最好避免使用静态的
。它有它的位置，它通常用于实用程序类和常量（尽管在Java
enum中，s更适合用于常量）。
如果我稍微更改一下您的示例，可以最好地说明这一差异：

public class C1{
    private final int v;

    public C1(final int v) {
        this.v = v;
    }

    public int getV(){
       return v;
    }
}

在这种情况下，当您创建