精华内容
下载资源
问答
  • java动态运行代码动态执行

    千次阅读 2020-08-17 16:45:32
    动态编译和执行都可以使用runtime方法在此不讲 动态编译 - 使用JavaCompiler方法进行编译 //动态编译 String path="g:/dynamic/first.java"; //路径 JavaCompiler compiler=ToolProvider....

    若在动态编译过程中出现空指针错误请看这篇文章(点击查看)

    动态编译和执行都可以使用runtime方法在此不讲

    动态编译

    - 使用JavaCompiler方法进行编译

    //动态编译
    		  String path="g:/dynamic/first.java"; //路径
    		  JavaCompiler compiler=ToolProvider.getSystemJavaCompiler(); //调用动态编译的工具
    		  int result =compiler.run(null,null, null, path); //进行动态编译,并返回结果
    		  System.out.println(result==0?"编译成功":"编译失败");
    

    动态运行

    实用类加载器进行操作(之后会专门讲类加载器)
    1、首先构建文件的目录url地址,

    2、使用URLClassLoader对象的loadClass方法加载对应类

    3、获取所加载类的方法

    4、传入方法所需的参数通过invoke运行方法

    //通过反射方法动态执行 
    		  //1、首先构建文件的目录url地址,
    		  URL[] urls =new URL[] {new URL("file:/"+"g:/dynamic/")};
    		  //2、使用URLClassLoader对象的loadClass方法加载对应类
    		  URLClassLoader loder=new URLClassLoader(urls);
    		  //3、获取所加载类的方法
    		  Class clazz =loder.loadClass("first");
    		 // 4、传入方法所需的参数通过invoke运行方法
    		  Method method=clazz.getDeclaredMethod("main", String[].class);
    		  method.invoke(null, (Object)new String[] {}); //当类型为String[]时,需要(Object)new String[] {}初始化
    

    注意点

    1、在构建URL时候一定要是URL数组。因为new URLClassLoader() 只支持URL[]的参数

    2、 在使用loader.loadClass()时,传入的为类名,不要加.class后缀

    3、在使用Method对象的getDeclaredMethod()方法时候第一个参数为获取方法的名字,第二个参数为本方法传入参数的类型

    4、执行invoke()方法时,第一个参数为方法的返回类型。第二个参数为一个对象,例如main方法中的String[]
    args,它本身是一个数组,若不将其强制转换为Object,会产生异常:

    完整代码

    package 动态编译;
    
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.net.MalformedURLException;
    import java.net.URL;
    import java.net.URLClassLoader;
    
    import javax.tools.JavaCompiler;
    import javax.tools.ToolProvider;
    
    
    
    
    
    public class dynamic1 {
    	public static void main(String[] args) throws MalformedURLException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException   {
    		
    		//动态编译
    		  String path="g:/dynamic/first.java"; //路径
    		  JavaCompiler compiler=ToolProvider.getSystemJavaCompiler(); //调用动态编译的工具
    		  int result =compiler.run(null,null, null, path); //进行动态编译,并返回结果
    		  System.out.println(result==0?"编译成功":"编译失败");
    		  
    		//通过反射方法动态执行 
    		  //1、首先构建文件的目录url地址,
    		  URL[] urls =new URL[] {new URL("file:/"+"g:/dynamic/")};
    		  //2、使用URLClassLoader对象的loadClass方法加载对应类
    		  URLClassLoader loder=new URLClassLoader(urls);
    		  //3、获取所加载类的方法
    		  Class clazz =loder.loadClass("first");
    		 // 4、传入方法所需的参数通过invoke运行方法
    		  Method method=clazz.getDeclaredMethod("main", String[].class);
    		  method.invoke(null, (Object)new String[] {}); //当类型为String[]时,需要(Object)new String[] {}初始化
    	}
    }
    
    • 被动态编译带类是 start 作用复制一张图片
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
    展开全文
  • java动态执行代码或者第三方程序并返回pid,杀掉进程 使用java动态执行Java代码或者调用第三方软件,如下代码即可 Process child = Runtime.getRuntime().exec(cmd); 只要写好cmd命令即可,如何同时返回进程的...

    java动态执行代码或者第三方程序并返回pid,杀掉进程

    使用java动态执行Java代码或者调用第三方软件,如下代码即可

    Process child = Runtime.getRuntime().exec(cmd);

    只要写好cmd命令即可,如何同时返回进程的pid呢,这样可以准确的杀掉进程,这里我们需要一个jar用于调用dll

    网上,maven仓库可下载,或者下载结尾源码

    首先把jar buildpath引入,创建一个接口

    import com.sun.jna.Library;
    import com.sun.jna.Native;
    
    import constant.OtherConstant;
    
    public interface Kernel32 extends Library {
    	public static Kernel32 INSTANCE = (Kernel32) Native.loadLibrary("kernel32", Kernel32.class);
    
    	public long GetProcessId(Long hProcess);
    }
    

    调用方法

    // 获取pid
    	public static long getProcessPID(Process child) {
    		long pid = -1;
    		Field field = null;
    		try {
    			field = child.getClass().getDeclaredField("handle");
    			field.setAccessible(true);
    			pid = Kernel32.INSTANCE.GetProcessId((Long) field.get(child));
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return pid;
    	}

    接下来实战模拟一下,首先使用runtime执行class文件,书写代码,编译成class,然后使用runtime执行它,示例代码:

    package example;
    
    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    public class JavaProcess1 {
    	public static void main(String[] args) {
    		for (int i = 0; i < 100; i++) {
    			System.out.println(i);
    //			appendFile("C:\\RICO\\JavaProcess1.txt", "test:  " + i);
    			try {
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    	// 追加文件
    	public static boolean appendFile(String filePath, String content) {
    		FileWriter fw = null;
    		try {
    			// 如果文件存在,则追加内容
    			// 如果文件不存在,则创建文件
    			File f = new File(filePath);
    			fw = new FileWriter(f, true);
    			PrintWriter pw = new PrintWriter(fw);
    			pw.println(content);
    			pw.flush();
    			fw.flush();
    			pw.close();
    			fw.close();
    			return true;
    		} catch (IOException e) {
    			e.printStackTrace();
    			return false;
    		}
    	}
    }
    

    如何编译java执行class详见:https://blog.csdn.net/rico_zhou/article/details/79873344,注意有无package名的区别

    接下来创建两个工具类,一个是用于执行cmd,一个是线程截取输出流

    运行类

    package utils;
    
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.lang.reflect.Field;
    import java.util.HashMap;
    import java.util.Map;
    
    import constant.OtherConstant;
    import constant.SpiderConstant;
    
    public class RunUtils {
    	public static Map<String, Object> messageMap = new HashMap<String, Object>();
    
    	// 运行代码有两种方式,一种是通过反射动态运行,一种是另起进程,这里选择另起进程
    	public static void run(String cmd, int flag) {
    		long pid;
    		try {
    			Process child = Runtime.getRuntime().exec(cmd);
    			messageMap.put(SpiderConstant.SPIDER_KEYWORD_PROCESSMAP_PROCESS, child);
    
    			// 获取此子进程的pid,只windows系统
    			pid = getProcessPID(child);
    			messageMap.put(SpiderConstant.SPIDER_KEYWORD_PROCESSMAP_PID, pid);
    
    			// 获取程序输入流
    			// OutputStream os = child.getOutputStream();
    			// 正常输出流和异常输出流
    			InputStream stdin = child.getInputStream();
    			InputStream stderr = child.getErrorStream();
    			// 启动线程,获取输出流
    
    			if (flag == 0) {
    				ConsoleSimulator cs1 = new ConsoleSimulator(stdin, 0);
    				ConsoleSimulator cs2 = new ConsoleSimulator(stderr, 1);
    				Thread tIn = new Thread(cs1);
    				Thread tErr = new Thread(cs2);
    				tIn.start();
    				tErr.start();
    			}
    
    			// // 启动线程获取输出之后不在阻塞,直接返回,打印输出以轮播形式推送前台
    			// messageMap.put(SpiderConstant.SPIDER_KEYWORD_PROCESSMAP_INPUTSTREAMTHREAD,
    			// tIn);
    			// messageMap.put(SpiderConstant.SPIDER_KEYWORD_PROCESSMAP_INPUTSTREAMCONSOLE,
    			// cs1);
    			// messageMap.put(SpiderConstant.SPIDER_KEYWORD_PROCESSMAP_ERRORSTREAMTHREAD,
    			// tErr);
    			// messageMap.put(SpiderConstant.SPIDER_KEYWORD_PROCESSMAP_ERRORSTREAMCONSOLE,
    			// cs2);
    			// 正在运行
    			messageMap.put(SpiderConstant.SPIDER_KEYWORD_PROCESSMAP_RUNSTATUS, 0);
    			// int result = child.waitFor();
    			// tIn.join();
    			// tErr.join();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    	// 阻塞
    	public static String[] run2(String cmd) {
    		String returnPrintContent = null;
    		String returnErrorContent = null;
    		String[] returnContent = new String[2];
    		try {
    
    			Process child = Runtime.getRuntime().exec(cmd);
    
    			// 获取程序输入流
    			OutputStream os = child.getOutputStream();
    			// 正常输出流和异常输出流
    			InputStream stdin = child.getInputStream();
    			InputStream stderr = child.getErrorStream();
    			// 启动线程
    
    			ConsoleSimulator cs1 = new ConsoleSimulator(stdin, 0);
    			ConsoleSimulator cs2 = new ConsoleSimulator(stderr, 1);
    			Thread tIn = new Thread(cs1);
    			Thread tErr = new Thread(cs2);
    			tIn.start();
    			tErr.start();
    			int result = child.waitFor();
    			tIn.join();
    			tErr.join();
    			returnPrintContent = cs1.getReturnPrintContent();
    			returnErrorContent = cs2.getReturnErrorContent();
    			// 处理中文乱码,需更改服务器端编码
    			// 0是全部信息
    			returnContent[0] = returnPrintContent;
    			// 1是错误信息
    			returnContent[1] = returnErrorContent;
    			return returnContent;
    		} catch (Exception e) {
    			e.printStackTrace();
    			return returnContent;
    		}
    	}
    
    	// 获取pid
    	public static long getProcessPID(Process child) {
    		long pid = -1;
    		Field field = null;
    		try {
    			field = child.getClass().getDeclaredField("handle");
    			field.setAccessible(true);
    			pid = Kernel32.INSTANCE.GetProcessId((Long) field.get(child));
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return pid;
    	}
    }
    

    代码中常量信息请下载源码查看

    输出流线程

    package utils;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.UnsupportedEncodingException;
    
    import constant.CodingConstant;
    import constant.CommonSymbolicConstant;
    
    //另起线程截取程序流
    public class ConsoleSimulator implements Runnable {
    	public boolean isStop = false;
    	public int INFO = 0;
    	public int ERROR = 1;
    	public InputStream is;
    	public int type;
    	public StringBuilder returnPrintContent = new StringBuilder();
    	public StringBuilder returnErrorContent = new StringBuilder();
    	public StringBuilder returnCommonContent = new StringBuilder();
    
    	public ConsoleSimulator(InputStream is, int type) {
    		this.is = is;
    		this.type = type;
    	}
    
    	public void run() {
    		InputStreamReader isr = null;
    		try {
    			isr = new InputStreamReader(is, CodingConstant.CODING_UTF_8);
    		} catch (UnsupportedEncodingException e) {
    			e.printStackTrace();
    		}
    		BufferedReader reader = new BufferedReader(isr);
    		String s;
    		try {
    			// 此地方执行python的时候阻塞,不知为何线程会停止
    			while ((!isStop) && (s = reader.readLine()) != null) {
    				if (s.length() != 0) {
    					if (type == INFO) {
    						System.out.println(s);
    						returnPrintContent.append(s + CommonSymbolicConstant.LINEBREAK2);
    					} else {
    						returnErrorContent.append(s + CommonSymbolicConstant.LINEBREAK2);
    					}
    				}
    			}
    			isStop = true;
    
    		} catch (IOException ex) {
    			ex.printStackTrace();
    		} finally {
    			try {
    				isr.close();
    				reader.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    	public String getReturnPrintContent() {
    		return returnPrintContent.toString();
    	}
    
    	public String getReturnErrorContent() {
    		return returnErrorContent.toString();
    	}
    
    	public String getReturnCommonContent() {
    		return returnCommonContent.toString();
    	}
    
    	public void stop() {
    		isStop = true;
    	}
    
    }
    

    准备工作完成,开始测试,首先测试无阻塞不获取输出流,注意示例代码运行时长为100秒,我们在运行10秒后杀掉

    package runkillprocess;
    
    import constant.CMDConstant;
    import constant.SpiderConstant;
    import utils.RunUtils;
    
    //使用runtime调用第三方程序
    public class RunProcess {
    	public static void main(String[] args) {
    		// 执行无阻塞调用
    		// 子进程动态执行java,class文件
    		long pid = runJavaProcess(1);
    		System.out.println(pid);
    
    		// 十秒后杀掉进程
    		try {
    			Thread.sleep(10000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		stopProcess(pid);
    
    		// 执行阻塞调用
    
    	}
    
    	public static long runJavaProcess(int flag) {
    		String cmd = "java -cp C:\\RICO example.JavaProcess1";
    		RunUtils.run(cmd, flag);
    		// 获取pid
    		return (long) RunUtils.messageMap.get("pid");
    	}
    
    	public static void stopProcess(long pid) {
    		// 拼接命令
    		String cmd = "taskkill /PID " + pid + " /F";
    		// 运行命令
    		String[] returnContent = RunUtils.run2(cmd);
    	}
    }
    

    若不杀掉进程且不获取输出流,则情况如下:

    我们可以看到主程序运行一下就结束了,获取了动态运行的java进行pid为11304,打开任务管理器你会发现11304的进程依然在进行,表明我运行成功。当我们选择10秒后杀掉进程这种情况执行代码,注意管理器中的java进程会在十秒后结束,杀掉成功。

    如果选择读取输出流则控制台将会获取跟cmd执行class一样的内容。

    下面我们选择一个第三方软件试试。调用notepad++打开一个文件,10秒后杀掉

    package runkillprocess;
    
    import constant.CMDConstant;
    import constant.SpiderConstant;
    import utils.RunUtils;
    
    //使用runtime调用第三方程序
    public class RunProcess {
    	public static void main(String[] args) {
    		// 执行无阻塞调用
    		// 子进程调用notepad++,打开一个文件
    		long pid = runJavaProcess(1);
    		System.out.println(pid);
    
    		// 十秒后杀掉进程
    		try {
    			Thread.sleep(10000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		stopProcess(pid);
    
    		// 执行阻塞调用
    
    	}
    
    	public static long runJavaProcess(int flag) {
    		String cmd = "\"C:\\Program Files (x86)\\Notepad++\\notepad++.exe\" C:\\RICO\\icon2.txt";
    		RunUtils.run(cmd, flag);
    		// 获取pid
    		return (long) RunUtils.messageMap.get("pid");
    	}
    
    	public static void stopProcess(long pid) {
    		// 拼接命令
    		String cmd = "taskkill /PID " + pid + " /F";
    		// 运行命令
    		String[] returnContent = RunUtils.run2(cmd);
    	}
    }
    

    完美运行。

    github源码:https://github.com/ricozhou/runkillprocess

    展开全文
  • java动态代码执行

    2020-12-17 11:58:49
    基于groovy框架,进行的简单java动态代码执行;附件中包含java调用groovy具体的代码实现,及测试方法。
  • 主要介绍了Java动态编译执行代码示例,具有一定借鉴价值,需要的朋友可以参考下。
  • Java动态生成代码并编译载入 Java动态生成代码并编译载入
  • Java项目中,或多或少我们有动态执行代码的需求,比如: 系统中有一个规则验证需求,但规则经常改变 代码热更新,热修复 笔者也在目前参与的一个项目中遇到了动态执行代码的需求:项目需要一个自动审核模块,...

    引言

    在Java项目中,或多或少我们有动态执行代码的需求,比如:

    • 系统中有一个规则验证需求,但规则经常改变
    • 代码热更新,热修复

    笔者也在目前参与的一个项目中遇到了动态执行代码的需求:项目需要一个自动审核模块,但是审核规则根据相关书面文件制定,如果写死在.java文件里,那么当新的书面文件下发时,就要系统停机更新系统,然后才能继续使用,其中存在着很多不稳定因素,也很麻烦。因此在设计上就有动态执行代码的需求。好在这个需求只是审核一个表单,并没有对系统的操作和IO操作,输入参数也很固定。

    笔者上网查阅了大量资料,发现网上大致流传三种动态执行代码方式,笔者经过全面比较,选择了其中一种。这里将几种方法列举如下。

    方法

    1.使用JEXL动态执行表达式

    参考利用JEXL实现动态表达式编译 - Narcssus的专栏 - CSDN博客

    JEXL支持两种循环方式:

    for(item : list) {
        x = x + item;
    }
    

    while (x lt 10) {
        x = x + 2;
    }
    
    • 优点:可以动态执行Java代码,调用Java Function(Function需先传入JexlContext)
    • 缺点:只能执行一个“表达式”,而不是Function,所以有很多语法局限,不是真正执行一个Function

    2.使用Java动态编译

    参考[改善Java代码]慎用动态编译 - SummerChill - 博客园

    动态编译一直是Java的梦想,从Java 6版本它开始支持动态编译了,可以在运行期直接编译.java文件,执行.class,并且能够获得相关的输入输出,甚至还能监听相关的事件。不过,我们最期望的还是给定一段代码,直接编译,然后运行,也就是空中编译执行(on-the-fly)。

    • 优点:功能强大,能够真正实现完整的动态执行功能,能够动态调用全部系统功能和IO操作。
    • 缺点:虽然功能强大,可以编译.java文件,但是还是很难在运行时替换框架级的类文件,但是相比于上述方法已经有过之而无不及了;能动态调用全部系统功能和IO操作,与一般代码环境没有隔离,从而会成为项目中一个非常严重的安全隐患处。

    3.使用Java ScriptEngine

    使用Java自带的ScriptEngine可以说是最完美的Java动态执行代码方案之一(不考虑代码热更新等场景),关于ScriptEngine网上有大量资料可供参考,这里就不附参考资料了,简单提供下一个使用JS Engine的例子:

    String regular="function regular(args1,args2,args3){................}";
    ScriptEngine engine = new ScriptEngineManager().getEngineByName("javascript");
    try {
    	engine.eval(regular);
    	if (engine instanceof Invocable) {
    		Invocable invoke = (Invocable) engine;
    		String result = (String) invoke.invokeFunction(
    				"regular", 
    				args1,
    				args2,
    				args3);
    		System.out.println(result);
    		} else {
    			System.out.println("error");
    		}
    	}
    } catch (ScriptException e) {
    	System.out.println("表达式runtime错误:" + e.getMessage());
    }
    

    使用eval(),动态执行一遍JS代码(包含一个JS function),然后利用Java的Invoke传入参数,最后获取返回值。

    • 优点:可以执行完整的JS方法,并且获取返回值;在虚拟的Context中执行,无法调用系统操作和IO操作,非常安全;可以有多种优化方式,可以预编译,编译后可以复用,效率接近原生Java;所有实现ScriptEngine接口的语言都可以使用,并不仅限于JS,如Groovy,Ruby等语言都可以动态执行。
    • 缺点:无法调用系统和IO操作 ,也不能使用相关js库,只能使用js的标准语法。更新:可以使用scriptengine.put()将Java原生Object传入Context,从而拓展实现调用系统和IO等操作。

    对于一般的动态执行代码需求,建议使用最后一种方法。

    展开全文
  • 添加动态执行的编译环境 options 是个集合,添加内容,字符集,classpath等 * 6.传入JavaFileObject的java文件,是个集合,创建JavaSourceObject实现这个接口,Kind.SOURCE.extension = '.java' * 7.创建任务并...
  • demo使用了命令行的方式去执行,将代码段输出到文件中,调用javac编译文件,在使用java命令运行编译好的class,将运行结果输出到控制台上。     demo运行效果:   异常显示效果: 同时使用@...

    demo使用了命令行的方式去执行,将代码段输出到文件中,调用javac编译文件,在使用java命令运行编译好的class,将运行结果输出到控制台上。

     

     

    demo运行效果:

     

    异常显示效果:

    同时使用@RequestMapping(value ="compile3",produces = "text/html; charset=utf-8")解决了上次出现的乱码问题

    展开全文
  • 原理:将文本写到文件,用Java的类加载动态运行。 1.使用jdk自带rt.jar中的javax.tools包提供的编译器(也可以用runtime运行cmd)进行编译java源文件。 2.重写类加载器达到加载指定文件夹下的类。 import javax....
  • JAVA 动态执行字符串代码

    千次阅读 2019-08-05 19:17:24
    执行动态代码调用: public class Test { public String exec(String para) { return para; } public static void main(String[] args) { HashMap,String> map = new HashMap(); map.put("name",...
  • java android 执行脚本代码(java代码)
  • java动态编译 ,写了一个jsp在页面上编辑java代码,然后servlet动态编译并执行main方法
  • 近来要开发一个上传java文件,就能动态的将其加载到内存中并执行它的方法的小功能,在网上找到了一篇不错的api介绍,特将其记下,下面直接进入正题:步骤:1.编译public static Map&lt;String, byte[]&gt; ...
  • Java动态编译源代码并加载执行

    千次阅读 2017-01-08 19:25:33
    最近在看研究Hadoop时,发现官方文档中使用com.sun.tools.javac.Main编译Java代码的,脚本如下。就研究了一番,写了个demo,记录一下,也方便后来人学习。 $ bin/hadoop com.sun.tools.javac.Main WordCount.java...
  • Java直接运行JS代码

    2018-09-27 14:44:11
    Java直接运行JS代码样例 java中调用js脚本 java中直接调用js代码
  • 内存中动态编译执行java代码

    热门讨论 2014-10-25 11:27:58
    不需要任何java类文件,将字符串输入到内存,然后编译,加载,执行,整个过程全部在内存中实现,不会产生.java和.class文件,做到了洁净无污染。
  • 页面上有个textarea,在里面写java代码,然后如何动态编译执行这段java代码??
  • java 停止执行后面代码While working on the threads, sometimes we need to pause the execution of any thread – in that case, we need the concept of pausing the thread execution. 在线程上工作时,有时...
  • 动态编译可以实现:让用户提交一段Java代码,上传到服务器,运行,实现在线评测系统。 Java 6.0之前,可以使用这种方式,达到动态编译的效果: Java 6.0之后,使用如下方式,也就是本文要讲的: 使用JavaCompiler...
  • java代码执行linux系统命令
  • Java动态编译执行

    万次阅读 2017-01-05 16:18:02
    在某些情况下,我们可能需要动态生成java代码,通过动态编译,然后执行代码。JAVA API提供了相应的工具(JavaCompiler)来实现动态编译...下面我们通过一个简单的例子介绍,如何通过JavaCompiler实现java代码动态编译。
  • java 延迟执行代码

    万次阅读 2014-12-25 14:44:09
    通过调试发现,创建一个Timer对象,就会创建一个main线程之外的独立子线程程序,来专门执行计时器里的任务,而任务也被理解成为对象:TimerTask,这也体现了JAVA中一切皆是对象的理念。一个Timer里即使有多个...
  • java异步执行代码

    千次阅读 2018-03-05 16:51:00
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • java动态执行一段代码

    万次阅读 2005-04-03 22:47:00
    动态执行一段简单代码,采用生成java文件,调用javac编译,反射执行的方式。只是一个简单测试,有些地方有待完善。代码如下import java.io.*;/** * 动态执行一段代码(生成文件->编译->执行) * @author kingfish...
  • java执行JavaScript代码

    2019-03-20 03:11:14
    NULL 博文链接:https://relive123-yahoo-com-cn.iteye.com/blog/784700
  • Java代码执行顺序

    千次阅读 2017-02-15 23:58:22
    JAVA是一门面向对象的编程语言,这里考虑“类”在程序开始执行时的执行顺序。class Person{ static { System.out.println("执行Person静态代码块"); } { System.out.println("执行Person构造代码块"); } ...
  • java代码执行顺序详解

    千次阅读 多人点赞 2019-07-15 11:15:19
    今天我们来聊一聊Java的...因为static代码块只在类加载时执行,类是用类加载器来读取的,类加载器是带有一个缓存区的,它会把读取到的类缓存起来,所以在一次虚拟机运行期间,一个类只会被加载一次,这样的话,静态...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,808,922
精华内容 1,123,568
关键字:

java动态执行代码

java 订阅