Java 编译时和运行时的含义

为了把事情弄清楚，我已经详细阐述了我的问题。

我这里有一段代码，它详细介绍了使用覆盖概念的动态绑定

代码如下：

class Test { 
         public static void main(String [] args) 
         { 

             B b = new A();   

             b.p(10);      //  10.0
             b.p(10.0);   // 10.0
         } 
  } 
  class B
  { 
    public void p(double i)
    { 
        print(i*2); 
    } 
  } 

  class A extends B 
  { 
     public void p(double i) 
    { 
          print(i); 
    } 
  }   

现在，解释说编译器无法确定在“编译时”调用哪个方法。在“运行时”，编译器知道需要调用的方法是子类方法，因为当我们重写时，我们看到的是实际的类型

与此代码相比：

    class Test { 
         public static void main(String [] args) 
         { 

             B b = new A();   

             b.p(10);      //  10.0
             b.p(10.0);   // 10.0
         } 
       } 
  class B
 { 
   public void p(double i)() 
  { 
     print(i*2); 
  } 
} 

 class A extends B 
 { 
    public void p(int i) 
   { 
      print(i); 
   } 
}

在本例中，编译器可以识别在编译时调用哪个方法。在本例中，编译器如何识别，而在上一个示例中却无法识别？ 问题:

---

术语“编译时”和“运行时”到底是什么意思？编译器如何在编译时不认识到需要调用的函数是子类函数呢？

这是一个非常自我解释的过程

编译时和运行时指的是时间段

---

编译时是编译器构建项目的时间

Runtime是项目运行的时间

---

我想你是在问为什么你的代码在运行之前不知道

B

是

A

。在以下章节中：

 B b = new A();   

 b.p(10);      //  20.0
 b.p(10.0);   // 20.0

原因是编译器不会计算代码中所有可能的路径来检查这些内容，当您看到稍微复杂一些的实现时，这更容易理解

 B b = new A();   

 if(...)
 {
    ...
    b = new B();
 }


 b.p(10);      //  20.0
 b.p(10.0);   // 20.0

---

当代码实际执行时，它只知道

b

是什么

运行时表示“程序运行时”

编译时表示“编译程序时”

有些事情只有在运行时才知道

例如，用户输入

编译器无法预测用户在运行时将输入什么

术语“编译时”和“运行时”到底是什么意思

编译时是将代码编译为可执行代码（字节码）的时间。这意味着，所有文件都被链接（通过

import

expression包含），并创建字节码，即指令序列

运行时是CPU运行编译代码-字节代码的时间

编译器如何在编译时不识别需要调用的函数是子类函数

事实上，的确如此。如果无法识别，则不会编译，因为compile必须清楚地知道要调用什么方法，以便为运行时准备代码。您提供的代码有效，将执行类

A

中的

p（）

方法。

• 编译时间：编译期间
• 运行时：在程序执行期间

考虑：

List x = getsSomeList();

x

可以是

列表

接口的任何实现

---

如果您调用

x.add（foo）

，正确的

add

方法将在执行之前不为人所知，并且有一个实际的实现可以调用

add
当您使用多态性时，编译器无法知道调用哪个方法，因为您可以有许多相同方法的实现。。。因此，它只能在运行时确定。
编译时和运行时之间的区别在于编译期间，JVM检查程序员编写的程序中的语法、特定Java和其他错误。运行时是在应用程序运行期间检查的内容

您可能语法正确，但在运行时有许多错误。示例：
拼写错误的单词
程序中的逻辑
它运行的方式
如何处理动画等

它取决于以下（伪）代码：

编译器无法知道在运行时调用哪个方法。
由于多态性，编译器无法知道调用哪个方法，正如所说的
，编译器无法确定在“编译时”调用哪个方法。
这意味着由于函数有多种形式可用，编译器决定在编译应用程序时调用哪个版本的函数，因此它决定在运行时执行程序时调用哪个方法）

如果
extended/derived
class
重载了您试图调用它的函数/方法，请从
派生类调用该方法，如果该方法在派生类中未重载，则它将从
基类调用该方法。这就是面向对象语言中动态绑定的工作原理。
您提供的示例似乎不正确

两次调用的输出都是10.0，而不是如您所述的20.0。
检查[this][1]。你在问同样的问题。[1] ：关于你的问题1<代码>您的代码是如何引用您的问题的？
2<代码>什么的解释？说明编译器无法确定要调用的方法？
是否出现某种错误？。选中此项代码中的注释表示您认为输出将导致
20.0
。事实上，输出将是
10.0
，因为
b
是
A
的一个实例……这是这里最好的答案+1.简单而完美地解释了这一点。这并不是问题的真正答案。这更像是一个切向相关的注释，虽然作者认为应该调用子类方法，但它是相关的。事实上，它正在被调用。但它仍然不是答案。也许不是直接的，但它应该向作者确认，他/她关于子类实现未被识别的假设是不正确的。
B b = Rand() > 0.5?new A() : new B();

b.p(10);