`
m635674608
  • 浏览: 5042987 次
  • 性别: Icon_minigender_1
  • 来自: 南京
社区版块
存档分类
最新评论

java 之方法调用 方法传参 值传递还是引用传递字节码

    博客分类：
  • java
 
阅读更多 
/*Java中的参数传递方式到底是引用传递还是值传递？java核心技术卷I里有一个结

论我觉得挺有意思的：java中没有引用传递，只有值传递 
首先看定义： 
值传递，是指方法接收的是调用者提供的值 
引用传递，是指方法接收的是调用者提供的变量地址
事实上，Java中方法参数传递的是原来对象引用的copy（副本）。如果你在方法

中改变这个copy中的内容，因为这个copy也是指向原对象，所以改变会生效。给

你带来好像Java中存在地址传递一样。而实际上当你对这个对象的引用进行操作

，例如object = new SomeObject();这样的操作是无效的，因为你改变的是这个

copy（副本），原来的引用还是指向原来的对象，并没有发生变化。方法传参就

相当于这个

 */
package com.zhang;

public class Test6 {
	String name = "t";

	void change(Test5 t2) {
	};

	void change2(Test5 t2) {
		t2 = new Test5();
	};

	public static void main(String[] args) {
		Test5 t = new Test5();
		Test5 t2 = t;

		/*
		 * //这一步t2就相当于调用方法的对象copy副本.就相当于这样change(Test5 t2)。 t2.name =
		 * "hao";当t2副本对象改变了name属性的值同时，t的对象name值也改变 了。因为。t,和 副本t2。指向的都是new
		 * Test5();这个对象。当我们企图change(Test5 t2){t2 = new Test5();}
		 * 没有改变t2的值是因为函数change(Test5 t2){t2 = new Test5();}中的引用只是原对象引用
		 * 的一个副本，即t2，并不是t。既然如此，我们在函数中只是改变了引用t2所指向 的对象，而没有改变引用t所指向的对象。
		 * 所以当调用change(Test5 t2){t2 = new Test5();}方法时候。t2.name结果还是 “好”
		 */
		System.out.println(t.name);
	}
}

/*
 *  *Compiled from "Test5.java" public
 * 
 * class Test5 extends java.lang.Object SourceFile: "Test5.java" minor
 * 
 * version: 0 major version: 50 Constant pool: const #1 = Method #9.#20;
 * 
 * // java/lang/Object."<init>":()V const #2 = String #21; // t const #3 =
 * 
 * Field #4.#22; // Test5.name:Ljava/lang/String; const #4 = class #23; //
 * 
 * Test5 const #5 = Method #4.#20; // Test5."<init>":()V const #6 = String
 * 
 * #24; // hao const #7 = Field #25.#26; //
 * 
 * java/lang/System.out:Ljava/io/PrintS tream; const #8 = Method #27.#28;
 * 
 * // java/io/PrintStream.println:(Ljava/l ang/String;)V const #9 = class
 * 
 * #29; // java/lang/Object const #10 = Asciz name; const #11 = Asciz
 * 
 * Ljava/lang/String;; const #12 = Asciz <init>; const #13 = Asciz ()V;
 * 
 * const #14 = Asciz Code; const #15 = Asciz LineNumberTable; const #16 =
 * 
 * Asciz main; const #17 = Asciz ([Ljava/lang/String;)V; const #18 = Asciz
 * 
 * SourceFile; const #19 = Asciz Test5.java; const #20 = NameAndType
 * 
 * #12:#13;// "<init>":()V const #21 = Asciz t; const #22 = NameAndType
 * 
 * #10:#11;// name:Ljava/lang/String; const #23 = Asciz Test5; const #24 =
 * 
 * Asciz hao; const #25 = class #30; // java/lang/System const #26 =
 * 
 * NameAndType #31:#32;// out:Ljava/io/PrintStream; const #27 = class #33;
 * 
 * // java/io/PrintStream const #28 = NameAndType #34:#35;// println:
 * 
 * (Ljava/lang/String;)V const #29 = Asciz java/lang/Object; const #30 =
 * 
 * Asciz java/lang/System; const #31 = Asciz out; const #32 = Asciz
 * 
 * Ljava/io/PrintStream;; const #33 = Asciz java/io/PrintStream; const #34
 * 
 * = Asciz println; const #35 = Asciz (Ljava/lang/String;)V; {
 * 
 * java.lang.String name; public Test5(); Code: Stack=2, Locals=1,
 * 
 * Args_size=1 0: aload_0 1: invokespecial #1; //Method
 * 
 * java/lang/Object."<init>":()V 4: aload_0 5: ldc #2; //String t 7:
 * 
 * putfield #3; //Field name:Ljava/lang/String; 10: return
 * 
 * LineNumberTable: line 1: 0 line 2: 4 public static void main
 * 
 * (java.lang.String[]); Code: Stack=2, Locals=3, Args_size=1 0: new #4;
 * 
 * //class Test5 创建一个新对象，并压入栈顶 3: dup ////复制栈顶数值，并将
 * 
 * 复制值压入栈顶 4: invokespecial #5; //Method "<init>":()V 7: astore_1
 * 
 * ////将栈顶引用类型数值存到第二个本地变量（局部变量表） 8: aload_1 //将
 * 
 * 第二个引用类型本地变量推送至栈顶 9: astore_2 //将栈顶引用类型数值存到第
 * 
 * 三个本地变量（局部变量表） 10: aload_2 //将第三个引用类型本地变量推送至
 * 
 * 栈顶 11: ldc #6; //String hao 将string hao常量从常量池取出，推入栈顶
 * 
 * 13: putfield #3; //Field name:Ljava/lang/String;//为对象的name字段赋值
 * 
 * 16: getstatic #7; //Field java/lang/System.out:Ljava/io/PrintStream;
 * 
 * 19: aload_1 //将第二个引用类型本地变量推送至栈顶(13步已经把对象引用对象
 * 
 * name地段赋值了) 20: getfield #3; //Field name:Ljava/lang/String; //获取
 * 
 * 对象的相应字段name。并压入栈顶 23: invokevirtual #8; //Method
 * 
 * java/io/PrintStream.println:(Ljava/lang/Str ing;)V 26: return
 * 
 * LineNumberTable: line 4: 0 line 5: 8 line 6: 10 line 7: 16 line 8: 26 }
 */


 package com.zhang;
public class Test{
    public static void changeStr(String str){
        str="welcome";
    }
    public static void main(String[] args) {
        String str="1234";
        changeStr(str);
        System.out.println(str);
    }
}
/*
 * Compiled from "Test.java"
public class Test extends java.lang.Object
  SourceFile: "Test.java"
  minor version: 0
  major version: 50
  Constant pool:
const #1 = Method       #8.#19; //  java/lang/Object."<init>":()V
const #2 = String       #20;    //  welcome
const #3 = String       #21;    //  1234
const #4 = Method       #7.#22; //  Test.changeStr:(Ljava/lang/String;)V
const #5 = Field        #23.#24;        //  java/lang/System.out:Ljava/io/PrintS
tream;
const #6 = Method       #25.#26;        //  java/io/PrintStream.println:(Ljava/l
ang/String;)V
const #7 = class        #27;    //  Test
const #8 = class        #28;    //  java/lang/Object
const #9 = Asciz        <init>;
const #10 = Asciz       ()V;
const #11 = Asciz       Code;
const #12 = Asciz       LineNumberTable;
const #13 = Asciz       changeStr;
const #14 = Asciz       (Ljava/lang/String;)V;
const #15 = Asciz       main;
const #16 = Asciz       ([Ljava/lang/String;)V;
const #17 = Asciz       SourceFile;
const #18 = Asciz       Test.java;
const #19 = NameAndType #9:#10;//  "<init>":()V
const #20 = Asciz       welcome;
const #21 = Asciz       1234;
const #22 = NameAndType #13:#14;//  changeStr:(Ljava/lang/String;)V
const #23 = class       #29;    //  java/lang/System
const #24 = NameAndType #30:#31;//  out:Ljava/io/PrintStream;
const #25 = class       #32;    //  java/io/PrintStream
const #26 = NameAndType #33:#14;//  println:(Ljava/lang/String;)V
const #27 = Asciz       Test;
const #28 = Asciz       java/lang/Object;
const #29 = Asciz       java/lang/System;
const #30 = Asciz       out;
const #31 = Asciz       Ljava/io/PrintStream;;
const #32 = Asciz       java/io/PrintStream;
const #33 = Asciz       println;

{
public Test();
  Code:
   Stack=1, Locals=1, Args_size=1
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return
  LineNumberTable:
   line 1: 0


public static void changeStr(java.lang.String);
  Code:
   Stack=1, Locals=1, Args_size=1
   0:   ldc     #2; //String welcome 将string welcome常量从常量池取出，推入栈顶
   2:   astore_0 //将栈顶引用类型数值存到第一个本地变量（局部变量表）
   3:   return
  LineNumberTable:
   line 3: 0
   line 4: 3


public static void main(java.lang.String[]);
  Code:
   Stack=2, Locals=2, Args_size=1
   0:   ldc     #3; //String 1234 将string 1234常量从常量池取出，推入栈顶
   2:   astore_1  //将栈顶引用类型数值存到第二个本地变量（局部变量表）
   3:   aload_1   //将第二个引用类型本地变量推送至栈顶
   4:   invokestatic    #4; //Method changeStr:(Ljava/lang/String;)V
   7:   getstatic       #5; //Field java/lang/System.out:Ljava/io/PrintStream;
   10:  aload_1   //将第二个引用类型本地变量推送至栈顶
   11:  invokevirtual   #6; //Method java/io/PrintStream.println:(Ljava/lang/Str
ing;)V
   14:  return
  LineNumberTable:
   line 6: 0
   line 7: 3
   line 8: 7
   line 9: 14


}

 * */

 

package com.zhang;
public class Test2{
    public static void changeStr(String str){
        str="welcome";
    }
    public static void main(String[] args) {
        String str="1234";
        str = "welcome";
       // changeStr(str);
        System.out.println(str);
    }


}

/**
 *Compiled from "Test2.java"
public class Test2 extends java.lang.Object
  SourceFile: "Test2.java"
  minor version: 0
  major version: 50
  Constant pool:
const #1 = Method       #7.#18; //  java/lang/Object."<init>":()V
const #2 = String       #19;    //  welcome
const #3 = String       #20;    //  1234
const #4 = Field        #21.#22;        //  java/lang/System.out:Ljava/io/PrintS
tream;
const #5 = Method       #23.#24;        //  java/io/PrintStream.println:(Ljava/l
ang/String;)V
const #6 = class        #25;    //  Test2
const #7 = class        #26;    //  java/lang/Object
const #8 = Asciz        <init>;
const #9 = Asciz        ()V;
const #10 = Asciz       Code;
const #11 = Asciz       LineNumberTable;
const #12 = Asciz       changeStr;
const #13 = Asciz       (Ljava/lang/String;)V;
const #14 = Asciz       main;
const #15 = Asciz       ([Ljava/lang/String;)V;
const #16 = Asciz       SourceFile;
const #17 = Asciz       Test2.java;
const #18 = NameAndType #8:#9;//  "<init>":()V
const #19 = Asciz       welcome;
const #20 = Asciz       1234;
const #21 = class       #27;    //  java/lang/System
const #22 = NameAndType #28:#29;//  out:Ljava/io/PrintStream;
const #23 = class       #30;    //  java/io/PrintStream
const #24 = NameAndType #31:#13;//  println:(Ljava/lang/String;)V
const #25 = Asciz       Test2;
const #26 = Asciz       java/lang/Object;
const #27 = Asciz       java/lang/System;
const #28 = Asciz       out;
const #29 = Asciz       Ljava/io/PrintStream;;
const #30 = Asciz       java/io/PrintStream;
const #31 = Asciz       println;

{
public Test2();
  Code:
   Stack=1, Locals=1, Args_size=1
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return
  LineNumberTable:
   line 1: 0


public static void changeStr(java.lang.String);
  Code:
   Stack=1, Locals=1, Args_size=1
   0:   ldc     #2; //String welcome 将string welcome常量从常量池取出，推入栈顶
   2:   astore_0 //将栈顶引用类型数值存到第一个本地变量（局部变量表）
   3:   return
  LineNumberTable:
   line 3: 0
   line 4: 3


public static void main(java.lang.String[]);
  Code:
   Stack=2, Locals=2, Args_size=1
   0:   ldc     #3; //String 1234 将string 1234常量从常量池取出，推入栈顶
   2:   astore_1     //将栈顶引用类型数值存到第二个本地变量（局部变量表）
   3:   ldc     #2; //String welcome 将string welcome常量从常量池取出，推入栈顶
   5:   astore_1    //将栈顶引用类型数值存到第二个本地变量（局部变量表）
   6:   getstatic       #4; //Field java/lang/System.out:Ljava/io/PrintStream;
   9:   aload_1     //将第二个引用类型本地变量推送至栈顶
   10:  invokevirtual   #5; //Method java/io/PrintStream.println:(Ljava/lang/Str
ing;)V
   13:  return
  LineNumberTable:
   line 6: 0
   line 7: 3
   line 9: 6
   line 10: 13


}

 * 
**/

 

package com.zhang;
public class Test4{
   public static void changeStr(T str){
        str.name = "sf";
    }

    public static void main(String[] args) {
       T t = new T();
    	changeStr(t);
        System.out.println(t.name);
    }
}
class T{
	String name = "name--min";
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return name;
	}
}
/*
 *Compiled from "Test4.java"
public class Test4 extends java.lang.Object
  SourceFile: "Test4.java"
  minor version: 0
  major version: 50
  Constant pool:
const #1 = Method       #10.#21;        //  java/lang/Object."<init>":()V
const #2 = String       #22;    //  sf
const #3 = Field        #4.#23; //  T.name:Ljava/lang/String;
const #4 = class        #24;    //  T
const #5 = Method       #4.#21; //  T."<init>":()V
const #6 = Method       #9.#25; //  Test4.changeStr:(LT;)V
const #7 = Field        #26.#27;        //  java/lang/System.out:Ljava/io/Print
tream;
const #8 = Method       #28.#29;        //  java/io/PrintStream.println:(Ljava/
ang/String;)V
const #9 = class        #30;    //  Test4
const #10 = class       #31;    //  java/lang/Object
const #11 = Asciz       <init>;
const #12 = Asciz       ()V;
const #13 = Asciz       Code;
const #14 = Asciz       LineNumberTable;
const #15 = Asciz       changeStr;
const #16 = Asciz       (LT;)V;
const #17 = Asciz       main;
const #18 = Asciz       ([Ljava/lang/String;)V;
const #19 = Asciz       SourceFile;
const #20 = Asciz       Test4.java;
const #21 = NameAndType #11:#12;//  "<init>":()V
const #22 = Asciz       sf;
const #23 = NameAndType #32:#33;//  name:Ljava/lang/String;
const #24 = Asciz       T;
const #25 = NameAndType #15:#16;//  changeStr:(LT;)V
const #26 = class       #34;    //  java/lang/System
const #27 = NameAndType #35:#36;//  out:Ljava/io/PrintStream;
const #28 = class       #37;    //  java/io/PrintStream
const #29 = NameAndType #38:#39;//  println:(Ljava/lang/String;)V
const #30 = Asciz       Test4;
const #31 = Asciz       java/lang/Object;
const #32 = Asciz       name;
const #33 = Asciz       Ljava/lang/String;;
const #34 = Asciz       java/lang/System;
const #35 = Asciz       out;
const #36 = Asciz       Ljava/io/PrintStream;;
const #37 = Asciz       java/io/PrintStream;
const #38 = Asciz       println;
const #39 = Asciz       (Ljava/lang/String;)V;

{
public Test4();
  Code:
   Stack=1, Locals=1, Args_size=1
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return
  LineNumberTable:
   line 1: 0


public static void changeStr(T);
  Code:
   Stack=2, Locals=1, Args_size=1
   0:   aload_0  ////将栈顶引用类型数值存到第一个本地变量（局部变量表）
   1:   ldc     #2; //String sf 将string sf常量从常量池取出，推入栈顶
   3:   putfield        #3; //Field T.name:Ljava/lang/String;//为t对象的name字段赋值
   6:   return
  LineNumberTable:
   line 3: 0
   line 4: 6


public static void main(java.lang.String[]);
  Code:
   Stack=2, Locals=2, Args_size=1
   0:   new     #4; //class T  创建一个新对象，并压入栈顶
   3:   dup      //复制栈顶数值，并将复制值压入栈顶
   4:   invokespecial   #5; //Method T."<init>":()V 调入无参够造方法
   7:   astore_1  //将栈顶引用类型数值存到第二个本地变量（局部变量表）
   8:   aload_1   //将第二个引用类型本地变量推送至栈顶
   9:   invokestatic    #6; //Method changeStr:(LT;)V
   12:  getstatic       #7; //Field java/lang/System.out:Ljava/io/PrintStream;
   15:  aload_1     //将第二个引用类型本地变量推送至栈顶
   16:  getfield        #3; //Field T.name:Ljava/lang/String; //获取对象的相应字段name。并压入栈顶
   19:  invokevirtual   #8; //Method java/io/PrintStream.println:(Ljava/lang/St
ing;)V
   22:  return
  LineNumberTable:
   line 7: 0
   line 8: 8
   line 9: 12
   line 10: 22


}

 * */

 

分享到：
| js 小技巧总结
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java 调用 powershell 并传参 返回

    java 调用 powershell 并传参 返回

    js直接调用exe传参

    实现JS直接调用exe并传参主要依赖于以下几种技术和方法： 1. **使用`Process.Start`方法**：这是一种较为直接的方法，可以在.NET框架中使用。但在纯前端环境中不可行。 2. **利用`ActiveXObject`对象**：这种方法...

    service_java接口远程调用_get、post、带参数远程调用_

    本篇文章将详细讲解如何使用Java实现GET和POST方法的远程接口调用，以及如何处理带有参数的情况。 首先，我们要了解HTTP协议中的GET和POST请求。GET请求通常用于获取资源，其参数包含在URL中；而POST请求常用于提交...

    C++调用Python并传参

    C#调用C++,C++调用Python并传参，包括C++向python传递图片数据，C++向python传递组数据，C++向python传递字符串数据，C++向python传递结构体数据，C++初始化python类数据并调用方法，实际案例，能直接运行，需要安装...

    Java传参方式-值传递还是引用传递

    1. 对象是通过引用访问的，但在方法调用中，对象引用是按值传递的。 2. Java 仅支持按值传递参数，无论是基本类型还是引用类型。 3. 按值传递意味着方法内部的任何修改都不会影响到原始参数的值，除非是修改引用所...

    webservice调用，传参代码样例

    在这个例子中，`setOperationName`指定了要调用的服务操作，`addParameter`方法添加了两个输入参数，最后通过`invoke`方法调用了服务，并将参数值作为对象数组传入。 **注意事项** 1. 确保Web服务的URL正确，否则...

    java调用shell向DataX传参，带where条件，特殊字符

    Java调用Shell脚本执行DataX任务是一种常见的数据迁移或同步操作。DataX是阿里巴巴开源的数据同步工具，它支持多种数据库之间的数据迁移。在实际应用中，我们可能需要根据特定的业务逻辑，如where条件，来定制数据...

    c#调用c++ dll 传参 string 崩溃的一种解决办法

    ### c#调用c++ dll 传参 string 崩溃的一种解决办法 在跨语言编程环境中，我们经常需要在不同编程语言之间进行交互。一个常见的场景是C#调用C++编写的动态链接库（DLL）。然而，在这种情况下可能会遇到一些问题，...

    Android原生java语句 和html js互相调用 传递参数

    这样，当Android调用`callJsFunction`时，JavaScript会传递一个消息给Java，Java处理后返回结果，再将结果显示回页面。 总结来说，Android与HTML JavaScript的互调主要依赖`WebView`的`addJavascriptInterface`和`...

    NDKC调用Java函数传参或获取变量

    NDK开发时，C/C++调用Java的函数的一些案例； 传递int类型参数： https://blog.csdn.net/niuba123456/article/details/80978500 传递String类型参数： https://blog.csdn.net/niuba123456/article/details/80978916 ...

    java调用json参数的webservice

    3. 在Java客户端，调用WebService方法并将JSON格式的字符串作为参数传递给服务端。这个字符串将被序列化为SOAP消息，然后通过网络发送给WebService端点。在客户端代码中，一般需要有一个客户端代理类，这个代理类...

    Java 字节码概述

    Java 编译器不将对变量和方法的引用编译为数值引用，也不确定程序执行过程中的内存布局，而是将这些符号引用信息保留在字节码中，由解释器在运行过程中创立内存布局，然后再通过查表来确定一个方法所在的地址。...

    详解java的值传递、地址传递、引用传递

    这是因为java中的对象参数传递也是值传递的，在调用`SChange`方法时，我们将`name`变量的引用传递给`str`参数，而不是传递`name`变量的地址或值。因此，在`SChange`方法中修改`str`参数的值，会影响到`name`变量的值...

    java方法的参数传递其二.docx

    Java 方法参数传递之引用类型 Java 方法参数传递是 Java 编程语言中的一种基本机制，在方法调用时将参数传递给方法体内的变量，但是在传递过程中，参数的类型会对传递结果产生影响。在本文中，我们将讨论 Java 方法...

    java用JNA调用dll实例，包含各种参数调用

    你需要继承Struct类，定义成员变量并使用`Structure.ByValue`或`Structure.ByReference`来选择是值传递还是引用传递。 4. **结构体的指针和引用**：如果DLL函数需要结构体的指针，你可以创建一个指向Struct实例的...

    面向对象语言中的值传递与引用传递

    由于是引用传递，`b`和`a_book`都是指向同一个对象的引用，因此在方法调用之后，`b`对象的值发生了变化。 总结来说，值传递和引用传递是Java中处理参数传递的两种机制。理解这两者的差异对于正确处理方法调用和对象...

    java通过实例了解值传递和引用传递

    此外，Java语言中当对象引用是传递给方法的一个参数时，您传递的是该引用的一个副本（可以认为特殊的值传递），而不是引用本身。例如，public static void main(String[] args) { Person p=new Person(); p.setAge...

    调用webservice，通过post传参读取返回的XML

    在这个场景中，POST方法用于传递调用WebService所需的参数。 3. **XML**：XML是一种自描述性的文本标记语言，用于存储和传输数据。在与WebService交互时，XML常被用来封装请求参数和返回的数据。 4. **调用...

    Java语言如何调用C++语言编写的本地方法

    在Java程序中调用用C++语言编写的本地方法，是通过Java本地接口（JNI）实现的，JNI是Java提供的一套标准编程接口，用于Java代码和本地应用程序或库之间的交互。本地库通常是用C或C++编写的动态链接库（在Windows上是...

Magicbox
Global site tag (gtag.js) - Google Analytics