精华内容
下载资源
问答
  • 今天小熙突然想到一个问题,那就是Java到底是动态语言还是静态语言,是强类型还是弱类型呢?虽然知道但是还是不够深入,接下来就一起探讨下吧。 二. 图释 小熙碰巧看到一张,完美的区分了以上的问题 如图所示,...

    一. 前言

    今天小熙突然想到一个问题,那就是Java到底是动态语言还是静态语言,是强类型还是弱类型呢?虽然知道但是还是不够深入,接下来就一起探讨下吧。

    二. 图释

    小熙碰巧看到一张图,完美的区分了以上的问题,如下图所示:

    语言类型

    如图所示,Java是强类型语言,静态类型。下面解释下为什么。

    三. 解释

    1. 静态类型语言:变量定义时有类型声明的语言。

      (1)变量的类型在编译的时候确定

      (2)变量的类型在运行时不能修改

      这样编译器就可以确定运行时需要的内存总量。
      例如:C、Scala、Java、F#语言是静态类型语言。

    2. 动态类型语言:变量定义时无类型声明的语言。

      (1)变量的类型在运行的时候确定

      (2)变量的类型在运行可以修改

      例如:python、Javascript、Ruby语言是动态类型语言。

    3. 强类型定义语言

      强制数据类型定义的语言。也就是说,一旦一个变量被指定了某个数据类型,如果不经过强制转换,那么它就永远是这个数据类型了。举个例子:如果你定义了一个整型变量a,那么程序根本不可能将a当作字符串类型处理。强类型定义语言是类型安全的语言。

    4. 弱类型定义语言

      数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。强类型定义语言在速度上可能略逊色于弱类型定义语言,但是强类型定义语言带来的严谨性能够有效的避免许多错误。

    综上所述:小熙认为Java是在编译时期确定的变量类型且在运行时期不能改变,在类型转换方面也是强制的,例如大范围整数类型转换为小范围整数类型时必须要强转,如 int 必须强制转换才能得到小范围类型 byte。所以Java是静态、强类型语言。

    以上就是小熙总结的结论,欢迎大家讨论。

    展开全文
  • 除此之外如Ruby、Python、OC等也都属于动态语言,而C、C++、Java等语言则不属于动态语言。 动态类型语言,就是类型的检查是在运行时做的,是不是合法的要到运行时才判断,例如JavaScript就没有编译

    什么是动态语言?
      动态语言,是指程序在运行时可以改变其结构:新的函数可以被引进,已有的函数可以被删除等在结构上的变化。比如JavaScript便是一个典型的动态语言。

    除此之外如Ruby、Python、OC等也都属于动态语言,而C、C++、Java等语言则不属于动态语言。

    动态类型语言,就是类型的检查是在运行时做的,是不是合法的要到运行时才判断,例如JavaScript就没有编译错误,只要运行错误。

    JavaScript改变结构小例子:

    复制代码
    aAll[0].οnclick=function(){
                    //通过重新赋类名,达到显示隐藏菜单的效果
                    if(oArt.className=='no_circle'){
                        oArt.className='yes_circle'
                    }else{
                        oArt.className='no_circle'
                    }
                }
    }
    复制代码

    静态语言

      而静态类型语言的类型判断是在运行前判断(如编译阶段),比如java就是静态类型语言,静态类型语言为了达到多态会采取一些类型鉴别手段,如继承、接口,而动态类型语言却不需要,
    静态类型语言的主要优点:
          在于其结构非常规范,便于调试,方便类型安全;
    缺点:
            是为此需要写更多的类型相关代码,导致不便于阅读、不清晰明了。动态类型语言的优点在于方便阅读,不需要写非常多的类型相关的代码;缺点自然就是不方便调试,命名不规范时会造成读不懂,不利于理解等。
     
    为什么Java可以称之为"准动态语言"?
    体现在以下几个方面:

      1.反射机制

      2.动态编译

      3.动态执行javascript代码

      4.动态字节码操作

      5.动态转换类型

    Java的反射机制被视为Java为准动态语言的主要的一个关键性质,这个机制允许程序在运行时透过反射取得任何一个已知名称的class的内部信息,包括:
    正在运行中的类的属性信息,正在运行中的类的方法信息,正在运行中的类的构造信息,正在运行中的类的访问修饰符,注解等等。
     
    动态语言无时不刻在体现动态性,而静态语言也在通过其他方法来趋近于去弥补静态语言的缺陷。
    展开全文
  • Java 8支持动态语言,看到了很酷的Lambda表达式,对一直以静态类型语言自居的Java,让人看到了Java虚拟机可以支持动态语言的目标。

    Java 8支持动态语言,看到了很酷的Lambda表达式,对一直以静态类型语言自居的Java,让人看到了Java虚拟机可以支持动态语言的目标。

    import java.util.function.Consumer;
    
    public class Lambda {
    	public static void main(String[] args) {
    		Consumer<String> c = s -> System.out.println(s);
    		c.accept("hello lambda!");
    	}
    }
    刚看到这个表达式,感觉java的处理方式是属于内部匿名类的方式

    public class Lambda {
    	static {
    		System.setProperty("jdk.internal.lambda.dumpProxyClasses", ".");
    	}
    	public static void main(String[] args) {
    		Consumer<String> c = new Consumer<String>(){
    			@Override
    			public void accept(String s) {
    				System.out.println(s);
    			}
    			};
    		c.accept("hello lambda");
    	}
    }

    编译的结果应该是Lambda.class , Lambda$1.class 猜测在支持动态语言java换汤不换药,在最后编译的时候生成我们常见的方式。

    但是结果不是这样的,只是产生了一个Lambda.class 

    反编译吧,来看看真相是什么?

    javap -v -p Lambda.class 

    注意  -p 这个参数 -p 参数会显示所有的方法,而不带默认是不会反编译private 的方法的

      public Lambda();
        descriptor: ()V
        flags: ACC_PUBLIC
        Code:
          stack=1, locals=1, args_size=1
             0: aload_0
             1: invokespecial #21                 // Method java/lang/Object."<init>":()V
             4: return
          LineNumberTable:
            line 3: 0
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0       5     0  this   LLambda;
    
      public static void main(java.lang.String[]);
        descriptor: ([Ljava/lang/String;)V
        flags: ACC_PUBLIC, ACC_STATIC
        Code:
          stack=2, locals=2, args_size=1
             0: invokedynamic #30,  0             // InvokeDynamic #0:accept:()Ljava/util/function/Consumer;
             5: astore_1
             6: aload_1
             7: ldc           #31                 // String hello lambda
             9: invokeinterface #33,  2           // InterfaceMethod java/util/function/Consumer.accept:(Ljava/lang/Object;)V
            14: return
          LineNumberTable:
            line 8: 0
            line 9: 6
            line 10: 14
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0      15     0  args   [Ljava/lang/String;
                6       9     1     c   Ljava/util/function/Consumer;
          LocalVariableTypeTable:
            Start  Length  Slot  Name   Signature
                6       9     1     c   Ljava/util/function/Consumer<Ljava/lang/String;>;
    
      private static void lambda$0(java.lang.String);
        descriptor: (Ljava/lang/String;)V
        flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC
        Code:
          stack=2, locals=1, args_size=1
             0: getstatic     #46                 // Field java/lang/System.out:Ljava/io/PrintStream;
             3: aload_0
             4: invokevirtual #50                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
             7: return
          LineNumberTable:
            line 8: 0
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0       8     0     s   Ljava/lang/String;
    }
    SourceFile: "Lambda.java"
    BootstrapMethods:
      0: #66 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
        Method arguments:
          #67 (Ljava/lang/Object;)V
          #70 invokestatic Lambda.lambda$0:(Ljava/lang/String;)V
          #71 (Ljava/lang/String;)V
    InnerClasses:
         public static final #77= #73 of #75; //Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles

    在这里我们发现了几个与我们常见的java不太一样的地方,由于常量定义太多了,文章中就不贴出了

    1. Invokedynamic 指令

    Java的调用函数的四大指令(invokevirtual、invokespecial、invokestatic、invokeinterface),通常方法的符号引用在静态类型语言编译时就能产生,而动态类型语言只有在运行期才能确定接收者类型,改变四大指令的语意对java的版本有很大的影响,所以在JSR 292 《Supporting Dynamically Typed Languages on the Java Platform》添加了一个新的指令

    Invokedynamic

    0: invokedynamic #30,  0             // InvokeDynamic #0:accept:()Ljava/util/function/Consumer;

     #30 是代表常量#30 也就是后面的注释InvokeDynamic #0:accept:()Ljava/util/function/Consumer;
    0 是占位符号,目前无用

    2. BootstrapMethods

    每一个invokedynamic指令的实例叫做一个动态调用点(dynamic call site), 动态调用点最开始是 未链接状态(unlinked:表示还未指定该调用点要调用的方法), 动态调用点依靠引导方法来链接到具体的方法.  引导方法是由编译器生成, 在运行期当JVM第一次遇到invokedynamic指令时, 会调用引导方法来将invokedynamic指令所指定的名字(方法名,方法签名)和具体的执行代码(目标方法)链接起来, 引导方法的返回值永久的决定了调用点的行为.引导方法的返回值类型是java.lang.invoke.CallSite, 一个invokedynamic指令关联一个CallSite, 将所有的调用委托到CallSite当前的target(MethodHandle)

    InvokeDynamic #0 就是BootstrapMethods表示#0的位置

      0: #66 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
        Method arguments:
          #67 (Ljava/lang/Object;)V
          #70 invokestatic Lambda.lambda$0:(Ljava/lang/String;)V
          #71 (Ljava/lang/String;)V

    我们看到调用了LambdaMetaFactory.metafactory 的方法

    参数:

    LambdaMetafactory.metafactory(Lookup, String, MethodType, MethodType, MethodHandle, MethodType)有六个参数, 按顺序描述如下
    1. MethodHandles.Lookup caller : 代表查找上下文与调用者的访问权限, 使用invokedynamic指令时, JVM会自动自动填充这个参数


    2. String invokedName : 要实现的方法的名字, 使用invokedynamic时, JVM自动帮我们填充(填充内容来自常量池InvokeDynamic.NameAndType.Name), 在这里JVM为我们填充为 "apply", 即Consumer.accept方法名.


    3. MethodType invokedType : 调用点期望的方法参数的类型和返回值的类型(方法signature). 使用invokedynamic指令时, JVM会自动自动填充这个参数(填充内容来自常量池InvokeDynamic.NameAndType.Type), 在这里参数为String, 返回值类型为Consumer, 表示这个调用点的目标方法的参数为String, 然后invokedynamic执行完后会返回一个即Consumer实例.


    4. MethodType samMethodType :  函数对象将要实现的接口方法类型, 这里运行时, 值为 (Object)Object 即 Consumer.accept方法的类型(泛型信息被擦除).#67 (Ljava/lang/Object;)V


    5. MethodHandle implMethod : 一个直接方法句柄(DirectMethodHandle), 描述在调用时将被执行的具体实现方法 (包含适当的参数适配, 返回类型适配, 和在调用参数前附加上捕获的参数), 在这里为 #70 invokestatic Lambda.lambda$0:(Ljava/lang/String;)V 方法的方法句柄.


    6. MethodType instantiatedMethodType : 函数接口方法替换泛型为具体类型后的方法类型, 通常和 samMethodType 一样, 不同的情况为泛型:
    比如函数接口方法定义为 void accept(T t)  T为泛型标识, 这个时候方法类型为(Object)Void,  在编译时T已确定, 即T由String替换, 这时samMethodType就是 (Object)Void, 而instantiatedMethodType为(String)Void.
    第4, 5, 6 三个参数来自class文件中的. 如上面引导方法字节码中Method arguments后面的三个参数就是将应用于4, 5, 6的参数.

      Method arguments:
          #67 (Ljava/lang/Object;)V
          #70 invokestatic Lambda.lambda$0:(Ljava/lang/String;)V
          #71 (Ljava/lang/String;)V

    我们来看metafactory 的方法里的实现代码

    public static CallSite metafactory(MethodHandles.Lookup caller,
                                           String invokedName,
                                           MethodType invokedType,
                                           MethodType samMethodType,
                                           MethodHandle implMethod,
                                           MethodType instantiatedMethodType)
                throws LambdaConversionException {
            AbstractValidatingLambdaMetafactory mf;
            mf = new InnerClassLambdaMetafactory(caller, invokedType,
                                                 invokedName, samMethodType,
                                                 implMethod, instantiatedMethodType,
                                                 false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY);
            mf.validateMetafactoryArgs();
            return mf.buildCallSite();
        }

    在buildCallSite的函数中

    CallSite buildCallSite() throws LambdaConversionException {
            final Class<?> innerClass = spinInnerClass();

    函数spinInnerClass 构建了这个内部类,也就是生成了一个Lambda$$Lambda$1/716157500 这样的内部类,这个类是在运行的时候构建的,并不会保存在磁盘中,如果想看到这个构建的类,可以通过设置环境参数

    System.setProperty("jdk.internal.lambda.dumpProxyClasses", ".");

    会在你指定的路径 . 当前运行路径上生成这个内部类

    3.静态类

    Java在编译表达式的时候会生成lambda$0静态私有类,在这个类里实现了表达式中的方法块 system.out.println(s);

    private static void lambda$0(java.lang.String);
        descriptor: (Ljava/lang/String;)V
        flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC
        Code:
          stack=2, locals=1, args_size=1
             0: getstatic     #46                 // Field java/lang/System.out:Ljava/io/PrintStream;
             3: aload_0
             4: invokevirtual #50                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
             7: return
          LineNumberTable:
            line 8: 0
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0       8     0     s   Ljava/lang/String;


    当然了在上一步通过设置的jdk.internal.lambda.dumpProxyClasses里生成的Lambda$$Lambda$1.class

     public void accept(java.lang.Object);
        descriptor: (Ljava/lang/Object;)V
        flags: ACC_PUBLIC
        Code:
          stack=1, locals=2, args_size=2
             0: aload_1
             1: checkcast     #15                 // class java/lang/String
             4: invokestatic  #21                 // Method Lambda.lambda$0:(Ljava/lang/String;)V
             7: return
        RuntimeVisibleAnnotations:
          0: #13()

    调用了Lambda.lambda$0静态函数,也就是表达式中的函数块

    总结

    这样就完成的实现了Lambda表达式,使用invokedynamic指令,运行时调用LambdaMetafactory.metafactory动态的生成内部类,实现了接口,内部类里的调用方法块并不是动态生成的,只是在原class里已经编译生成了一个静态的方法,内部类只需要调用该静态方法





    展开全文
  • java虚拟机动态类型语言支持

    千次阅读 2017-08-30 18:59:34
    这篇博客是根据《深入理解java虚拟机》的讲解和本人对动态类型语言的一些认识,来深度剖析一下java虚拟机对动态类型语言的支持!

    这篇博客是根据《深入理解java虚拟机》的讲解和本人对动态类型语言的一些认识,来深度剖析一下java虚拟机对动态类型语言的支持!

    什么是动态类型语言

    在讲解java虚拟机对动态类型语言支持之前,我们首先要弄明白动态类型语言是什么?它与java语言、java虚拟机有什么关系?那么接下来先回答第一个问题,什么是动态类型语言:动态类型语言的关键特征是它的类型检查的主体过程是在运行期而不是编译器,满足这个特征的语言有很多,常用的包括: APL、JavaScript、python、Ruby、Groovy等。相对的在编译期就进行类型检查过程的语言(C++和Java等)就是最常用的静态类型语言。大家可能对上面定义过于概念化,那我们不妨通过几个例子以最浅显的方式说明什么是“在编译器/运行期进行”和什么是“类型检查”。首先看下面这段简单的Java代码:它是否能正常编译和运行呢?

    public static void main(String[] args) {
    		
    		int i = 10;
    		int j = 0;
    		int v = i/j;
    	}

    这段代码相信大家再熟悉不过了,它可以正常编译,但是会运行时会报ArithmeticException异常。在Java虚拟机中规范中明确规定了ArithmeticException是一个运行异常,通俗一点说,运行时异常只要代码不运行到这一行就不会有问题。与运行异常相对应的是编译时异常,接下来看一下编译时异常的例子:

    public static void main(String[] args) {
    		 FileInputStream fis = null;  
    	     fis = new FileInputStream("test.txt");     
    	}

    上面这个例子中 fis = new FileInputStream("test.txt")会抛出IOException异常,这是一个编译时异常,如果不做try-catch处理,编译都通不过。通过上面两个例子就是想说明有些检查是在运行期进行的,有些检查是在编译器进行的。接下来再举一个例子来解释“类型检查”,例如下面这一句非常简单的代码:

          obj = Demo();
          obj.function();

    上面代码中假设Demo是一个类,且里面有function方法,这两行对于Java说,相信大家都知道是无法编译的更别提执行了。但是类似的代码在JavaScript或者Python中情况则不一样,是可以编译并且可以执行的。这种差别产生的原因在于动态类型语言中,变量obj本身是没有类型的,变量obj的值才具有类型,这是因为动态类型语言在运行期确定类型的,而Java或者静态类型语言是编译器确定类型的。孰好孰坏不知道,应该是各有所长吧。

     

    JDK1.7与动态类型

    在介绍完动态类型,回到Java语言、虚拟机和动态类型语言之间的关系。其实Java虚拟机层面对动态类型语言的支持一直都有所欠缺,主要表现在方法调用方面:JDK1.7以前的字节码指令集中,4条方法调用指令(invokevirtual , invokespecial , invokestatic ,invokeinterface)的第一条参数都是被调用的方法的符号引用,前面已经提到过,方法的符号引用在编译时产生,而动态类型语言是在动态运行期才能确定接受者的类型。因此这也就是JDK1.7中invokedynamic指令以及java.lang.invoke包出现要解决的问题。

    java.lang.invoke包

    JDK1.7中新加入的java.lang.invoke包的主要目的就是在之前单纯依靠符号引用来确定的目标方法这种方式以外,提供一种新的动态确定目标方法的机制,称之为MethodHandle。其实MethodHandle就是类似C/C++中的函数指针,或者C#中的委托。举个例子,如果我们要实现一个带有函数参数的排序函数,用函数指针的方如下:
    void sort(int list[], const int size , int (*compare)(int, int)) int (*compare)(int, int))
    但Java语言就做不到这点,即没有办法把一个函数作为参数进行传递。普遍的做法是设计一个带有compare()方法的Comparator接口,以实现了这个接口的对象作为参数。不过,在拥有Method Handle之后,Java语言也可以拥有类似于函数指针或者委托的方法别名的工具了。如下代码演示了MethodHandle的基本用法,无论obj是何种类型,都可以正确的调用到println()方法。
    package demo;
    
    import java.lang.invoke.MethodHandle;
    import java.lang.invoke.MethodType;
    import static java.lang.invoke.MethodHandles.lookup;
    
    public class MethodHandleTest {
    
    	static class ClassA{
    		public void println(String s){
    			System.out.println(s);
    		}
    	}
    	public static void main(String[] args) throws Throwable {
    		Object obj = System.currentTimeMillis() % 2 == 0 ? System.out : new ClassA();
    		
    		//无论obj最终是哪个实现类,下面这句都能正确调用到println方法
    		getPrintlnMH(obj).invokeExact("test");
    	}
    	private static MethodHandle getPrintlnMH(Object reveiver) throws Throwable{
    		//MethodType: 代表"方法类型",包含了方法的返回值(methodType()的第一个参数)和具体参数(methodType()第二个及以后的参数)
    		MethodType mt = MethodType.methodType(void.class,String.class);
    		//lookup()方法来自于MethodHandles.lookup,这句的作用是在指定类中查找符合给定的方法名称、方法类型、并且符合调用权限的方法语柄
    		/*因为这里调用的是一个虚方法,按照Java语言的规则,方法第一个参数是隐式的,代表该方法的接受者,也即是this指向的对象,这个参数以前是放在
    		 参数列表中进行传递的,而现在提供了bindTo方法来完成这件事情*/
    		return lookup().findVirtual(reveiver.getClass(),"println",mt).bindTo(reveiver);
    		
    	}
    }
    
    实际上,方法getPrintlnMH()中模拟了invokevirtual指令的执行过程,只不过它的分派逻辑并非固化在Class字节码上,而是通过一个具体方法来实现。在这里本人仅仅举了MethodHandle来实现java对动态类型的支持。但是还有其他的方法,比如反射、invokedynamic指令,在这里就不再一一细说,这篇博客主要介绍了什么叫做动态类型语言,以及Java对动态类型支持所做的努力。希望能让大家有一个总体印象!
    展开全文
  • JavaScript语言是动态语言、弱类型语言。 静态类型语言、动态类型语言分析: 静态类型语言:变量定义时有类型声明的语言。 1)变量的类型在编译的时候确定 2)变量的类型在运行时不能修改 这样编译器就可以确定...
  • Java语言

    千次阅读 2020-01-19 12:22:35
    所以说Java就是是一门面向对象编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承(Java里面是没有类的多继承的)、指针(Nopoint)等概念,因此Java语言具有功能强大和简单易用两个特征,所以...
  • 什么是Java语言java语言简介

    万次阅读 2010-10-19 09:04:00
    Java是由Sun Microsystems公司于1995年5月推出的Java程序设计语言(以下简称Java语言)和Java平台的总称。用Java实现的HotJava浏览器(支持Java applet)显示了Java的魅力:跨平台、动态的Web、Internet计算。从此,...
  • Java语言特点

    万次阅读 多人点赞 2019-06-30 19:37:45
    Java语言是简单的 Java语言的语法与C语言和C++语言很接近,从某种意义上讲,它是由C和C++演变而来,使得大多数程序员很容易学习和使用。 对C++来说进行了简化和一定的提高,如:使用接口代替了复杂的多重继承以及...
  • Java虚拟机的动态语言支持——访Java SE项目负责人丹尼·考沃德 ◎ 文 Frank Sommers / 译 朱海艳 Java SE 6已不再局限于Java语言了,因为SE 6还可以用来执行动态脚本语言代码。据Sun公司Java SE平台项目的负责人...
  •  JSR 223中规范了在Java虚拟机上运行的脚本语言Java程序之间的交互方式。JSR 233是JavaSE6的一部分,在Java表中API中的包是javax.script。目前Java虚拟机支持比较多的脚本语言,比较流行的有JavaScript、Scala、...
  • Java是静态语言也是强类型定义语言

    千次阅读 2013-09-21 19:23:28
    1、动态语言和静态语言  通常我们所说的动态语言、静态语言是指动态类型语言和静态类型语言。 (1)动态类型语言:动态类型语言是指在运行期间才去做数据类型检查的语言,也就是说,在用动态类型的语言编程时,...
  • 详解Java语言动态代理模式,打开一扇门,见识一片世界。
  • Java语言动态性-invokedynamic

    万次阅读 2017-06-20 09:38:15
    Invokedynamic指令在JAVA7中就已经提供了,在java7之前,JVM字节码提供了如下4种字节码方法调用指令: 1、 Invokevirtual:根据虚方法表调用虚方法。 2、 invokespecial,:调用实例构造方法( 方法),私有...
  • Java语言简介

    千次阅读 2018-12-24 11:38:38
    1.Java编程语言是个简单、完全面向对象、分布式、解释性、健壮、安全与系统无关、可移植、高性能、多线程和动态的编程语言。 2.Java可以撰写跨平台应用软件,是由Sun Microsystems公司于1995年5月推出的Java程序...
  •  JSR 223中规范了在Java虚拟机上运行的脚本语言Java程序之间的交互方式。JSR 233是JavaSE6的一部分,在Java表中API中的包是javax.script。目前Java虚拟机支持比较多的脚本语言,比较流行的有JavaScript、Scala、...
  • JAVA是解释型语言还是编译型语言

    万次阅读 2012-08-30 12:20:00
    JAVA是解释型语言还是编译型语言 Under J2SE | 三月 10th, 2010 1 comment   JAVA是解释型语言还是编译型语言 概念: 编译型语言:把做好的源程序全部编译成二进制代码的可运行程序。然后,可直接...
  • (多选)Java是一门支持反射的语言,基于反射为Java提供了丰富的动态性支持,下面关于Java反射的描述,哪些是错误的:() A. Java反射主要涉及的类如Class, Method, Filed,等,他们都在java.lang.reflet包下 B. 通过...
  • Java 动态

    千次阅读 2015-08-12 18:40:11
    Java不是动态语言,但Java具有一定的动态性,表现在以下几个方面: l 反射机制; l 动态字节码操作; l 动态编译; l 执行其他脚本代码; 下面我们将介绍反射机制和动态字节码操作等内容。 1、 
  • Java是世界上最好的语言

    千次阅读 2019-07-27 16:05:46
    不好意思,Java是世界上最好的语言 Java的特点 ***Java**是一门面向对象编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承、指针等概念,因此Java语言具有功能强大和简单易用两个特征。Java...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 455,708
精华内容 182,283
关键字:

java是动态语言吗

java 订阅