关于java方法调用的几个问题

1：我有一个像

public class Test{
    void dispose(){
        System.out.println("disposing");
    }
    Test t=new Test();
    public static void main(String[] args){
        t.dispose();
    }
}

为什么我不能从main（）调用dispose方法？如果它是静态和非静态的关系，为什么下面的代码可以工作

public class Test{
    void dispose(){
        System.out.println("disposing");
    }
    public static void main(String[] args){
        Test t=new Test();
        t.dispose();
    }
}

2：方法调用代码应该始终在方法中吗？因为，下面的代码不起作用

public class Test{
    void dispose(){
        System.out.println("disposing");
    }
    Test t=new Test();
    t.dispose();
    public static void main(String[] args){
    }
}

请向我澄清

为什么我不能从main（）调用dispose方法？如果它是静态和非静态的关系，为什么下面的代码可以工作

public class Test{
    void dispose(){
        System.out.println("disposing");
    }
    public static void main(String[] args){
        Test t=new Test();
        t.dispose();
    }
}

因为您有一个Test实例，所以即使在静态上下文中也可以使用它

方法调用代码应该始终在方法中吗

---

对。确切地在方法、静态块或构造函数中。其他地方不允许进入。

示例1

您处于静态方法（main）中，试图访问非静态变量t。您已将变量t声明为：

 Test t=new Test();

这已将其创建为类的成员变量。相反，您需要将其声明为：

 static Test t=new Test();

现在静态方法可以访问它（尽管这通常不是一种好的方法）

示例2

您现在将变量t声明为main方法中的局部变量，因此从main中访问它是有效的

示例3

---

除了initalizer块（您不必担心）之外，所有代码都必须进入一个方法。

第二个块不工作的原因是静态关系

如果一个方法不是静态的，那么它必须有一个要访问的实例。这就是为什么创建类的实例允许您调用该方法

如果将dispose方法设置为静态，则可以直接调用该方法，因为该方法只有一个实例

下面是一个不同问题的链接，可以很好地解释这个问题：

---

希望这有帮助：）

在开始之前，让我先弄清楚什么是类变量和对象变量

类变量：静态变量，无需初始化类即可访问

对象变量：只能在类实例化时访问的非静态变量

因此，在您的情况下，当调用main时，类不会被初始化，因此对象不会被初始化，因此您无法调用dispose方法

为什么我不能从main（）调用dispose方法？如果它是静态和非静态的 静态关系，为什么下面的代码工作

public class Test{
    void dispose(){
        System.out.println("disposing");
    }
    public static void main(String[] args){
        Test t=new Test();
        t.dispose();
    }
}

无法从静态上下文引用非静态变量t（编译器异常）。 您应该始终记住，jvm搜索main（）方法并执行它。然后初始化方法和块。 注意：-您总是编译并运行包含main方法的类

您在main方法中将变量t声明为局部变量，因此从main方法中访问它是有效的

方法调用代码应该始终在方法中吗

---

Yes方法调用总是需要在方法内部，或者在构造函数或初始化块中，甚至在静态块中。

当java程序正在执行时，JVM会查找主方法。在大范围内，如果你不写任何东西，什么也不会发生

public class Test{
    void dispose(){
        System.out.println("disposing");
    }
    Test t=new Test();  //That's ok.
    t.dispose();        //causes compilation error
    
    public static void main(String[] args){
         //Executed as soon as you run your program.
    }
}

您想调用dispose（）。你想要什么？对测试对象调用dispose（），方法是t.dispose（），也可以使用test.dispose（）调用它

方法1： 测试中的dispose（）是静态的吗？不因此，您必须使用测试对象调用它。 是否在teststatic中使用dispose（）？然后

方法2： 不能使用类引用调用非静态方法。必须使用类对象，但可以使用类对象调用静态方法（不推荐）。你应该使用类引用来调用它

方法3：（不推荐） 我猜你有C这样的程序语言背景

Java是不同的。它是对象或方向的

来回答你的问题

Ans1:正确的说法是，使用类的方法不必创建类的实例。如果使用static关键字声明方法，则无需首先创建类的实例即可调用该方法。这是因为静态方法是从类调用的，而不是从对象调用的

但是，您不能从静态上下文调用非静态方法（这里就像在静态方法

main（）

中一样）。为什么？ 因为

然而，这里的情况并非如此 您可能会觉得在代码的第5行创建了该类的实例，但对于编译器来说，它并不存在。它在

main（）

方法之外，这是在任何可运行的Java程序中寻找的第一个方法。然后，编译器根据需要插入其他部分。如果方法中没有可执行代码，请查看对象初始化在第二段代码中，编译器看到对象初始化，因此程序执行。

Ans2：是。与以前一样，您不能有不在方法中的可执行代码

插图：

class DeclarationTest  
{  
  int a = 5;  
  int b = 10;  
  int c = a + b;//it is Ok, this is a declaration statement for c  

  /* 
  int c; 
  c = a + b; ------> this is not Ok, you are performing an action here this must be inside a method! 
  */  
}

---

如果是这样的话，那么使用方法就会变得不那么有用。想想看。

是的，您不能在静态块中调用非静态对象或变量。若您将对象声明为静态，那个么您的代码将按如下方式工作

public class Test{
    void dispose(){
        System.out.println("disposing");
    }

    static Test t=new Test();

    public static void main(String[] args){
        t.dispose();        
    }
}

您也可以尝试以下方法：

public class Test{
    void dispose(){
        System.out.println("disposing");
    }

    {
         dispose();
    }

    public static void main(String[] args){
        Test t=new Test();
    }
}

---

此外，我们可以在类中的方法外声明对象，但不能在方法或块外调用方法。

您也可以在非静态初始值设定项块中执行此操作。

public class Test{
    void dispose(){
        System.out.println("disposing");
    }

    {
         dispose();
    }

    public static void main(String[] args){
        Test t=new Test();
    }
}