`
m635674608
  • 浏览: 5028464 次
  • 性别: 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：按值传递还是按引用传递详细解说

    ### Java中的按值传递与按引用传递详解 #### 一、引言 在Java编程语言中，关于参数传递的方式一直存在两种观点：一种认为Java仅支持按值传递，另一种则指出Java同时支持按值传递和按引用传递。实际上，这两种观点...

    java http 接口调用 的get和post传参方法

    java实现调用httpclient接口的类和方法，包括了get和post传参方式，简单易懂

    js直接调用exe传参

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

    java调用shell（包含有参数的调用）

    本文将详细解释Java如何调用Shell脚本，包括如何编写Shell脚本和在Java中如何传递参数。 首先，Shell脚本可以被看作是一系列Linux命令的集合，用于自动化执行多个命令。类似于Windows环境中的批处理文件，Shell脚本...

    java值传递与引用传递

    在Java编程语言中，函数参数的传递方式有两种：值传递和引用传递。理解这两种机制对于编写高效、无误的代码至关重要。以下是对这两种传递方式的详细解析。 首先，值传递是指函数调用时，实际参数的值被复制一份传给...

    基于字节码搜索的Java反序列化漏洞调用链挖掘方法.pdf

    本文主要介绍了一种基于字节码搜索的Java反序列化漏洞调用链挖掘方法。文章的核心在于结合了污点分析与符号执行技术来生成从反序列化漏洞入口点到危险函数的调用树。这一方法能够自动化地进行调用链的构建，大幅提升...

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

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

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

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

    C++调用Python并传参

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

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

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

    android中js与java间函数相互调用demo，支持中文传参，无乱码

    要让JavaScript能够调用Java方法，我们需要使用`@JavascriptInterface`注解来暴露Java方法。这个注解确保了只有在`WebView`内的JavaScript代码才能访问这些方法。例如： ```java public class JsBridge { @...

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

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

    值传递和引用传递

    **引用传递**则是指在函数或方法调用时，传递的是实际参数的引用而不是值本身。这意味着形参和实参指向的是同一块内存区域。因此，形参的任何改变都会直接影响到实参。 ##### 3.1 引用传递的特点 - **共享性**：...

    Java语言后台实现调用url路径并传参

    在Java编程中，后台调用URL路径并传递参数是一项常见的任务，这通常涉及到网络请求的实现。Java提供了多种库来处理这种需求，如HttpURLConnection、Apache HttpClient等。在这个场景下，我们将重点讨论使用Apache ...

    android webview中使用Java调用JavaScript方法并获取返回值

    当JavaScript执行完毕并准备好将结果返回给Java时，它会通过window.stub.jsMethod(result)来调用Java中相应的方法，并传递一个参数result。 在JavaScript代码中，可以使用window.stub.jsMethod()来调用Java的方法。...

    java调用shell向DataX传递参数，where条件，包含特殊字符

    本问题聚焦于如何通过Java调用shell脚本，向DataX传递参数，特别是包含特殊字符的where条件。在实际操作中，这可能会涉及到字符串转义、参数安全传递以及shell命令的构建等多个技术点。 首先，我们需要理解DataX的...

    Java是值传递，传对象引用也是通过值

    无论是基本类型还是对象类型，参数传递都是以值的形式进行，但对象类型的值是其引用，允许我们在方法内修改对象的状态，而不影响方法外部的引用。这种特性使得Java能够实现封装和数据安全性，同时也为程序员提供了...

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