JAVA启动参数大全
JAVA启动参数大全
文章分类:Java编程
转自：https://www.360docs.net/doc/6c9465311.html,/sawxb/archive/2009/06/15/4269007.aspx
前段时间系统升级时遭遇了OOM，具体解决过程见遭遇 OutOfMemoryError；为了巩固对于java启动各项参数的认识，决定将所有参数列举出来，并一一解释，以便后查；
java启动参数共分为三类；
其一是标准参数（-），所有的JVM实现都必须实现这些参数的功能，而且向后兼容；
其二是非标准参数（-X），默认jvm实现这些参数的功能，但是并不保证所有jvm实现都满足，且不保证向后兼容；
其三是非Stable参数（-XX），此类参数各个jvm实现会有所不同，将来可能会随时取消，需要慎重使用；
本文主要描述标准参数部分，剩下的两个部分将会陆续推出；
标准参数列表如下：
-client
设置jvm使用client模式，特点是启动速度比较快，但运行时性能和内存管理效率不高，通常用于客户端应用程序或者PC应用开发和调试。
-server
设置jvm使server模式，特点是启动速度比较慢，但运行时性能和内存管理效率很高，适用于生产环境。在具有64位能力的jdk环境下将默认启用该模式，而忽略-client参数。
-agentlib:libname[=options]
用于装载本地lib包；
其中libname为本地代理库文件名，默认搜索路径为环境变量PATH中的路径，options为传给本地库启动时的参数，多个参数之间用逗号分隔。在 Windows 平台上jvm搜索本地库名为libname.dll的文件，在linux上jvm搜索本地库名为libname.so的文件，搜索路径环境变量在不同系统上有所不同，比如Solaries 上就默认搜索LD_LIBRARY_PATH。
比如：-agentlib:hprof
用来获取jvm的运行情况，包括CPU、内存、线程等的运行数据，并可输出到指定文件中；windows中搜索路径为JRE_HOME/bin /hprof.dll。
-agentpath:pathname[=options]
按全路径装载本地库，不再搜索PATH中的路径；其他功能和agentlib相同；更多的信息待续，在后续的JVMTI部分会详述。
-classpath classpath
-cp classpath
告知jvm搜索目录名、jar文档名、zip文档名，之间用分号;分隔；使用-classpath 后jvm将不再使用CLASSPATH中的类搜索路径，如果-classpath和CLASSPATH
都没有设置，则jvm使用当前路径(.)作为类搜索路径。
jvm搜索类的方式和顺序为：Bootstrap，Extension，User。
Bootstrap中的路径是jvm自带的jar或zip文件，jvm首先搜索这些包文件，用 System.getProperty("sun.boot.class.path")可得到搜索路径。
Extension是位于JRE_HOME/lib/ext目录下的jar文件，jvm在搜索完Bootstrap 后就搜索该目录下的jar文件，用 System.getProperty("java.ext.dirs")可得到搜索路径。
User搜索顺序为当前路径.、CLASSPATH、-classpath，jvm最后搜索这些目录，用 System.getProperty("java.class.path")可得到搜索路径。
-Dproperty=value
设置系统属性名/值对，运行在此jvm之上的应用程序可用
System.getProperty("property")得到value的值。
如果value中有空格，则需要用双引号将该值括起来，如-Dname="space string"。该参数通常用于设置系统级全局变量值，如配置文件路径，以便该属性在程序中任何地方都可访问。
-enableassertions[:
-ea[:
上述参数就用来设置jvm是否启动断言机制（从JDK 1.4开始支持），缺省时jvm关闭断言机制。
用-ea 可打开断言机制，不加
-ea:com.wombat.fruitbat...
-disableassertions[: -da[: 用来设置jvm关闭断言处理，packagename和classname的使用方法和-ea相同，jvm默认就是关闭状态。 该参数一般用于相同package内某些class不需要断言的场景，比如 com.wombat.fruitbat需要断言，但是 com.wombat.fruitbat.Brickbat该类不需要，则可以如下运行： java -ea:com.wombat.fruitbat...-da:com.wombat.fruitbat.Brickbat -enablesystemassertions 激活系统类的断言。 -disablesystemassertions -dsa 关闭系统类的断言。 -jar 指定以jar包的形式执行一个应用程序。 要这样执行一个应用程序，必须让jar包的manifest文件中声明初始加载的Main-class，当然那Main-class必须有public static void main(String[] args)方法。 -javaagent:jarpath[=options] 指定jvm启动时装入java语言设备代理。 Jarpath文件中的mainfest文件必须有Agent-Class属性。代理类也必须实现公共的静态public static void premain(String agentArgs, Instrumentation inst)方法（和main方法类似）。当jvm初始化时，将按代理类的说明顺序调用premain方法；具体参见 https://www.360docs.net/doc/6c9465311.html,ng.instrument软件包的描述。 -verbose -verbose:class 输出jvm载入类的相关信息，当jvm报告说找不到类或者类冲突时可此进行诊断。-verbose:gc 输出每次GC的相关情况。 -verbose:jni 输出native方法调用的相关情况，一般用于诊断jni调用错误信息。 -version 输出java的版本信息，比如jdk版本、vendor、model。 -version:release 指定class或者jar运行时需要的jdk版本信息；若指定版本未找到，则以能找到的系统默认jdk版本执行；一般情况下，对于jar文件，可以在 manifest文件中指定需要的版本信息，而不是在命令行。 release中可以指定单个版本，也可以指定一个列表，中间用空格隔开，且支持复杂组合，比如： -version:"1.5.0_04 1.5*&1.5.1_02+" 指定class或者jar需要jdk版本为1.5.0_04或者是1.5系列中比1.5.1_02 更高的所有版本。 -showversion 输出java版本信息（与-version相同）之后，继续输出java的标准参数列表及其描述。 -? 输出java标准参数列表及其描述。 -X 输出非标准的参数列表及其描述。 以上的这些参数我们经常会在很多情况下用到多个的组合，比如我们在用JProfiler进行跟踪监控时，需要在被监控java启动参数中加上如下配置： -agentlib:jprofilerti=port=8849 -Xbootclasspath/a:/usr/local/jprofil er5/bin/agent.jar 其中就用到两个-agentlib和-X参数，bootclasspath参数的详细信息将会在非标准参数中详细说明。 ================== 非标准参数又称为扩展参数，其列表如下： -Xint 设置jvm以解释模式运行，所有的字节码将被直接执行，而不会编译成本地码。 -Xbatch 关闭后台代码编译，强制在前台编译，编译完成之后才能进行代码执行； 默认情况下，jvm在后台进行编译，若没有编译完成，则前台运行代码时以解释模式运行。 -Xbootclasspath:bootclasspath 让jvm从指定路径（可以是分号分隔的目录、jar、或者zip）中加载bootclass，用来替换jdk的rt.jar；若非必要，一般不会用到； -Xbootclasspath/a:path 将指定路径的所有文件追加到默认bootstrap路径中； -Xbootclasspath/p:path 让jvm优先于bootstrap默认路径加载指定路径的所有文件； -Xcheck:jni 对JNI函数进行附加check；此时jvm将校验传递给JNI函数参数的合法性，在本地代码中遇到非法数据时，jmv将报一个致命错误而终止；使用该参数后将造成性能下降，请慎用。 -Xfuture 让jvm对类文件执行严格的格式检查（默认jvm不进行严格格式检查），以符合类文件格式规范，推荐开发人员使用该参数。 -Xnoclassgc 关闭针对class的gc功能；因为其阻止内存回收，所以可能会导致 OutOfMemoryError错误，慎用； -Xincgc 开启增量gc（默认为关闭）；这有助于减少长时间GC时应用程序出现的停顿；但由于可能和应用程序并发执行，所以会降低CPU对应用的处理能力。 -Xloggc:file 与-verbose:gc功能类似，只是将每次GC事件的相关情况记录到一个文件中，文件的位置最好在本地，以避免网络的潜在问题。 若与verbose命令同时出现在命令行中，则以-Xloggc为准。 -Xmsn 指定jvm堆的初始大小，默认为物理内存的1/64，最小为1M；可以指定单位，比如k、m，若不指定，则默认为字节。 -Xmxn 指定jvm堆的最大值，默认为物理内存的1/4或者1G，最小为2M；单位与-Xms 一致。 -Xprof 跟踪正运行的程序，并将跟踪数据在标准输出输出；适合于开发环境调试。 -Xrs 减少jvm对操作系统信号（signals）的使用，该参数从1.3.1开始有效； 从jdk1.3.0开始，jvm允许程序在关闭之前还可以执行一些代码（比如关闭数据库的连接池），即使jvm被突然终止； jvm关闭工具通过监控控制台的相关事件而满足以上的功能；更确切的说，通知在关闭工具执行之前，先注册控制台的控制handler，然后对 CTRL_C_EVENT, CTRL_CLOSE_EVENT, CTRL_LOGOFF_EVENT, and CTRL_SHUTDOWN_EVENT这几类事件直接返回true。 但如果jvm以服务的形式在后台运行（比如servlet引擎），他能接收 CTRL_LOGOFF_EVENT事件，但此时并不需要初始化关闭程序；为了避免类似冲突的再次出现，从jdk1.3.1开始提供-Xrs参数；当此参数被设置之后，jvm将不接收控制台的控制handler，也就是说他不监控和处理CTRL_C_EVENT, CTRL_CLOSE_EVENT, CTRL_LOGOFF_EVENT, or CTRL_SHUTDOWN_EVENT事件。 -Xssn 设置单个线程栈的大小，一般默认为512k。 上面这些参数中，比如-Xmsn、-Xmxn……都是我们性能优化中很重要的参数；-Xprof、-Xloggc:file等都是在没有专业跟踪工具情况下排错的好手； 在上一小节中提到的关于JProfiler的配置中就使用到了 -Xbootclasspath/a:path； =============== 前面我们提到用-XX作为前缀的参数列表在jvm中可能是不健壮的，SUN也不推荐使用，后续可能会在没有通知的情况下就直接取消了；但是由于这些参数中的确有很多是对我们很有用的，比如我们经常会见到的-XX:PermSize、 -XX:MaxPermSize等等； 下面我们将就Java HotSpot VM中-XX:的可配置参数列表进行描述； 这些参数可以被松散的聚合成三类： 行为参数（Behavioral Options）：用于改变jvm的一些基础行为； 性能调优（Performance Tuning）：用于jvm的性能调优； 调试参数（Debugging Options）：一般用于打开跟踪、打印、输出等jvm参数，用于显示jvm更加详细的信息； 由于sun官方文档中对各参数的描述也都非常少（大多只有一句话），而且大多涉及OS层面的东西，很难描述清楚，所以以下是挑选了一些我们开发中可能会用得比较多的配置项，若需要查看所有参数列表，可以点击HotSpot VM Specific Options .查看原文； 首先来介绍行为参数： 并行、并发； 串行（SerialGC）是jvm的默认GC方式，一般适用于小型应用和单处理器，算法比较简单，GC效率也较高，但可能会给应用带来停顿； 并行（ParallelGC）是指GC运行时，对应用程序运行没有影响，GC和app两者的线程在并发执行，这样可以最大限度不影响app的运行； 并发（ConcMarkSweepGC）是指多个线程并发执行GC，一般适用于多处理器系统中，可以提高GC的效率，但算法复杂，系统消耗较大； 性能调优参数列表： 调试参数列表： 况下，以上的这些参数就会发挥重大作用了，比如dump堆信息、打印并发锁…… 引用在函数参数传递中的作用 传递参数有三种方法：1，传递对象本身。2，传递指向对象的指针。3，传递对象的引用。 (1)传值方式 ①传给被调用函数的是整型、长整型、浮点型或双精度型变量。被调用的函数得定义相应的变量为形参。 ②传给被调用函数的是结构变量。被调用函数得定义结构变量为形参。 ③传给被调用函数的是结构变量的成员。被调用函数得定义与该成员同类的变量为形参。 #include "stdio.h" ?#include #include "stdio.h" void swapint(); int a,b; void main() { a = 5, b = 10; swapint(); printf("%d\n%d\n",a,b); } void swapint() { int temp; temp=a; a=b; b=temp; } （2）传址方式 ①传给被调用函数的是变量的地址。被调用函数得定义指针变量为形参。 ②传给被调用函数的是数组的地址即数组名。被调用的函数得定义数组或指针变量为形参。 ③传给被调用函数的是函数的地址即函数名称。被调用函数得定义指向函 数的指针变量为形参。④传给被调用函数的是结构的地址。被调用函数得定义结构指针为形参。 #include "stdio.h" ?#include java传值与传引用的三种情况大家先看一个例子: public class Example{ String str=new String("good"); char[]ch={'a','b','c'}; public static void main(String args[]){ Example ex=new Example(); ex.change(ex.str,ex.ch); System.out.print(ex.str+" and "); System.out.print(ex.ch); } public void change(String str,char ch[]){ str="test ok"; ch[0]='g'; } } 看看输出结果？ good and gbc java中没有了c＋＋中这样的引用符号，也没像c＃中那样提供了out与ref 那么它是怎么做的呢 做什么事情都要去除例外的东西，String类就是此类问题的一个特殊情况 为什么特殊呢？ 因为它是一个引用类型，确执行的是值传递。这样说有些抽象，还是举个例子吧 值传递： class Str ｛ public static void main（String[] args） ｛ int i ＝ 900; System.out.println（i）; changeInt（i）; System.Out.println（i）; ｝ public static void changeInt（int s） ｛ s ＝ 34234; ｝ ｝ 结果： 900 900 这就是所谓的值传递。i把自己的副本给了函数changeInt的形参，而在changeInt中虽然将s赋值34234。但是对原来的i值并没有影响，因为它所修改的只是i的copy品而已。 C#中方法的参数有四种类型 1. 值参数(不加任何修饰符,是默认的类型) 2. 引用型参数(以ref 修饰符声明) 3. 输出参数(以out 修饰符声明) 4. 数组型参数(以params 修饰符声明) 1. 值传递: 值类型是方法默认的参数类型，采用的是值拷贝的方式。也就是说，如果使用的是值类型，则可以在方法中更改该值，但当控制传递回调用过程时，不会保留更改的值。 使用值类型的例子如：（下面的Swap()未能实现交换的功能，因为控制传递回调用方时不保留更改的值） using System; class Test { static void Swap(int x, int y) { int temp = x; x = y; y = temp; } static void Main() { int i = 1, j = 2; Swap(i, j); Console.WriteLine("i = {0}, j = {1}", i, j); } } /* * 输出结果为: i=1, j=2 * 未能实现Swap()计划的功能 */ 2. 引用传递(ref类型) ref关键字使参数按引用传递。其效果是，当控制权传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。 2.1. 若要使用ref 参数，则方法定义和调用方法都必须显式使用ref关键字。 2.2. 传递到ref 参数的参数必须最先初始化。这与out 不同，out 的参数在传递之前不需要显式初始化。 2.3. 如果一个方法采用ref 或out 参数，而另一个方法不采用这两类参数，则可以进行重载。 相关实例如下: using System; class Test { static void Swap(ref int x, ref int y) { int temp = x; x = y; y = temp; } static void Main() { int i = 1, j = 2; Swap(ref i, ref j); Console.WriteLine("i = {0}, j = {1}", i, j); } } /* * 引用类型实现了Swap()计划的功能: * 输出为: * i = 2, j =1 */ 3. 输出类型(out类型) out 关键字会导致参数通过引用来传递。这与ref 关键字类似。 与ref 的不同之处： 3.1. ref 要求变量必须在传递之前进行初始化，out 参数传递的变量不需要在传递之前进行初始化。 3.2. 尽管作为out 参数传递的变量不需要在传递之前进行初始化，但需要在调用方法初始化以便在方法返回之前赋值。 示例如下: using System; class Test { static void Swap(out int x, out int y) { //在这里进行了i和j的初始化 转载 原文地址：https://www.360docs.net/doc/6c9465311.html,/clara/archive/2011/09/17/2179493.html Java中的值传递和引用传递 当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递? 答:是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是该对象的引用一个副本。指向同一个对象,对象的内容可以在被调用的方法中改变，但对象的引用(不是引用的副本)是永远不会改变的。 Java参数，不管是原始类型还是引用类型，传递的都是副本(有另外一种说法是传值，但是说传副本更好理解吧，传值通常是相对传址而言)。 如果参数类型是原始类型，那么传过来的就是这个参数的一个副本，也就是这个原始参数的值，这个跟之前所谈的传值是一样的。如果在函数中改变了副本的值不会改变原始的值. 如果参数类型是引用类型，那么传过来的就是这个引用参数的副本，这个副本存放的是参数的地址。如果在函数中没有改变这个副本的地址，而是改变了地址中的值，那么在函数内的改变会影响到传入的参数。如果在函数中改变了副本的地址，如new一个，那么副本就指向了一个新的地址，此时传入的参数还是指向原来的地址，所以不会改变参数的值。 例： 1public class ParamTest { 2public static void main(String[] args){ 3/** 4 * Test 1: Methods can't modify numeric parameters 5 */ 6 System.out.println("Testing tripleValue:"); 7double percent = 10; 8 System.out.println("Before: percent=" + percent); 9 tripleValue(percent); 10 System.out.println("After: percent=" + percent); 11 12/** 13 * Test 2: Methods can change the state of object parameters 14 */ 15 System.out.println("\nTesting tripleSalary:"); 16 Employee harry = new Employee("Harry", 50000); 函数调用参数传递类型（java）的用法介绍. java方法中传值和传引用的问题是个基本问题，但是也有很多人一时弄不清。 （一）基本数据类型：传值，方法不会改变实参的值。 public class TestFun { public static void testInt(int i){ i=5; } public static void main(String[] args) { int a=0 ; TestFun.testInt(a); System.out.println("a="+a); } } 程序执行结果：a=0 。 （二）对象类型参数：传引用，方法体内改变形参引用，不会改变实参的引用，但有可能改变实参对象的属性值。 举两个例子： （1）方法体内改变形参引用，但不会改变实参引用，实参值不变。 public class TestFun2 { public static void testStr(String str){ str="hello";//型参指向字符串“hello” } public static void main(String[] args) { String s="1" ; TestFun2.testStr(s); System.out.println("s="+s); //实参s引用没变，值也不变 } } 执行结果打印：s=1 （2）方法体内，通过引用改变了实际参数对象的内容，注意是“内容”，引用还是不变的。 import java.util.HashMap; import java.util.Map; public class TestFun3 { public static void testMap(Map map){ map.put("key2","value2");//通过引用，改变了实参的内容 } public static void main(String[] args) { Map map = new HashMap(); map.put("key1", "value1"); new TestFun3().testMap(map); System.out.println("map size:"+map.size()); //map内容变化了 } } 执行结果，打印：map size:2 。可见在方法testMap()内改变了实参的内容。 （3）第二个例子是拿map举例的，还有经常涉及的是 StringBuffer ： public class TestFun4 { 在C++中，参数传递的方式是“实虚结合”。 ?按值传递(pass by value) ?地址传递(pass by pointer) ?引用传递(pass by reference) 按值传递的过程为：首先计算出实参表达式的值，接着给对应的形参变量分配一个存储空间，该空间的大小等于该形参类型的，然后把以求出的实参表达式的值一一存入到形参变量分配的存储空间中，成为形参变量的初值，供被调用函数执行时使用。这种传递是把实参表达式的值传送给对应的形参变量，故称这种传递方式为“按值传递”。 使用这种方式，调用函数本省不对实参进行操作，也就是说，即使形参的值在函数中发生了变化，实参的值也完全不会受到影响，仍为调用前的值。 [cpp]view plaincopy 1./* 2. pass By value 3.*/ 4.#include 如果在函数定义时将形参说明成指针，对这样的函数进行调用时就需要指定地址值形式的实参。这时的参数传递方式就是地址传递方式。 地址传递与按值传递的不同在于，它把实参的存储地址传送给对应的形参，从而使得形参指针和实参指针指向同一个地址。因此，被调用函数中对形参指针所指向的地址中内容的任何改变都会影响到实参。 [cpp]view plaincopy 1.#include java参数传递（超经典） (2009-02-20 14:47:22)转载 分类：Java 标签：杂 谈 Java中的参数传递机制一直以来大家都争论不休，究竟是“传值”还是“传址（传引用）”，争论的双方各执一词，互不相让。不但“菜鸟”们一头雾水，一些“老鸟”也只知道结果却说不出所以然来。我相信看过下面的内容后，你就会明白一些。 先看基本类型作为参数传递的例子： public class Test1 { public static void main(String[] args) { int n = 3; System.out.println("Before change, n = " + n); changeData(n); System.out.println("After changeData(n), n = " + n); } public static void changeData(int nn) { n = 10; } } 我想这个例子大家都明白，基本类型作为参数传递时，是传递值的拷贝，无论你怎么改变这个拷贝，原值是不会改变的，输出的结果证明了这一点： Before change, n = 3 After changeData(n), n = 3 那么，我们现在来看看对象作为参数传递的例子，这也是大家争论的地方。public class Test2 { public static void main(String[] args) { StringBuffer sb = new StringBuffer("Hello "); System.out.println("Before change, sb = " + sb); changeData(sb); System.out.println("After changeData(n), sb = " + sb); } public static void changeData(StringBuffer strBuf) { 总结Java方法(函数)传值和传引用的问题 java方法中传值和传引用的问题是个基本问题，但是也有很多人一时弄不清。 （一）基本数据类型：传值，方法不会改变实参的值。 public class TestFun { public static void testInt(int i){ i=5; } public static void main(String[] args) { int a=0 ; TestFun.testInt(a); System.out.println("a="+a); } } 程序执行结果：a=0 。 （二）对象类型参数：传引用，方法体内改变形参引用，不会改变实参的引用，但有可能改变实参对象的属性值。 举两个例子： （1）方法体内改变形参引用，但不会改变实参引用，实参值不变。 public class TestFun2 { public static void testStr(String str){ str="hello";//型参指向字符串“hello” } public static void main(String[] args) { String s="1" ; TestFun2.testStr(s); System.out.println("s="+s); //实参s引用没变，值也不变 } } 执行结果打印：s=1 （2）方法体内，通过引用改变了实际参数对象的内容，注意是“内容”，引用还是不变的。 import java.util.HashMap; import java.util.Map; public class TestFun3 { public static void testMap(Map map){ map.put("key2","value2");//通过引用，改变了实参的内容 } public static void main(String[] args) { Map map = new HashMap(); map.put("key1", "value1"); new TestFun3().testMap(map); System.out.println("map size:"+map.size()); //map内容变化了 } } 执行结果，打印：map size:2 。可见在方法testMap()内改变了实参的内容。 （3）第二个例子是拿map举例的，还有经常涉及的是 StringBuffer ： public class TestFun4 { 深入了解C语言(函数的参数传递和函数使用参数的方法) C语言生成的代码在执行效率上比其它高级语言都高.现在让我们来看看C语言生成的代码具体是什么样子的.当你看完本文对于C语言的了解一定会更深一步了. 本文通过一个个实际案例程序来讲解C语言. 研究案例一 工具: Turboc C v2.0,Debug,MASM v5.0,NASM 实例C程序: /* example1.c */ char ch; int e_main() { e_putchar(ch); } 目标内容:C语言调用函数的方法与细节 我们使用的C编译器是16位的Turboc C v2.0,它生成的是16位的代码,比较简单,方便我们来研究.同时我们也需要用到DOS下的DEBUG来进行反汇编.由于我们很多案例中的程序并不是完整的C程序,所以Turboc下的Tlink并不能为我们生成目标程序,所以我将使用MASM 中的link.exe,同时里面的https://www.360docs.net/doc/6c9465311.html,也可以为我们把exe文件转换成bin文件. 这个程序没有main函数,我们用e_main来代替main函数.这样我们能避开C语言对main函数进行一系列处理的代码.同样,我们也用e_putchar()来代替我们平常使用的putchar().这里"e"的意思就是"example". 没有了main函数,我们的C程序就没有了入口,所以在开始编译这段C代码之前,我还得写几行简单的汇编代码,通过它来作为我们程序的入口. ; C程序的入口start.asm [BITS 16] [global start] [extern _e_main] start: call _e_main 按照C语言的习惯,所以C总的名词都要自动在前面加一个"_"下划线.所以,我们在C中的e_main函数,如果要在汇编中调用,就变成了_e_main函数.这段汇编代码只有一句:call _e_main,就是调用我们在C中的e_main函数 java参数是如何传递的 总的来说，计算机语言给子程序传递参数的方法有两种。第一种方法是按值传递（call-by-value ）。这种方法将一个参数值（value ）复制成为子程序的正式参数。这样，对子程序的参数的改变不影响调用它的参数。第二种传递参数的方法是引用调用（call-by-reference ）。在这种方法中，参数的引用（而不是参数值）被传递给子程序参数。在子程序中，该引用用来访问调用中指定的实际参数。这样，对子程序参数的改变将会影响调用子程序的参数。你将看到，根据传递的对象不同，Java 将使用这两种不同的方法。 在Java 中，当你给方法传递一个简单类型时，它是按值传递的。因此，接收参数的子程序参数的改变不会影响到该方法之外。例如，看下面的程序： // Simple types are passed by value. class Test { void meth(int i，int j) { i *= 2;j /= 2; } } class CallByValue { public static void main(String args[]) { Test ob = new Test(); int a = 15，b = 20; System.out.println("a and b before call: " +a + " " + b); ob.meth(a，b); System.out.println("a and b after call: " +a + " " + b); } } 该程序的输出如下所示： a and b before call: 15 20 a and b after call: 15 20 可以看出，在meth( ) 内部发生的操作不影响调用中a和b的值。它们的值没在本例中没有变为30和10。 当你给方法传递一个对象时，这种情形就会发生戏剧性的变化，因为对象是通过引用传递的。记住，当你创建一个类类型的变量时，你仅仅创建了一个类的引用。因此，当你将这个引用传递给一个方法时，接收它的参数将会指向该参数指向的同一个对象。这有力地证明了对象是通过引用调用传递给方法的。该方法中对象的改变确实影响了作为参数的对象。例如，考虑下面的程序： // Objects are passed by reference. class Test { int a，b; Test(int i，int j) {a = i;b = j; } // pass an object void meth(Test o) { SpringMVC向页面传递参数的4种方式 1、使用HttpServletRequest和Session 然后setAttribute()，就和Servlet 中一样 request.setAttribute(“user”,user_data); 2、使用ModelAndView对象 @RequestMapping("/login.do") publicModelAndView login(String name,String pass) { User user = userService.login(name,pwd); Map java参数传递时到底是值传递还是引用传递(baidu搜集) 最近比较长一段时间以来，网上的IT同行里面比较流行“JAVA面试32问”，很多人的BLOG里都引用这些面试题，最近因为工作内容比较枯燥，也来看看这些试题以调节一下口味，其中有一道题让我很费解。 原题是：当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递? 用google查询结果，得到答案基本上是：值传递。当时觉得挺纳闷儿，为什么连参数的内容都被修改了，怎么还能说是“值传递”呢？因为在传统的印象里（尤其是从C++过来以后），值传递都应该是不改变原参数的。 问问周围的同事，也大都这么讲，但是也都讲不清这种理论的根源是什么。我这个人有个毛病，有事情想不通时就会憋得难受，后来在《Thinking in Java》的一段内容（注解[1]）里找到了自己的结论，我认为（《Thinking in Java》的作者也这么认为）：可以说是值传递，也可以说是引用传递。 一，认为是值传递。得出这种结论的前提必须是“参数的值就是对该对象的引用，而不是对象的内容”，这句话可能有些费解，举个例子加以说明。 public class Paier { public static void main(String[] args) { Paier paier = new Paier(); paier.test(); } public void test() { TestClass para1 = new TestClass(); para1.setTest(new Integer(10)); TestClass result1 = test1(para1); System.out.println("para1 = " + para1.getTest()); System.out.println("result1 = " + result1.getTest()); TestClass para2 = new TestClass(); para2.setTest(new Integer(10)); TestClass result2 = test2(para2); System.out.println("para2 = " + para2.getTest()); System.out.println("result2 = " + result2.getTest()); } public TestClass test1(TestClass t) { java语言深入（java中是传值还是引用） 关键字: java基础深入 熟悉C的程序员都用过指针，对指针可谓爱之深恨之切。指针是指向一块内存地址的内存数据（有些拗口），也就是说指针本身是一个占用4字节内存的int（32 位系统内），而这个int值恰恰又是另一块内存的地址。比如"hello"这个字串，存放在@0x0000F000这个地址到@0x0000F005这段内存区域内（包括0x00的结束字节）。而在@0x0000FFF0到@0x0000FFF03这四个字节内存放着一个int，这个int的值是@0x0000F000。这样就形成了一个指向"hello"字串的指针。 在Java中，很多人说没有指针，事实上，在Java更深层次里，到处都是大师封装好的精美绝伦的指针。为了更容易的讲解Java 中关于类和类型的调用，Java中出现了值与引用的说法。浅显的来说，我们可以认为Java中的引用与C中的指针等效（其实差别非常非常大，但是为了说明我们今天的问题，把他们理解为等效是没有任何问题的）。 所谓传引用的说法是为了更好的讲解调用方式。基于上面对指针的理解，我们不难看出，指针其实也是一个int值，所谓传引用，我们是复制了复制了指针的int值进行传递。为了便于理解，我们可以姑且把指针看作一种数据类型，透明化指针的int特性，从而提出传引用的概念。 重申一遍：Java中只有传值。 1所谓传值和传引用 传值和传引用的问题一直是Java里争论的话题。与C++不同的，Java里面没有指针的概念，Java的设计者巧妙的对指针的操作进行了管理。事实上，在懂C++的Java程序员眼中，Java到处都是精美绝伦的指针。 下面举个简单的例子，说明什么是传值，什么是传引用。 //例1 void method1(){ int x=0; this.change(x); System.out.println(x); } void int change(int i){ i=1; } 很显然的，在mothod1中执行了change(x)后，x的值并不会因为change方法中将输入参数赋值为1而变成1，也就是说在执行change(x)后，x的值z依然是0。这是因为x传递给change(int i)的是值。这就是最简单的传值。 同样的，进行一点简单的变化。 //例2 void method1(){ StringBuffer x=new StringBuffer("Hello"); this.change(x); System.out.println(x); } java学习笔记(四)----对象、数组作为参数传递，静态变量、静态方法的使用，内部类，使用文档注释 2009-10-15 20:21 ＊＊＊对象作为参数传递＊＊＊ class passparam { int x; public static void main(String[] args) { passparam obj = new passparam(); obj.x=5; change(obj); System.out.println(obj.x); //如果change方法不是静态的，想调用它就得写成new passparam().change(obj); } public static void change(passparam obj) //如果这个函数前面没加static编译出错，因为非静态方法，不能被静态方法直接调用，main 是一个静态方法。 { obj.x=3;} } 结果：3 ＊＊＊数组作为参数传递＊＊＊ class passparam { int x; public static void main(String[] args) { passparam obj = new passparam(); int []x=new int[1]; x[0]=5; change(x); System.out.println(x[0]); } public static void change(int[] x) { x[0]=3; } } 结果：3 ＊＊＊静态变量、静态方法的使用＊＊＊ 静态变量相当于全局变量 class Chinese { static string country="中国"; //如果改为private static string country="中国" 下面的两处调用，就会出错 String name; int age; static void sing() { System.out.println("啊~~") void singOurCountry() { System.out.println(country); sing(); } } 基于java的数据传输设计的实验报告 基于Java和OPC技术的分布式远程监控系统，系统的结构模型如图1所示。系统的功能是：实现对生产过程的数据采集和存贮，并在远程客户端实现对采集过程的监测和控制。 １.介绍 系统采用多层Client/Server结构。总体上可以分为3个层次：数据服务器层、应用服务器层和客户端。数据服务器负责提供所需的数据，包括系统的实时数据、历史数据和报警信息等；应用服务器接收客户端发出的请求信息，根据客户端的请求与数据服务器进行交互，实现客户端的请求。客户端负责数据曲线的显示，并负责处理用户的监控请求。 2.１系统中的数据传送问题 本系统采用分布式技术，应用服务器和远程客户端分别位于网络中不同的主机上，采集的数据用RMI技术通过网络从服务器端传送到客户端。 系统中，客户端需要完成两项任务，一是对采集过程的监测和控制，并用波形图把采集的数据实时地显示在客户端界面上，这就要求数据采集服务器采集的数据实时的传送到客户端，保证监控的实时性。客户端的另一项任务是，把从服务器端传送过来的数据保存在客户端计算机上，以便用户能浏览和分析采集到的数据。为保证对数据分析的正确和完整，数据采集服务器采集的数据应全部传送到客户端，这就要求数据传送的准确性，即数据应无丢失的在网络上进行传送。总之，数据从服务器端传送到远程客户端时，应满足数据传送的实时性和准确性。 然而，当数据在网络上进行传送时，由于网络的连接情况和拥塞情况具有一定的随机性，很多时候会出现网络抖动的情况，造成客户端与服务器端失去连接，使数据传送中断。为保证数据传送的实时性和准确性，需采取措施，当网络连接出现短时断开的时候，客户端和服务器端应能自动重新建立连接，使实时监控和数据保存继续进行。对于由于网络短时中断时没能传送的数据，应采用缓存的方法，待连接重新建立后，再把这些数据进行传送。 ３.１数据传送方案及数据缓存的实现 如前所述，客户端需要完成两项任务：一是对数据采集进行实时监控，二是把从服务器端传送过来的数据保存在客户端计算机上。在这两项任务中，实时监控任务要求保证数据的实时性，即服务器端采集的数据应实时地传送到客户端，让用户及时了解数据采集的情况。而数据保存任务需要的是数据传送的准确和完整，即采集的数据应无丢失的从服务器端传送到客户端。考对传送的要求，为保证他们都能满足各自的功能，本系统在设计数据传送时，把实时监控部分和数据保存部分分开，即分别通过不同的途径从服务器端获得数据。 对数据保存部分，采用在服务器端先用数组缓存数据，缓存数组中的数据达到一定数量后，由服务器主动一次性把这些数据传送到客户端。具体的方法是：在服务器端，对每一通道的数据先用两个数组交替进行缓存，数据采集服务器传送过来的数据先放进数组1，当数据满一定数量后（例如200个），由数组 2接着接收数据，与此同时，新开一个线程，把数组中的数据通过远程方法调用主动传送给客户端。在传送数组时如果网络是中断的，则可利用后面介绍的重连接机制，让客户和服务器重新建立连接，只要在数组2接收200个数据的过程中，连接能够重新建立，把数组1传送成功，就可以保证数据无丢失的传送。这就是本远程监控系统在网络短时中断时，利用数组对数据进行缓存的原理所在。数组2接收满200个数据后，新开一个线程传送数组2，同时由数组1 public class Test5 { public static void main(String[] args) { int [] a = { 1, 2, 3, 4, 5 }; int [] b = new int [a.length ]; System.out .println("交换前："); print (a); print (b); b = swap (a); System.out .println("交换后："); print (a); print (b); } private static void print(int [] a) { for (int i = 0; i < a.length ; i++) { System.out .print(" " + a[i]); } System.out .println(); } private static int [] swap(int [] c) { int [] tmp = new int [c.length ]; for (int j = 0; j < c.length ; j++) { tmp[j] = c[c.length - j - 1] + 10; } return tmp; } } 结果： 交换前： 1 2 3 4 5 0 0 0 0 0 交换后： 1 2 3 4 5 15 14 13 12 11 说明： 在该程序中，在调用swap()方法时，，数组a 将其地址传递给数组c ，所以a 和c 是指向同一个数组。 但在swap 方法中,新生成了一个数组tmp,改变是在tmp 数组上进行的.返回时把tmp 数组的首地址送数组b.所以b 指向改变后数组tmp. public class Test5 { public static void main(String[] args) { int [] a = { 1, 2, 3, 4, 5 }; int [] b = new int [a.length ]; System.out .println("交换前："); print (a); print (b); b = swap (a); System.out .println("交换后："); print (a); print (b); } private static void print(int [] a) { for (int i = 0; i < a.length ; i++) { System.out .print(" " + a[i]); } System.out .println(); } private static int[] swap(int [] c) { for (int j = 0; j < a.length ; j++) { c[j] = c[c.length - j - 1] + 10; } return c ; } } 结果： 交换前： 1 2 3 4 5 0 0 0 0 0 交换后： 15 14 13 24 25 15 14 13 24 25 说明： 在该程序中，在调用swap()方法时，数组a 将其地址传递给数组c ，所以a 和c 是指向同一个数组。 返回时,数组b 不再指向原来的数组,而指向c 所在的数组。 注: JAVA 中参数传递时是值传递,引用型与基本数据类型是不同的. 1 2 3 4 5 15 14 13 12 11 a[ ] c[ ] 0 0 0 0 0 b[ ] a[ ] c[ ] b[ ] 1 2 3 4 5 1 2 3 4 5 a[ ] c[ ] 0 0 0 0 0 b[ ] a[ ] c[ ] b[ ] 15 14 13 12 11 值传递：方法调用时，实际参数把它的值传递给对应的形式参数，方法执行中形式参数值的改变不影响实际参数的值。（参数类型为基本数据类型） 引用传递：也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，方法执行中形式参数值的改变将会影响实际参数的值。（类和数组） 下面举例说明： 传值---传递基本数据类型参数 public class PassValue{ static void exchange(int a, int b){//静态方法，交换a,b的值 int temp; temp = a; a = b; b = temp; } public static void main(String[] args){ int i = 10; int j = 100; System.out.println("before call: " + "i=" + i + "\t" + "j = " + j);//调用前 exchange(i, j); //值传递，main方法只能调用静态方法 System.out.println("after call: " + "i=" + i + "\t" + "j = " + j);//调用后 } } 运行结果： before call: i = 10 j = 100 after call: i = 10 j = 100 说明：调用exchange(i, j)时，实际参数i，j分别把值传递给相应的形式参数a，b,在执行方法exchange()时，形式参数a，b的值的改变不影响实际参数i和j的值，i和j的值在调用前后并没改变。 引用传递---对象作为参数 如果在方法中把对象（或数组）作为参数，方法调用时，参数传递的是对象的引用（地址），即在方法调用时，实际参数把对对象的引用（地址）传递给形式参数。这是实际参数与形式参数指向同一个地址，即同一个对象（数组），方法执行时，对形式参数的改变实际上就是对实际参数的改变，这个结果在调用结束后被保留了下来。 class Book{ String name; private folat price; Book(String n, float ){ //构造方法 name = n; price = p; } static void change(Book a_book, String n, float p){ //静态方法，对象作为参数 a_https://www.360docs.net/doc/6c9465311.html, = n;参数传递方式
Java中传值与传引用的三种情况
C#中方法的参数有四种类型
java中的值传递和引用传递
函数调用参数传递类型(java)的用法介绍.
C++中函数调用时的三种参数传递方式
java参数传递(经典)
总结Java方法(函数)传值和传引用的问题
深入了解C语言(函数的参数传递和函数使用参数的方法)
java参数是如何传递的
SpringMVC向页面传递参数的4种方式
java参数传递时到底是值传递还是引用传递
Java值传递和引用
java对象、数组作为参数传递,静态变量、静态方法的使用,内部类,使用文档注释
基于java的数据传输设计的实验报告 高灵琪 1110230015
关于JAVA中参数地址传递的问题
java中的值传递和引用传递