编译时，运行时解释

在开发和设计的时候，我们需要考虑编译时，运行时以及构建时这三个概念。理解这几个概念可以更好地帮助你去了解一些基本的原理。下面是初学者晋级中级水平需要知道的一些问题。

Q.下面的代码片段中，行A和行B所标识的代码有什么区别呢？


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

public class ConstantFolding {

    static final  int number1 = 5;

    static final  int number2 = 6;

    static int number3 = 5;

    static int number4= 6;

    public static void main(String[ ] args) {

          int product1 = number1 * number2;         //line A

          int product2 = number3 * number4;         //line B

    }

}


A.在行A的代码中，product的值是在编译期计算的，行B则是在运行时计算的。如果你使用Java反编译器（例如，jd-gui）来反编译ConstantFolding.class文件的话，那么你就会从下面的结果里得到答案。


1

2

3

4

5

6

7

8

9

10

11

12

13

public class ConstantFolding

{

  static final int number1 = 5;

  static final int number2 = 6;

  static int number3 = 5;

  static int number4 = 6;

  public static void main(String[ ] args)

  {

      int product1 = 30;

      int product2 = number3 * number4;

  }

}

常量折叠是一种Java编译器使用的优化技术。由于final变量的值不会改变，因此就可以对它们优化。Java反编译器和javap命令都是查看编译后的代码（例如，字节码）的利器。

Q.你能想出除了代码优化外，在什么情况下，查看编译过的代码是很有帮助的？

A.Java里的泛型是在编译时构造的，可以通过查看编译后的class文件来理解泛型，也可以通过查看它来解决泛型相关的问题。

Q.下面哪些是发生在编译时，运行时，或者两者都有？

A.

 方法重载：这个是发生在编译时的。方法重载也被称为编译时多态，因为编译器可以根据参数的类型来选择使用哪个方法。


1

2

3

4

public class {

     public static void evaluate(String param1);  // method #1

     public static void evaluate(int param1);   // method #2

}

如果编译器要编译下面的语句的话：


1

evaluate(“My Test Argument passed to param1”);

它会根据传入的参数是字符串常量，生成调用#1方法的字节码

方法覆盖：这个是在运行时发生的。方法重载被称为运行时多态，因为在编译期编译器不知道并且没法知道该去调用哪个方法。JVM会在代码运行的时候做出决定。


1

2

3

4

5

6

7

8

9

10

11

12

public class A {

   public int compute(int input) {          //method #3

        return 3 * input;

   }       

}

public class B extends A {

   @Override

   public int compute(int input) {          //method #4

        return 4 * input;

   }       

}

子类B中的compute(..)方法重写了父类的compute(..)方法。如果编译器遇到下面的代码：


1

2

3

public int evaluate(A reference, int arg2)  {

     int result = reference.compute(arg2);

}

编译器是没法知道传入的参数reference的类型是A还是B。因此，只能够在运行时，根据赋给输入变量“reference”的对象的类型（例如，A或者B的实例）来决定调用方法#3还是方法#4.

泛型（又称类型检验）：这个是发生在编译期的。编译器负责检查程序中类型的正确性，然后把使用了泛型的代码翻译或者重写成可以执行在当前JVM上的非泛型代码。这个技术被称为“类型擦除“。换句话来说，编译器会擦除所有在尖括号里的类型信息，来保证和版本1.4.0或者更早版本的JRE的兼容性。


1

List<String> myList = new ArrayList<String>(10);

编译后成为了：


1

List myList = new ArrayList(10);


注解（Annotation）：你可以使用运行时或者编译时的注解。


1

2

3

4

5

6

public class B extends A {

   @Override

    public int compute(int input){      //method #4

        return 4 * input;

    }      

}

@Override是一个简单的编译时注解，它可以用来捕获类似于在子类中把toString()写成tostring()这样的错误。在Java 5中，用户自定义的注解可以用注解处理工具(Anotation Process Tool ——APT)在编译时进行处理。到了Java 6，这个功能已经是编译器的一部分了。


1

2

3

4

5

6

7

8

9

10

public class MyTest{

    @Test

     public void testEmptyness( ){

         org.junit.Assert.assertTrue(getList( ).isEmpty( ));

     }

     private List getList( ){

        //implemenation goes here

     }

}

@Test是JUnit框架用来在运行时通过反射来决定调用测试类的哪个（些）方法的注解。


1

2

3

4

@Test (timeout=100)

public void testTimeout( ) {

    while(true);   //infinite loop

}

如果运行时间超过100ms的话，上面的测试用例就会失败。


1

2

3

4

@Test (expected=IndexOutOfBoundsException.class)

public void testOutOfBounds( ) {

       new ArrayList<Object>( ).get(1);

}

如果上面的代码在运行时没有抛出IndexOutOfBoundsException或者抛出的是其他的异常的话，那么这个用例就会失败。用户自定义的注解可以在运行时通过Java反射API里新增的AnnotatedElement和”Annotation”元素接口来处理。

异常（Exception）：你可以使用运行时异常或者编译时异常。

运行时异常（RuntimeException）也称作未检测的异常（unchecked exception），这表示这种异常不需要编译器来检测。RuntimeException是所有可以在运行时抛出的异常的父类。一个方法除要捕获异常外，如果它执行的时候可能会抛出RuntimeException的子类，那么它就不需要用throw语句来声明抛出的异常。

例如：NullPointerException，ArrayIndexOutOfBoundsException，等等

受检查异常（checked exception）都是编译器在编译时进行校验的，通过throws语句或者try{}cathch{} 语句块来处理检测异常。编译器会分析哪些异常会在执行一个方法或者构造函数的时候抛出。

面向切面的编程（Aspect Oriented Programming-AOP）：切面可以在编译时，运行时或，加载时或者运行时织入。

  • 编译期：编译期织入是最简单的方式。如果你拥有应用的代码，你可以使用AOP编译器（例如，ajc – AspectJ编译器）对源码进行编译，然后输出织入完成的class文件。AOP编译的过程包含了waver的调用。切面的形式可以是源码的形式也可以是二进制的形式。如果切面需要针对受影响的类进行编译，那么你就需要在编译期织入了。
  • 编译后：这种方式有时候也被称为二进制织入，它被用来织入已有的class文件和jar文件。和编译时织入方式相同，用来织入的切面可以是源码也可以是二进制的形式，并且它们自己也可以被织入切面。
  • 装载期：这种织入是一种二进制织入，它被延迟到JVM加载class文件和定义类的时候。为了支持这种织入方式，需要显式地由运行时环境或者通过一种“织入代理（weaving agent）“来提供一个或者多个“织入类加载器（weaving class loader）”。
  • 运行时：对已经加载到JVM里的类进行织入

继承 – 发生在编译时，因为它是静态的

代理或者组合 – 发生在运行时，因为它更加具有动态性和灵活性。

Q.你有没有听说过“组合优于继承”这样的说法呢？如果听说过的话，那么你是怎么理解的呢？

A.继承是一种多态工具，而不是一种代码复用工具。有些开发者喜欢用继承的方式来实现代码复用，即使是在没有多态关系的情况下。是否使用继承的规则是继承只能用在类之间有“父子”关系的情况下。

  • 不要仅仅为了代码复用而继承。当你使用组合来实现代码复用的时候，是不会产生继承关系的。过度使用继承（通过“extends”关键字）的话，如果修改了父类，会损坏所有的子类。这是因为子类和父类的紧耦合关系是在编译期产生的。
  • 不要仅仅为了多态而继承。如果你的类之间没有继承关系，并且你想要实现多态，那么你可以通过接口和组合的方式来实现，这样不仅可以实现代码重用，同时也可以实现运行时的灵活性。

这就是为什么四人帮（Gang of Four）的设计模式里更倾向于使用组合而不是继承的原因。面试者会在你的答案里着重关注这几个词语——“耦合”，“静态还是动态”，以及“发生在编译期还是运行时”。运行时的灵活性可以通过组合来实现，因为类可以在运行时动态地根据一个结果有条件或者无条件地进行组合。但是继承却是静态的。

Q.你能够通过实例来区别编译期继承和运行时继承，以及指出Java支持哪种吗？

A.“继承”表示动作和属性从一个对象传递到另外一个对象的场景。Java语言本身只支持编译期继承，它是通过“extends”关键字来产生子类的方式实现的，如下所示：


1

2

3

4

5

6

7

8

9

10

11

12

public class Parent {

    public String saySomething( ) {

          return “Parent is called”;

    }

}

public class Child extends Parent {

     @Override

     public String saySomething( ) {

          return super.saySomething( ) +  “, Child is called”;

    }

}

“Child”类的saySomething()方法的调用会返回“Parent is called，Child is Called”，因为，子类的调用继承了父类的“Parenet is called”。关键字“super”是用来调用“Parent”类的方法。运行时继承表示在运行时构建父/子类关系。Java语言本身不支持运行时继承，但是有一种替代的方案叫做“代理”或者“组合”，它表示在运行时组件一个层次对象的子类。这样可以模拟运行时继承的实现。在Java里，代理的典型实现方式如下：


1

2

3

4

5

6

7

8

9

10

11

public class Parent {

    public String saySomething( ) {

          return “Parent is called”;

    }

}

public class Child  {

     public String saySomething( ) {

          return new Parent( ).saySomething( ) +  “, Child is called”;

    }

}

子类代理了父类的调用。组合可以按照下面的方式来实现：


1

2

3

4

5

6

7

8

9

10

11

public class Child  {

     private Parent parent = null;

     public Child( ){

          this.parent = new Parent( );

     }

     public String saySomething( ) {

          return this.parent.saySomething( ) +  “, Child is called”;

    }
时间： 2025-01-14 09:34:30

编译时，运行时解释的相关文章

程序编译后运行时的内存分配

原文地址不详,我的转载的来源:http://blog.sina.com.cn/s/blog_5420e0000101a0w1.html 一.编译时与运行时的内存情况 1.编译时不分配内存 编译时是不分配内存的.此时只是根据声明时的类型进行占位,到以后程序执行时分配内存才会正确.所以声明是给编译器看的,聪明的编译器能根据声明帮你识别错误. 2.运行时必分配内存 运行时程序是必须调到"内存"的.因为CPU(其中有多个寄存器)只与内存打交道的.程序在进入实际内存之前要首先分配物理内存. 3.

java编译时与运行时概念与实例详解 -------------------(*************************)

Java编译时与运行时很重要的概念,但是一直没有明晰,这次专门博客写明白概念. 基础概念 编译时  编译时顾名思义就是正在编译的时候.那啥叫编译呢?就是编译器帮你把源代码翻译成机器能识别的代码.(当然只是一般意义上这么说,实际上可能只是翻译成某个中间状态的语言.比如Java只有JVM识别的字节码,.另外还有啥链接器.汇编器.为了了便于理解我们可以统称为编译器) 那编译时就是简单的作一些翻译工作,比如检查老兄你有没有粗心写错啥关键字了啊.有啥词法分析,语法分析之类的过程.就像个老师检查学生的作文中

Java导入package编译后运行时提示无法加载主类的解决办法

Java代码中通过package导入包后,用命令行编译可以成功,但是运行时提示无法加载主类,这时候可以把编译后的class文件放在导入包的上一层文件夹,然后用 java 包名.类名 的命令形式运行 参考链接:点击这里 原文地址:https://www.cnblogs.com/excellent-ship/p/9134994.html

ios 引入第三方库时 运行时找不到函数实现的 问题

今天引入webtrends 这个库,结果一直运行时找不到函数,纳闷了一下午! 后来发现,是other flag没有设置对,对于那些包含category用来扩展ios原始类型的库,链接的时候需要特别的链接选项: 我先参看了如下的链接,感谢原作者! http://blog.csdn.net/xiaowenwen1010/article/details/40782971 读完原文后,我再总结一下:

★Java-----记事本编译、运行时注意事项

1.文件名需要与源代码中公共类的名字相同,即class后面的名字: 2.Java中严格区分大小写: 3.记事本编辑好之后保存文件后缀必须是". java": 4.运行cmd,dos窗口下,javac进行编译时,文件的扩展名“.java”不可丢: 5.编译好之后,执行java命令,只需输入文件名即可: 6.在创建类名时,要用一个阅读性强的类名来定义,见名思意: 7.Java是具有跨平台性的: 8.Java中的符号须在英文状态下写入:

编译或运行时可能会出现错误： Error:Error retrieving parent for item: No resource found that matches the given name “Theme.AppCompat.Light”

这个问题我在刚开始写"HelloWorld"时就遇到,以为是API版本太高,下载了常用的API 19.17--一系列的,后来还是有问题.就上网查了很多,遇到几篇不错的文章,记录下来,方便以后查看. No resource found that matches the given name 'Theme.AppCompat.Light 的完美解决方案  http://www.360doc.com/content/15/0316/15/9200790_455576135.shtml And

iOS Objective -C Runtime 运行时之一: 类与对象

// --------------------------------------------------- 参考:南峰子的技术博客 http://southpeak.github.io //---------------------------------------------------- OC语言是一门动态语言,它将很多静态语言在编译和链接时期做的事放到了运行时来处理.这种动态语言的优势在于:我们编写代码时更具灵活性,如我们可以把消息转发给我们想要的对象,或者随意交换一个方法的实现等.

程序运行时三种内存分配策略

按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的. 静态存储分配是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在编译时就可以给他们分配固定的内存空间.这种分配策略要求程序代码中不允许有可变数据结构(比如可变数组)的存在,也不允许有嵌套或者递归的结构出现,因为它们都会导致编译程序无法计算准确的存储空间需求. 栈式存储分配也可称为动态存储分配,是由一个类似于堆栈的运行栈来实现的.和静态存储分配相反,在栈式存储方案中,程序对数据区的需求在编译时是完全未

ubuntu android studio 编译及运行错误Error retrieving parent for item: No resource found that matches the given name

安装好android studio并且安装其它需要的SDK或组件后,根据向导生成新的项目, 编译或运行时可能会出现下面的错误: Error:Error retrieving parent for item: No resource found that matches the given name “xxxxxxxxxx” 不大确定其它人的同样错误是否与本人是同一原因,在本人环境中的问题是“build.gradle(Module:app)”中的配置版本过高的问题. 本人生成项目时,目标andro

linux下junit测试用例编译与运行配置

1.linux下Java程序的编译与运行 linux 下编译Java代码的command line模式: javac -cp .:./lib/sequoiadb.jar ./com/sequoiadb/test/CsAndClOperation.java linux 下编译Java代码的command line模式: java -cp .:./lib/sequoiadb.jar com.sequoiadb.test.CsAndClOperation 2.linux下Junit测试用例的编译与运行