2. 程式人生 > >java 之方法呼叫 方法傳參 值傳遞還是引用傳遞位元組碼

java 之方法呼叫 方法傳參 值傳遞還是引用傳遞位元組碼

阿新 • • 發佈：2019-02-08 
/*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


}

 * */
  • 下載次數: 1

相關推薦

java 之方法呼叫 方法傳參 值傳遞還是引用傳遞位元組碼

/*Java中的引數傳遞方式到底是引用傳遞還是值傳遞？java核心技術卷I裡有一個結 論我覺得挺有意思的：java中沒有引用傳遞，只有值傳遞 首先看定義： 值傳遞，是指方法接收的是呼叫者提供的值 引用傳遞，是指方法接收的是呼叫者提供的變數地址 事實上，Java中方法引

物件引用 方法傳參 值傳遞 引用傳遞 易錯點

Markdown版本筆記 我的GitHub首頁 我的部落格 我的微信 我的郵箱 MyAndroidBlogs baiqiantao bai

java方法中的傳參機制以及利用反射交換兩個引數

Java方法的值傳遞機制可以訪問這篇部落格：https://www.cnblogs.com/lixiaolun/p/4311863.html， 今天我要寫的是如何利用反射來交換兩個變數的值。 private static void swap(Integer x, Integer y) {

SpringMVC原始碼學習之request處理流程 springMVC原始碼學習地址 springMVC原始碼學習之addFlashAttribute原始碼分析 java reflect反射呼叫方法invoke

目的：為看原始碼提供呼叫地圖，最長呼叫邏輯深度為8層，反正我是springMVC原始碼學習地址看了兩週才理出來的。 1.處理流程（版本為4.3.18） 入口為spring-webmvc-4.3.18.RELEASE.jar中org.springframework.web.servlet.Dispatche

java 方法呼叫，形參改變，實參是否發生改變

今天遇見一個面試題，java基礎的東西。我竟然給忘了。。。寫下來加深一下印象面試題：public class Test2 { public static void main(String[] args) { String a = new String(

父視窗和iframe子視窗之間相互傳遞引數和呼叫函式或方法(url中傳參)

1.父視窗向子視窗傳遞引數： 可以在url中新增引數：2.html?a=1&b=2&c=3 然後在子頁面上可用js解析,提供一個函式： function getQueryStr(sArgName)

Java之map使用方法

str basic 添加元素 修改 添加 col pack mov 遍歷 1 package basic; 2 3 import java.util.HashMap; 4 import java.util.Map; 5 6 //map使用方法 7 p

以Integer型別傳參值不變來理解Java值傳參

最近在寫程式碼的時候出了一個錯誤，由於對值引用理解的不深,將Integer傳入方法中修改，以為傳入後直接修改Integer中的值就不用寫返回值接收了，雖然很快發現了問題，但還是來總結一下 首先是程式碼： public static void main(String[] args){

Java之路：方法過載與重寫的區別

一、方法的過載（overload） 方法名相同但引數列表不同的方法簽名機制，稱之為方法的過載(method overload)。 過載的表現形式就是呼叫一系列具有相同名稱的方法，這些方法可根據傳入引數的不同而得到不同的處理結果，這其實就是多型性的一種體現，這屬於靜態多型，即同一種介面

Java之路：方法

一、方法的基本定義 方法（method）用來實現類的行為。 一個方法通常是用來完成一項具體的功能（function），所以方法在C++中也稱為成員函式（member function）。 在Java中，方法定義在類中，它和類的成員屬性（資料成員）一起構建一個完整的類。 方法是對邏

原生Ajax使用筆記---get和post方法，url傳參

AJAX是Asynchronous Javascript And XML（非同步JavaScript和XML）的縮寫，用於建立快速動態網頁的技術。AJAX的核心物件是XMLHttpRequest ，在每個瀏覽器中都有。 原生Ajax的使用步驟： 建立一個核心物件XMLHttpReque

java中 方法引數是值傳遞還是引用傳遞 ？

物件是引用傳遞，原始型別資料是值傳遞 實際上把方法引數中物件引數看做是物件的引用，那麼物件引用也是值傳遞 它符合值傳遞的一切的特徵，即我們可以通過物件引用的引數去改變它所指向物件的屬性，但我們卻無法改變這個物件引用引數所指向的物件。

JAVA 方法的引數是按值傳遞還是引用傳遞？

在思考這個問題之前首先要明白JAVA一個類中的資料成員有多少種：                    JAVA一個類中資料成員只有兩種，分別是：基本資料型別和物件。基本資料型別就不用多說了，只有8種；其他的都是物件，JAVA class位元組碼檔案在記憶體中是一個靜態物件、

【Java程式設計】呼叫方法判斷一個數是否是素數

上次寫了素數的判斷，這次又寫了素數的判斷，但是這次做了一些改進，把判斷的程式寫到方法裡面，要使用的時候直接呼叫即可。 本次實現了 程式碼如下： public static boolean judgme

Java方法引數的傳遞機制，值傳遞？引用傳遞？

在呼叫某個方法時你是不是經常有如下2個疑惑， 1、明明傳進去的引數在方法裡做了值的改變，但方法呼叫完後傳進去的引數在後面的程式碼中值卻沒有發生變化，疑惑中。（期望變化卻沒有發生變化） 2、一個物件在作為引數被方法呼叫之後，突然發現在後面的程式碼中值發生了變化，疑惑中。（不期

討論java中呼叫函式，形參的傳遞是值傳遞還是引用傳遞的問題

首先說結論： 當引數是引用資料型別時，傳入形參的是實參的引用；（證一） 當引數是基本資料型別時，傳入形參的是實參值；（證二） 證明如下： （證一） public class PassByReferenceOrValueTest { public static void main(String

java方法引數傳遞方式--按值傳遞、引用傳遞

java的方法引數傳遞方式有兩種，按值傳遞和引用傳遞 1.按值傳遞 引數型別是int，long等基本資料型別（八大基本資料型別），引數傳遞的過程採用值拷貝的方式 程式碼片段1： public class Test { public static void m

Excel催化劑開源第8波-VSTO開發之非同步呼叫方法

在VSTO開發過程中，因其和普通的Winform開發有點差別，具體細節筆者也說不清楚，大概是VSTO的外掛是寄生在Excel中，不屬於獨立的程序之類的，其非同步方法呼叫時，未能如Winform那樣直接用await async非同步方法就結束，仍需要再作簡單的處理。 使用場景 在Excel上直接使用非同步方

Java sort函式呼叫方法

其實與c++Stl庫中的sort函式沒有太大區別。 主要還是這個：Arrays.sort(陣列名,起始下標,終止下標); 這樣會對一組資料進行升序排列； eg： import java.util.*; public class Main { public st

Java語言中的方法引數——值傳遞與引用傳遞

Java語言中的方法引數有兩種： 1、基本資料型別（數字、布林值） 2、物件引用 基於方法引數的傳遞有兩種方式：值傳遞和引用傳遞。 值傳遞表示方法接收的是呼叫者提供的值。 引用傳遞表示方法接收的是呼叫者提供的變數地址。 Java程式設計語言總是採用按值傳遞的方式，也就是說