两种调用方法的区别，大家都进来看看，发表发表意见

Question

A类有两个方法：
public static int getRunStatic() {

return new A.getRun();

}

public  int  getRun() {

int x=0;

////逻辑代码////

return x;
}在B类里面进行调用：
public static void main(String[] args) {

int i=A.getRunStatic();

int t=new A.getRun();
}
现在的问题是：
1，这两种调用方式优点和缺点是什么？
2，这两种方法各自在那些场合下调用好？
3，哪种写法比较更合理（包括内存的使用）？大家根据自己掌握的知识说一说，共同讨论（请求斑竹首页推荐）

Answer 1

忘了 int i=A.getRunStatic();

int t=new A().getRun();

Answer 2

感觉int i=A.getRunStatic();好一点

Answer 3

getRunStatic()方法相当于把getRun()封装了一下，为什么不直接把getRun()设置成静态方法呢？
static 表示类初始化的时候就创建了其修饰的方法，并把方法实例化好方法哦内存中，
而没有被修饰的则是在调用的时候才实例化，才分配内存空间。
所以我认为刚才那样写是多此一举！！

Answer 4

区别不大 
差别上getRunStatic相当于一个Wrapper类。在对class A的依赖性上，没有本质的区别，这点要和Factory类区别看待。

Answer 5

我认为不好.
如下:可能会让人误操作.
package com.zb.test;
public class B{
public static void main(String[] args) { int i = A.getRunStatic();
System.out.println(i);
int t = new A().setAInt(2).getRun();
System.out.println(t); }}
 class A {
public int aInt = 1;
public A setAInt(int aInt){
this.aInt  = aInt;
return this ;
}
public static int getRunStatic() {
return new A().getRun();
}
public int getRun() {
int x = aInt;
return x;
}
}

Answer 6

原题是这样的，getRun()方法并没有调用全局变量，所以你的那种方法没有在我们的讨论范围内
    public  int  getRun() {
        
        int x=0;
        
        ////逻辑代码////
        
        return x;
    }至于两种方法调用的好坏和优缺点，大家还都没有说到点子上~

Answer 7

各有利弊：
被static修饰的在类创建时创建，创建的成员是该类的成员，适用于整个类，它放在另一个存储空间。
非静态成员变量是类在第一次被使用的时候分配内存空间。
静态成员存在于内存,非静态成员需要实例化才会分配内存
非静态成员的生存期决定于该类的生存期，而静态成员则不存在生存期的概念,因为静态成员始终驻留在内存中

Answer 8

static 可以直接类名.方法名调用，主要是隔离。

Answer 9

是要时间还是空间？
getRunStatic()占用的内存，但调用时效率高
getRun()不会一直占用内存，但调用时效率低。不知道对不对，关注标准答案...

Answer 10

第一种方法，调用一次以后就不会再产生新的A的对象了 ，始终使用第一次调用的A的实例
而第二种每次都新产生一个A的实例

Answer 11

但是第一种方法是在调用的时候是在方法体内实例化的，虽然自身是静态方法，但是被调用的时候”它“会new 一个实例出来。不知道考虑过没有呢

Answer 12

public static void main(String[] args) {
        
        int i=A.getRunStatic();
        
        int t=new A().getRun();
            }
很明显一个是直接调用程序初始化时就已经在内存中的静态方法，第二个是创建了一个A的新的对象之后又再调用A的对象方法，孰好孰坏应该很明显了吧。

Answer 13

静态方法在初始化的时候不是已经存在于内存中了吗？即使创建N的类的实例也是公用那个内存内的方法，何来new一个实例？（解释有误的话请谅解，我也不是高手）

Answer 14

这两种调用方式各有用处，第2种不用static修饰比较常用，用static修饰的方法被另外的类调用时可以直接用A.getRunStatic()的这种形式。
public Class A{
   static a;
   public static A getInstance(){
       if(a == null){
           a = new A();
       }
       return a;
   }
}
上面这个方法能保证类A只创建唯一的实例对象。在不同的类调用时可以保证只操作唯一的A的实例。而不是重新new出来的新实例。这点很有用。比如：在一个桌面应用系统里面，如果一个界面的数据被修改后，不使用数据库，不使用文件保存修改，怎么将这个修改传过去，这时，用上这个就很好处理了

Answer 15

从访问权限上来讲，A.staticRun();权限是完全开放的，不管A是否为私有构造都行，而new A().run();则不允许A有私有构造；另外就是A.staticRun()的方式要多转一层。其它应该都没什么区别吧！上面说到run()方法中没有访问全局变量，那就应该直接写成static方法，这样更方便和高效，不需要每次调用都实例化。

Answer 16

本人觉得A.getRunStatic()是直接调用A类的一个静态方法，所以它只执行一次，所以无论它在main中出现多少次它还是第一次执行的结果;        
而new A().getRun()是调用A类的普通方法，所以每次调用都会重新执行一遍;
lz可以把代码给成：就能看到区别。class F {
int x = 0; public static int getRunStatic() {
return new F().getRun(); } public int getRun() {
return x++;
}
}public class B { public static void main(String[] args) {
int i = F.getRunStatic();
F f = new F();
int t = f.getRun();
System.out.println(i + "   " + t);
i = F.getRunStatic();
t = f.getRun();
System.out.println(i + "   " + t);
i = F.getRunStatic();
t = f.getRun();
System.out.println(i + "   " + t); }
}

Answer 17

一般static方法适用对象是一些公用的或常用的方法；使用起来方便。