Is Java pass-by-reference or pass-by-value

Question

I always thought Java uses pass-by-reference  However  I ve seen a couple of blog posts  for example  this blog  that claim that it isn t  the blog post says that Java uses pass-by-value   I don t think I understand the distinction they re making  What is the explanation

User · Answer

Unlike some other languages  Java does not allow you to choose between pass-by-value and pass-by-reference   All arguments are passed by value    A method call can pass two types of valuesto a method   copies of primitive values  e g   values of type int and double  copies of references to objects    Objects themselves cannot be passed to methods  When a method modifies a primitive-type parameter  changes to the parameter have no effect on the original argument value in the calling method   This is also true for reference-type parameters  If you modify a reference-type parameter so that it refers to another object  only the parameter refers to the new object   the reference stored in the caller   s variable still refers to the original object   References  Java    How To Program  Early Objects   Tenth Edition

User · Answer

This will give you some insights of how Java really works to the point that in your next discussion about Java passing by reference or passing by value you ll just smile  -   Step one please erase from your mind that word that starts with  p                   especially if you come from other programming languages  Java and  p  cannot be written in the same book  forum  or even txt   Step two remember that when you pass an Object into a method you re passing the Object reference and not the Object itself    Student  Master  does this mean that Java is pass-by-reference  Master  Grasshopper  No    Now think of what an Object s reference variable does is    A variable holds the bits that tell the JVM how to get to the referenced Object in memory  Heap   When passing arguments to a method you ARE NOT passing the reference variable  but a copy of the bits in the reference variable  Something like this  3bad086a  3bad086a represents a way to get to the passed object  So you re just passing 3bad086a that it s the value of the reference  You re passing the value of the reference and not the reference itself  and not the object   This value is actually COPIED and given to the method     In the following  please don t try to compile execute this       1  Person person  2  person   new Person  Tom    3  changeName person   4  5    I didn t use Person person below as an argument to be nice 6  static void changeName Person anotherReferenceToTheSamePersonObject    7      anotherReferenceToTheSamePersonObject setName  Jerry    8      What happens    The variable person is created in line  1 and it s null at the beginning  A new Person Object is created in line  2  stored in memory  and the variable person is given the reference to the Person object  That is  its address  Let s say 3bad086a  The variable person holding the address of the Object is passed to the function in line  3  In line  4 you can listen to the sound of silence  Check the comment on line  5 A method local variable -anotherReferenceToTheSamePersonObject- is created and then comes the magic in line  6    The variable reference person is copied bit-by-bit and passed to anotherReferenceToTheSamePersonObject inside the function  No new instances of Person are created  Both  person  and  anotherReferenceToTheSamePersonObject  hold the same value of 3bad086a  Don t try this but person  anotherReferenceToTheSamePersonObject would be true  Both variables have IDENTICAL COPIES of the reference and they both refer to the same Person Object  the SAME Object on the Heap and NOT A COPY     A picture is worth a thousand words     Note that the anotherReferenceToTheSamePersonObject arrows is directed towards the Object and not towards the variable person   If you didn t get it then just trust me and remember that it s better to say that Java is pass by value  Well  pass by reference value  Oh well  even better is pass-by-copy-of-the-variable-value      Now feel free to hate me but note that given this there is no difference between passing primitive data types and Objects when talking about method arguments   You always pass a copy of the bits of the value of the reference    If it s a primitive data type these bits will contain the value of the primitive data type itself  If it s an Object the bits will contain the value of the address that tells the JVM how to get to the Object       Java is pass-by-value because inside a method you can modify the referenced Object as much as you want but no matter how hard you try you ll never be able to modify the passed variable that will keep referencing  not p                the same Object no matter what         The changeName function above will never be able to modify the actual content  the bit values  of the passed reference  In other word changeName cannot make Person person refer to another Object      Of course you can cut it short and just say that  Java is pass-by-value

User · Answer

Java is always pass by value  not pass by reference First of all  we need to understand what pass by value and pass by reference are  Pass by value means that you are making a copy in memory of the actual parameter s value that is passed in  This is a copy of the contents of the actual parameter  Pass by reference  also called pass by address  means that a copy of the address of the actual parameter is stored  Sometimes Java can give the illusion of pass by reference  Let s see how it works by using the example below  public class PassByValue       public static void main String   args            Test t   new Test            t name    quot initialvalue quot           new PassByValue   changeValue t           System out println t name                  public void changeValue Test f            f name    quot changevalue quot            class Test       String name     The output of this program is  changevalue Let s understand step by step  Test t   new Test    As we all know it will create an object in the heap and return the reference value back to t  For example  suppose the value of t is 0x100234  we don t know the actual JVM internal value  this is just an example    first illustration new PassByValue   changeValue t    When passing reference t to the function it will not directly pass the actual reference value of object test  but it will create a copy of t and then pass it to the function  Since it is passing by value  it passes a copy of the variable rather than the actual reference of it  Since we said the value of t was 0x100234  both t and f will have the same value and hence they will point to the same object  second illustration If you change anything in the function using reference f it will modify the existing contents of the object  That is why we got the output changevalue  which is updated in the function  To understand this more clearly  consider the following example  public class PassByValue       public static void main String   args            Test t   new Test            t name    quot initialvalue quot           new PassByValue   changeRefence t           System out println t name                  public void changeRefence Test f            f   null           class Test       String name     Will this throw a NullPointerException  No  because it only passes a copy of the reference  In the case of passing by reference  it could have thrown a NullPointerException  as seen below  third illustration Hopefully this will help

User · Answer

Java always uses call by value  That means the method gets copy of all parameter values   Consider next 3 situations   1  Trying to change primitive variable  public static void increment int x    x       int a   3  increment a     x will copy value of a and will increment x  a remains the same  2  Trying to change primitive field of an object  public static void increment Person p    p age       Person pers   new Person 20      age   20 increment pers     p will copy reference value of pers and will increment age field  variables are referencing to the same object so age is changed  3  Trying to change reference value of reference variables  public static void swap Person p1  Person p2        Person temp   p1      p1   p2      p2   temp     Person pers1   new Person 10   Person pers2   new Person 20   swap pers1  pers2     after calling swap p1  p2 copy reference values from pers1 and pers2  are swapping with values  so pers1 and pers2 remain the same  So  you can change only fields of objects in method passing copy of reference value to this object

User · Answer

First let s understand Memory allocation in Java  Stack and Heap are part of Memory that JVM allocates for different purposes  The stack memory is pre-allocated to thread  when it is created  therefore  a thread cannot access the Stack of other thread  But Heap is available to all threads in a program   For a thread  Stack stores all local data  metadata of program  primitive type data and object reference  And  Heap is responsible for storage of actual object   Book book   new Book  Effective Java      In the above example  the reference variable is  book  which is stored in stack  The instance created by new operator -  new Book  Effective Java   is stored in Heap  The ref variable  book  has address of the object allocated in Heap  Let s say the address is 1001     Consider passing a primitive data type i e  int  float  double etc   public class PrimitiveTypeExample        public static void main string   args           int num   10         System out println  Value before calling method      num          printNum num          System out println  Value after calling method      num             public static void printNum int num          num   num   10         System out println  Value inside printNum method      num             Output is  Value before calling method  10 Value inside printNum method  20 Value after calling method  10  int num  10  -  this allocates the memory for  int  in Stack of the running thread  because  it is a primitive type   Now when printNum     is called  a private stack is created within the same thread  When  num  is passed to this method  a copy of  num  is created in the method stack frame  num   num 10  -  this adds 10 and modifies the the int variable within the method stack frame  Therefore  the original num outside the method stack frame remains unchanged   Consider  the example of passing the object of a custom class as an argument     In the above example  ref variable  book  resides in stack of thread executing the program  and the object of class Book is created in Heap space when program executes new Book    This memory location in Heap is referred by  book   When  book  is passed as method argument  a copy  of  book  is created in  private stack frame of method within the same stack of thread  Therefore  the copied reference variable points to the same object of class  Book  in the Heap     The reference variable within method stack frame sets a new value to same object  Therefore  it is reflected when original ref variable  book  gets its value  Note that in case of passing reference variable  if it is initialized again in called method  it then points to new memory location and any operation does not affect the previous object in the Heap   Therefore  when anything is passed as method argument  it is always the Stack entity - either primitive or reference variable  We never pass something that is stored in Heap  Hence  in Java  we always pass the value in the stack  and it is pass by value

User · Answer

To make a long story short  Java objects have some very peculiar properties   In general  Java has primitive types  int  bool  char  double  etc  that are passed directly by value  Then Java has objects  everything that derives from java lang Object   Objects are actually always handled through a reference  a reference being a pointer that you can t touch   That means that in effect  objects are passed by reference  as the references are normally not interesting  It does however mean that you cannot change which object is pointed to as the reference itself is passed by value   Does this sound strange and confusing  Let s consider how C implements pass by reference and pass by value  In C  the default convention is pass by value  void foo int x  passes an int by value  void foo int  x  is a function that does not want an int a  but a pointer to an int  foo  amp a   One would use this with the  amp  operator to pass a variable address   Take this to C    and we have references  References are basically  in this context  syntactic sugar that hide the pointer part of the equation  void foo int  amp x  is called by foo a   where the compiler itself knows that it is a reference and the address of the non-reference a should be passed  In Java  all variables referring to objects are actually of reference type  in effect forcing call by reference for most intends and purposes without the fine grained control  and complexity  afforded by  for example  C

User · Answer

A few corrections to some posts   C does NOT support pass by reference  It is ALWAYS pass by value  C   does support pass by reference  but is not the default and is quite dangerous   It doesn t matter what the value is in Java  primitive or address roughly  of object  it is ALWAYS passed by value   If a Java object  behaves  like it is being passed by reference  that is a property of mutability and has absolutely nothing to do with passing mechanisms   I am not sure why this is so confusing  perhaps because so many Java  programmers  are not formally trained  and thus do not understand what is really going on in memory

User · Answer

I see that all answers contain the same  pass by value  However  a recent Brian Goetz update on project Valhalla actually answers it differently   Indeed  it is a common    gotcha    question about whether Java objects are passed by value or by reference  and the answer is    neither     object references are passed by value   You can read more here  State of Valhalla  Section 2  Language Model Edit  Brian Goetz is Java Language Architect  leading such projects as Project Valhalla and Project Amber  Edit-2020-12-08  Updated State of Valhalla

User · Answer

Java is strictly passed by value  When I say pass by value it means whenever caller has invoked the callee the arguments ie  the data to be passed to the other function  is copied and placed in the formal parameters  callee s local variables for receiving the input   Java makes data communications from one function to other function only in a pass by value environment   An important point would be to know that even C language is strictly passed by value only  ie  Data is copied from caller to the callee and more ever the operation performed by the callee are on the same memory location and  what we pass them is the address of that location that we obtain from   amp   operator and the identifier used in the formal parameters are declared to be a pointer variable     using which we can get inside the memory location for accessing the data in it   Hence here the formal parameter is nothing but mere aliases for that location  And any modifications done on that location is visible where ever that scope of the variable  that identifies that location  is alive   In Java  there is no concept of pointers  ie  there is nothing called a pointer variable   although we can think of reference variable as a pointer technically in java we call it as a handle  The reason why we call the pointer to an address as a handle in java is  because a pointer variable is capable of performing not just single dereferencing but multiple dereferencing  for example  int  p  in P means p points to an integer and int   p  in C means p is pointer to a pointer to an integer we dont have this facility in Java  so its absolutely correct and technically legitimate to say it as an handle  also there are rules for pointer arithmetic in C  Which allows performing arithmetic operation on pointers with constraints on it    In C we call such mechanism of passing address and receiving them with pointer variables as pass by reference since we are passing their addresses and receiving them as pointer variable in formal parameter but at the compiler level that address is copied into pointer variable  since data here is address even then its data   hence we can be 100  sure that C is Strictly passed by value  as we are passing data only    and if we pass the data directly in C we call that as pass by value    In java when we do the same we do it with the handles  since they are not called pointer variables like in  as discussed above  even though we are passing the references we cannot say its pass by reference since we are not collecting that with a pointer variable in Java   Hence Java strictly use pass by value mechanism

User · Answer

Have a look at this code  This code will not throw NullPointerException    It will print  Vinay   public class Main       public static void main String   args            String temp    Vinay           print temp           System err println temp              private static void print String temp            temp   null            If Java is pass by reference then it should have thrown NullPointerException as reference is set to Null

User · Answer

Java is always pass by value  not pass by reference First of all  we need to understand what pass by value and pass by reference are  Pass by value means that you are making a copy in memory of the actual parameter s value that is passed in  This is a copy of the contents of the actual parameter  Pass by reference  also called pass by address  means that a copy of the address of the actual parameter is stored  Sometimes Java can give the illusion of pass by reference  Let s see how it works by using the example below  public class PassByValue       public static void main String   args            Test t   new Test            t name    quot initialvalue quot           new PassByValue   changeValue t           System out println t name                  public void changeValue Test f            f name    quot changevalue quot            class Test       String name     The output of this program is   changevalue   Let s understand step by step  Test t   new Test     As we all know it will create an object in the heap and return the reference value back to t  For example  suppose the value of t is 0x100234  we don t know the actual JVM internal value  this is just an example     new PassByValue   changeValue t    When passing reference t to the function it will not directly pass the actual reference value of object test   but it will create a copy of t and then pass it to the function  Since it is passing by value  it passes a copy of the variable rather than the actual reference of it  Since we said the value of t was 0x100234  both t and f will have the same value and hence they will point to the same object   If you change anything in the function using reference f it will modify the existing contents of the object  That is why we got the output changevalue    which is updated in the function  To understand this more clearly  consider the following example  public class PassByValue       public static void main String   args            Test t   new Test            t name    quot initialvalue quot           new PassByValue   changeRefence t           System out println t name                  public void changeRefence Test f            f   null           class Test       String name     Will this throw a NullPointerException  No  because it only passes a copy of the reference  In the case of passing by reference  it could have thrown a NullPointerException  as seen below   Hopefully this will help

User · Answer

This is the best way to answer the question imo     First  we must understand that  in Java  the parameter passing behavior     public void foo Object param         some code in foo       public void bar       Object obj   new Object       foo obj       is exactly the same as     public void bar       Object obj   new Object       Object param   obj        some code in foo        not considering stack locations  which aren t relevant in this discussion   So  in fact  what we re looking for in Java is how variable assignment works  I found it in the docs       One of the most common operators that you ll encounter is the simple assignment operator           it assigns the value on its right to the operand on its left       int cadence   0     int speed   0     int gear   1         This operator can also be used on objects to assign object references         It s clear how this operator acts in two distinct ways  assign values and assign references  The last  when it s an object    the first  when it isn t an object  that is  when it s a primitive  But so  can we understand that Java s function params can be pass-by-value and pass-by-reference    The truth is in the code  Let s try it   public class AssignmentEvaluation     static public class MyInteger         public int value   0         static public void main String   args          System out println  Assignment operator evaluation using two MyInteger objects named height and width n         MyInteger height   new MyInteger        MyInteger width    new MyInteger         System out println   1  Assign distinct integers to height and width values         height value   9      width value    1       System out println  - gt   height is     height value     and width is     width value      we are different things   n         System out println   2  Assign to height s value the width s value         height value   width value       System out println  - gt   height is     height value     and width is     width value      are we the same thing now   n         System out println   3  Assign to height s value an integer other than width s value         height value   9       System out println  - gt   height is     height value     and width is     width value      we are different things yet   n         System out println   4  Assign to height the width object         height   width       System out println  - gt   height is     height value     and width is     width value      are we the same thing now   n         System out println   5  Assign to height s value an integer other than width s value         height value   9       System out println  - gt   height is     height value     and width is     width value      we are the same thing now   n         System out println   6  Assign to height a new MyInteger and an integer other than width s value         height   new MyInteger        height value   1       System out println  - gt   height is     height value     and width is     width value      we are different things again   n            This is the output of my run    Assignment operator evaluation using two MyInteger objects named height and width   1  Assign distinct integers to height and width values -   height is 9 and width is 1  we are different things     2  Assign to height s value the width s value -   height is 1 and width is 1  are we the same thing now     3  Assign to height s value an integer other than width s value -   height is 9 and width is 1  we are different things yet     4  Assign to height the width object -   height is 1 and width is 1  are we the same thing now     5  Assign to height s value an integer other than width s value -   height is 9 and width is 9  we are the same thing now     6  Assign to height a new MyInteger and an integer other than width s value -   height is 1 and width is 9  we are different things again     In  2  we have distinct objects and assign one variable s value to the other  But after assigning a new value in  3  the objects had different values  which means that in  2  the assigned value was a copy of the primitive variable  usually called pass-by-value  otherwise  the values printed in  3  should be the same   In  4  we still have distinct objects and assign one object to the other  And after assigning a new value in  5  the objects had the same values  which means that in  4  the assigned object was not a copy of the other  which should be called pass-by-reference  But  if we look carefully in  6   we can t be so sure that no copy was done           We can t be so sure because in  6  the objects were the same  then we assigned a new object to one of them  and after  the objects had different values  How can they be distinct now if they were the same  They should be the same here too          We ll need to remember the docs to understand what s going on      This operator can also be used on objects to assign object references   So our two variables were storing references    our variables had the same reference after  4  and different references after  6     if such a thing is possible  this means that assignment of objects is done by copy of the object s reference  otherwise  if it was not a copy of reference  the printed value of the variables in  6  should be the same  So objects  references   just like primitives  are copied to variables through assignment  what people usually call pass-by-value  That s the only pass-by- in Java

User · Answer

The major cornerstone knowledge must be the quoted one      When an object reference is passed to a method  the reference itself   is passed by use of call-by-value  However  since the value being   passed refers to an object  the copy of that value will still refer to   the same object referred to by its corresponding argument    Java  A Beginner s Guide  Sixth Edition  Herbert Schildt

User · Answer

I think this simple explanation might help you understand as I wanted to understand this same thing when I was struggling through this   When you pass a primitive data to a function call it s content is being copied to the function s argument and when you pass an object it s reference is being copied to the function s argument  Speaking of object  you can t change the copied reference-the argument variable is referencing to in the calling function   Consider this simple example  String is an object in java and when you change the content of a string the reference variable will now point to some new reference as String objects are immutable in java   String name  Mehrose       name referencing to 100  ChangeContenet String name    name  Michael      refernce has changed to 1001     System out print name      displays Mehrose   Fairly simple because as I mentioned you are not allowed to change the copied reference in the calling function  But the problem is with the array when you pass an array of String Object  Let us see   String names     Mehrose   Michael     changeContent String   names     names 0   Rose     names 1   Janet      System out println Arrays toString names      displays  Rose Janet    As we said that we can t change the copied reference in the function call and we also have seen in the case of a single String object  The reason is names   variable referencing to let s say 200 and names 0  referencing to 205 and so on  You see we didn t change the names   reference it still points to the old same reference still after the function call but now names 0  and names 1  reference has been changed  We Still stand on our definition that we can t change the reference variable s reference so we didn t   The same thing happens when you pass a Student object to a method and you are still able to change the Student name or other attributes  the point is we are not changing the actual Student object rather we are changing the contents of it  You can t do this  Student student1  new Student  Mehrose     changeContent Student Obj    obj  new Student  Michael     invalid  obj setName  Michael      valid

User · Answer

Java is always pass-by-value  Unfortunately  we never handle an object at all  instead juggling object-handles called references  which are passed by value of course    The chosen terminology and semantics easily confuse many beginners  It goes like this  public static void main String   args        Dog aDog   new Dog  quot Max quot        Dog oldDog   aDog          we pass the object to foo     foo aDog          aDog variable is still pointing to the  quot Max quot  dog when foo      returns     aDog getName   equals  quot Max quot       true     aDog getName   equals  quot Fifi quot       false     aDog    oldDog     true    public static void foo Dog d        d getName   equals  quot Max quot       true        change d inside of foo   to point to a new Dog instance  quot Fifi quot      d   new Dog  quot Fifi quot        d getName   equals  quot Fifi quot       true    In the example above aDog getName   will still return  quot Max quot   The value aDog within main is not changed in the function foo with the Dog  quot Fifi quot  as the object reference is passed by value  If it were passed by reference  then the aDog getName   in main would return  quot Fifi quot  after the call to foo  Likewise  public static void main String   args        Dog aDog   new Dog  quot Max quot        Dog oldDog   aDog       foo aDog          when foo      returns  the name of the dog has been changed to  quot Fifi quot      aDog getName   equals  quot Fifi quot       true        but it is still the same dog      aDog    oldDog     true    public static void foo Dog d        d getName   equals  quot Max quot       true        this changes the name of d to be  quot Fifi quot      d setName  quot Fifi quot       In the above example  Fifi is the dog s name after call to foo aDog  because the object s name was set inside of foo       Any operations that foo performs on d are such that  for all practical purposes  they are performed on aDog  but it is not possible to change the value of the variable aDog itself

User · Answer

In my opinion   pass by value  is a terrible way to singularly describe two similar but different events   I guess they should have asked me first   With primitives we are passing the actual value of the primitive into the method  or constructor   be it the integer  5   the character  c   or what have you   That actual value then becomes its own local primitive   But with objects  all we are doing is giving the same object an additional reference  a local reference   so that we now have two references pointing to the same object   I hope this simple explanation helps

User · Answer

I feel like arguing about  pass-by-reference vs pass-by-value  is not super-helpful   If you say   Java is pass-by-whatever  reference value    in either case  you re not provide a complete answer  Here s some additional information that will hopefully aid in understanding what s happening in memory   Crash course on stack heap before we get to the Java implementation  Values go on and off the stack in a nice orderly fashion  like a stack of plates at a cafeteria  Memory in the heap  also known as dynamic memory  is haphazard and disorganized  The JVM just finds space wherever it can  and frees it up as the variables that use it are no longer needed   Okay  First off  local primitives go on the stack  So this code   int x   3  float y   101 1f  boolean amIAwesome   true    results in this     When you declare and instantiate an object  The actual object goes on the heap  What goes on the stack  The address of the object on the heap  C   programmers would call this a pointer  but some Java developers are against the word  pointer   Whatever  Just know that the address of the object goes on the stack   Like so   int problems   99  String name    Jay-Z       An array is an object  so it goes on the heap as well  And what about the objects in the array  They get their own heap space  and the address of each object goes inside the array   JButton   marxBros   new JButton 3   marxBros 0    new JButton  Groucho    marxBros 1    new JButton  Zeppo    marxBros 2    new JButton  Harpo        So  what gets passed in when you call a method  If you pass in an object  what you re actually passing in is the address of the object  Some might say the  value  of the address  and some say it s just a reference to the object  This is the genesis of the holy war between  reference  and  value  proponents  What you call it isn t as important as that you understand that what s getting passed in is the address to the object   private static void shout String name       System out println  There goes     name            public static void main String   args       String hisName    John J  Jingleheimerschmitz       String myName   hisName      shout myName       One String gets created and space for it is allocated in the heap  and the address to the string is stored on the stack and given the identifier hisName  since the address of the second String is the same as the first  no new String is created and no new heap space is allocated  but a new identifier is created on the stack  Then we call shout    a new stack frame is created and a new identifier  name is created and assigned the address of the already-existing String     So  value  reference  You say  potato

User · Answer

Java passes everything by value      create an object by passing in a name and age   PersonClass variable1   new PersonClass  Mary   32    PersonClass variable2      Both variable2 and variable1 now reference the same object  variable2   variable1     PersonClass variable3   new PersonClass  Andre   45        variable1 now points to variable3  variable1   variable3      WHAT IS OUTPUT BY THIS   System out println variable2   System out println variable1    Mary 32 Andre 45   if you could understand this example we r done  otherwise  please visit this webPage for detailed explanation   webPage

User · Answer

So many long answers  Let me give a simple one    Java always passes everything by value that means also references are passed by value   In short  you can not modify value of any parameter passed  but you can call methods or change attributes of an object reference passed

User · Answer

Java is only passed by value  there is no pass by reference  for example  you can see the following example   package com asok cop example task  public class Example       int data   50       void change int data            data   data   100    changes will be in the local variable          System out println  after add     data                  public static void main String args              Example op   new Example            System out println  before change     op data           op change 500           System out println  after change     op data             Output   before change 50 after add 600 after change 50   as Michael says in the comments      objects are still passed by value even though operations on them behave like pass-by-reference  Consider void changePerson Person person   person   new Person      the callers reference to the person object will remain unchanged  Objects themselves are passed by value but their members can be affected by changes  To be true pass-by-reference  we would have to be able to reassign the argument to a new object and have the change be reflected in the caller

User · Answer

I can t believe that nobody mentioned Barbara Liskov yet  When she designed CLU in 1974  she ran into this same terminology problem  and she invented the term call by sharing  also known as call by object-sharing and call by object  for this specific case of  call by value where the value is a reference

User · Answer

A simple test to check whether a language supports pass-by-reference is simply writing a traditional swap  Can you write a traditional swap a b  method function in Java   A traditional swap method or function takes two arguments and swaps them such that variables passed into the function are changed outside the function  Its basic structure looks like   Non-Java  Basic swap function structure  swap Type arg1  Type arg2        Type temp   arg1      arg1   arg2      arg2   temp      If you can write such a method function in your language such that calling  Type var1        Type var2        swap var1 var2     actually switches the values of the variables var1 and var2  the language supports pass-by-reference  But Java does not allow such a thing as it supports passing the values only and not pointers or references

User · Answer

In java everything is reference  so when you have something like      Point pnt1   new Point 0 0   Java does following    Creates new Point object Creates new Point reference and initialize that reference to point  refer to  on previously created Point object  From here  through Point object life  you will access to that object through pnt1  reference  So we can say that in Java you manipulate object through its reference      Java doesn t pass method arguments by reference  it passes them by value  I will use example from this site    public static void tricky Point arg1  Point arg2      arg1 x   100    arg1 y   100    Point temp   arg1    arg1   arg2    arg2   temp    public static void main String    args      Point pnt1   new Point 0 0     Point pnt2   new Point 0 0     System out println  X1      pnt1 x     Y1     pnt1 y      System out println  X2      pnt2 x     Y2     pnt2 y     System out println         tricky pnt1 pnt2     System out println  X1      pnt1 x     Y1     pnt1 y      System out println  X2      pnt2 x     Y2     pnt2 y         Flow of the program   Point pnt1   new Point 0 0   Point pnt2   new Point 0 0     Creating two different Point object with two different reference associated    System out println  X1      pnt1 x     Y1     pnt1 y    System out println  X2      pnt2 x     Y2     pnt2 y   System out println         As expected output will be   X1  0     Y1  0 X2  0     Y2  0   On this line  pass-by-value  goes into the play      tricky pnt1 pnt2             public void tricky Point arg1  Point arg2     References pnt1 and pnt2 are passed by value to the tricky method  which means that now yours references pnt1 and pnt2 have their copies named arg1 and arg2 So pnt1 and arg1 points to the same object   Same for the pnt2 and arg2    In the tricky method    arg1 x   100   arg1 y   100      Next in the tricky method  Point temp   arg1  arg1   arg2  arg2   temp    Here  you first create new temp Point reference which will point on same place like arg1 reference  Then you move reference arg1 to point to the same place like arg2 reference  Finally arg2 will point to the same place like temp     From here scope of tricky method is gone and you don t have access any more to the references  arg1  arg2  temp  But important note is that everything you do with these references when they are  in life  will permanently affect object on which they are point to    So after executing method tricky  when you return to main  you have this situation    So now  completely execution of program will be   X1  0         Y1  0 X2  0         Y2  0 X1  100       Y1  100 X2  0         Y2  0

User · Answer

A  Java does manipulate objects by reference  and all object variables are references  However  Java doesn t pass method arguments by reference  it passes them by value   Take the badSwap   method for example   public void badSwap int var1  int var2      int temp   var1    var1   var2    var2   temp      When badSwap   returns  the variables passed as arguments will still hold their original values  The method will also fail if we change the arguments type from int to Object  since Java passes object references by value as well  Now  here is where it gets tricky   public void tricky Point arg1  Point arg2      arg1 x   100    arg1 y   100    Point temp   arg1    arg1   arg2    arg2   temp    public static void main String    args      Point pnt1   new Point 0 0     Point pnt2   new Point 0 0     System out println  X      pnt1 x     Y     pnt1 y      System out println  X      pnt2 x     Y     pnt2 y     System out println         tricky pnt1 pnt2     System out println  X      pnt1 x     Y     pnt1 y      System out println  X      pnt2 x     Y     pnt2 y         If we execute this main   method  we see the following output   X  0 Y  0 X  0 Y  0 X  100 Y  100 X  0 Y  0   The method successfully alters the value of pnt1  even though it is passed by value  however  a swap of pnt1 and pnt2 fails  This is the major source of confusion  In the main   method  pnt1 and pnt2 are nothing more than object references  When you pass pnt1 and pnt2 to the tricky   method  Java passes the references by value just like any other parameter  This means the references passed to the method are actually copies of the original references  Figure 1 below shows two references pointing to the same object after Java passes an object to a method    Figure 1  After being passed to a method  an object will have at least two references  Java copies and passes the reference by value  not the object  Thus  method manipulation will alter the objects  since the references point to the original objects  But since the references are copies  swaps will fail The method references swap  but not the original references  Unfortunately  after a method call  you are left with only the unswapped original references  For a swap to succeed outside of the method call  we need to swap the original references  not the copies

User · Answer

Java copies the reference by value  So if you change it to something else  e g  using new  the reference does not change outside the method  For native types  it is always pass by value

User · Answer

Java is always pass by value  with no exceptions  ever   So how is it that anyone can be at all confused by this  and believe that Java is pass by reference  or think they have an example of Java acting as pass by reference  The key point is that Java never provides direct access to the values of objects themselves  in any circumstances  The only access to objects is through a reference to that object  Because Java objects are always accessed through a reference  rather than directly  it is common to talk about fields and variables and method arguments as being objects  when pedantically they are only references to objects  The confusion stems from this  strictly speaking  incorrect  change in nomenclature   So  when calling a method   For primitive arguments  int  long  etc    the pass by value is the actual value of the primitive  for example  3   For objects  the pass by value is the value of the reference to the object    So if you have doSomething foo  and public void doSomething Foo foo         the two Foos have copied references that point to the same objects   Naturally  passing by value a reference to an object looks very much like  and is indistinguishable in practice from  passing an object by reference

User · Answer

Unlike some other languages  Java does not allow you to choose between pass-by-value and pass-by-reference   all arguments are passed by value  A method call can pass two types of values to a method   copies of primitive values  e g   values of int and double  and copies of references to objects   When a method modifies a primitive-type parameter  changes to the parameter have no effect on the original argument value in the calling method   When it comes to objects  objects themselves cannot be passed to methods  So we pass the reference address  of the object  We can manipulate the original object using this reference   How Java creates and stores objects  When we create an object we store the object   s address in a reference variable  Let s analyze the following statement   Account account1   new Account         Account account1    is the type and name of the reference variable          is the assignment operator     new    asks for the required amount of space from the system  The constructor to the right of keyword new which creates the object is called implicitly by the keyword new  Address of the created object result of right value  which is an expression called  class instance creation expression   is assigned to the left value  which is a reference variable with a name and a type specified  using the assign operator   Although an object   s reference is passed by value  a method can still interact with the referenced object by calling its public methods using the copy of the object   s reference  Since the reference stored in the parameter is a copy of the reference that was passed as an argument  the parameter in the called method and the argument in the calling method refer to the same object in memory   Passing references to arrays  instead of the array objects themselves  makes sense for performance reasons  Because everything in Java is passed by value  if array objects were passed  a copy of each element would be passed  For large arrays  this would waste time and consume considerable storage for the copies of the elements   In the image below you can see we have two reference variables These are called pointers in C C    and I think that term makes it easier to understand this feature   in the main method  Primitive and reference variables are kept in stack memory left side in images below   array1 and array2 reference variables  point   as C C   programmers call it  or reference to a and b arrays respectively  which are objects  values these reference variables hold are addresses of objects  in heap memory  right side in images below      If we pass the value of array1 reference variable as an argument to the reverseArray method  a reference variable is created in the method and that reference variable starts pointing to the same array  a     public class Test       public static void reverseArray int   array1                                  public static void main String   args                int   array1     1  10  -7            int   array2     5  -190  0             reverseArray array1               So  if we say   array1 0    5    in reverseArray method  it will make a change in array a   We have another reference variable in reverseArray method  array2  that points to an array c  If we were to say   array1   array2    in reverseArray method  then the reference variable array1 in method reverseArray would stop pointing to array a and start pointing to array c  Dotted line in second image    If we return value of reference variable array2 as the return value of method reverseArray and assign this value to reference variable array1 in main method  array1 in main will start pointing to array c   So let s write all the things we have done at once now   public class Test       public static int   reverseArray int   array1                int   array2     -7  0  -1             array1 0    5     array a becomes 5  10  -7          array1   array2     array1 of reverseArray starts           pointing to c instead of a  not shown in image below             return array2             public static void main String   args                int   array1     1  10  -7            int   array2     5  -190  0             array1   reverseArray array1      array1 of           main starts pointing to c instead of a                And now that reverseArray method is over  its reference variables array1 and array2  are gone  Which means we now only have the two reference variables in main method array1 and array2 which point to c and b arrays respectively  No reference variable is pointing to object  array  a  So it is eligible for garbage collection   You could also assign value of array2 in main to array1  array1 would start pointing to b

User · Answer

Java passes references to objects by value   So if any modification is done to the Object to which the reference argument points it will be reflected back on the original object   But if the reference argument point to another Object still the original reference will point to original Object

User · Answer

Java passes references by value   So you can t change the reference that gets passed in

User · Answer

I tried to simplify the examples above  keeping only the essense of the problem  Let me present this as a story that is easy to remember and apply correctly  The story goes like this  You have a pet dog  Jimmy  whose tail is 12 inches long  You leave it with a vet for a few weeks while you are travelling abroad   The vet doesn t like the long tail of Jimmy  so he wants to cut it by half  But being a good vet  he knows that he has no right to mutilate other people s dogs  So he first makes a clone of the dog  with the new key word  and cuts the tail of the clone  When the dog finally returns to you  it has the original 12 inch tail in tact  Happy ending    The next time you travel  you take the dog  unwittingly  to a wicked vet   He is also a hater of long tails  so he cuts it down to a miserable 2 inches   But he does this to your dear Jimmy  not a clone of it  When you return  you are shocked to see Jimmy pathetically wagging a 2 inch stub   Moral of the story  When you pass on your pet  you are giving away whole and unfettered custody of the pet to the vet  He is free to play any kind of havoc with it  Passing by value  by reference  by pointer are all just technical wrangling   Unless the vet clones it first  he ends up mutilating the original dog   public class Doggie        public static void main String   args            System out println  At the owner s home             Dog d   new Dog 12           d wag            goodVet d           System out println  With the owner again              d wag            badVet d           System out println  With the owner again              d wag               public static void goodVet  Dog dog            System out println  At the good vet             dog wag            dog   new Dog 12      create a clone         dog cutTail 6         cut the clone s tail         dog wag               public static void badVet  Dog dog            System out println  At the bad vet             dog wag            dog cutTail 2        cut the original dog s tail         dog wag                 class Dog        int tailLength       public Dog int originalLength            this tailLength   originalLength             public void cutTail  int newLength            this tailLength   newLength             public void wag              System out println  Wagging my    tailLength    inch tail             Output  At the owner s home  Wagging my 12 inch tail At the good vet  Wagging my 12 inch tail Wagging my 6 inch tail With the owner again   Wagging my 12 inch tail At the bad vet  Wagging my 12 inch tail Wagging my 2 inch tail With the owner again   Wagging my 2 inch tail

User · Answer

Let me try to explain my understanding with the help of four examples  Java is pass-by-value  and not pass-by-reference       Pass By Value  In Java  all parameters are passed by value  i e  assigning a method argument is not visible to the caller       Example 1   public class PassByValueString       public static void main String   args            new PassByValueString   caller               public void caller             String value    Nikhil           boolean valueflag   false          String output   method value  valueflag                          output  is insignificant in this example  we are more interested in             value  and  valueflag                      System out println  output       output           System out println  value       value           System out println  valueflag       valueflag               public String method String value  boolean valueflag            value    Anand           valueflag   true          return  output             Result  output   output value   Nikhil valueflag   false   Example 2              Pass By Value         public class PassByValueNewString       public static void main String   args            new PassByValueNewString   caller               public void caller             String value   new String  Nikhil            boolean valueflag   false          String output   method value  valueflag                          output  is insignificant in this example  we are more interested in             value  and  valueflag                      System out println  output       output           System out println  value       value           System out println  valueflag       valueflag               public String method String value  boolean valueflag            value    Anand           valueflag   true          return  output             Result  output   output value   Nikhil valueflag   false   Example 3         This  Pass By Value has a feeling of  Pass By Reference   Some people say primitive types and  String  are  pass by value    and objects are  pass by reference    But from this example  we can understand that it is infact pass by value only    keeping in mind that here we are passing the reference as the value    ie  reference is passed by value    That s why are able to change and still it holds true after the local scope    But we cannot change the actual reference outside the original scope    what that means is demonstrated by next example of PassByValueObjectCase2       public class PassByValueObjectCase1        private class Student           int id          String name          public Student                       public Student int id  String name                super                this id   id              this name   name                    public int getId                 return id                    public void setId int id                this id   id                    public String getName                 return name                    public void setName String name                this name   name                     Override         public String toString                 return  Student  id     id      name     name                             public static void main String   args            new PassByValueObjectCase1   caller               public void caller             Student student   new Student 10   Nikhil            String output   method student                          output  is insignificant in this example  we are more interested in             student                      System out println  output       output           System out println  student       student              public String method Student student            student setName  Anand            return  output             Result  output   output student   Student  id 10  name Anand    Example 4        In addition to what was mentioned in Example3  PassByValueObjectCase1 java    we cannot change the actual reference outside the original scope    Note  I am not pasting the code for private class Student  The class definition for Student is same as Example3       public class PassByValueObjectCase2        public static void main String   args            new PassByValueObjectCase2   caller               public void caller                student has the actual reference to a Student object created            can we change this actual reference outside the local scope  Let s see         Student student   new Student 10   Nikhil            String output   method student                          output  is insignificant in this example  we are more interested in             student                      System out println  output       output           System out println  student       student      Will it print Nikhil or Anand             public String method Student student            student   new Student 20   Anand            return  output              Result  output   output student   Student  id 10  name Nikhil

User · Answer

There is a very simple way to understand this  Lets s take C   pass by reference    include  lt iostream gt  using namespace std   class Foo       private          int x      public          Foo int val   x   val           void foo                         cout lt  lt x lt  lt endl                void bar Foo amp  ref        ref foo        ref     new Foo 99        ref foo       int main        Foo f   Foo 1      f foo       bar f      f foo        return 0      What is the outcome    1 1 99 99   So  after bar   assigned a new value to a  reference  passed in  it actually changed the one which was passed in from main itself  explaining the last f foo   call from main printing 99   Now  lets see what java says   public class Ref        private static class Foo           private int x           private Foo int x                this x   x                     private void foo                 System out println x                        private static void bar Foo f            f foo            f   new Foo 99           f foo               public static void main String   args            Foo f   new Foo 1           System out println f x           bar f           System out println f x              It says    1 1 99 1   Voil    the reference of Foo in main that was passed to bar  is still unchanged   This example clearly shows that java is not the same as C   when we say  pass by reference   Essentially  java is passing  references  as  values  to functions  meaning java is pass by value

User · Answer

The crux of the matter is that the word reference in the expression  pass by reference  means something completely different from the usual meaning of the word reference in Java    Usually in Java reference means a a reference to an object  But the technical terms pass by reference value from programming language theory is talking about a reference to the memory cell holding the variable  which is something completely different

User · Answer

PT 1  Of Realty Listings There is a blue  120sq-ft  quot Tiny House quot  currently parked at 1234 Main St with a nicely manicured lawn  amp  flower bed out front  A Realtor with a local firm is hired and told to keep a listing for that house  Let s call that Realtor  quot Bob  quot  Hi Bob  Bob keeps his Listing  which he calls tinyHouseAt1234Main  up to date with a webcam that allows him to note any changes to the actual house in real time  He also keeps a tally of how many people have asked about the listing  Bob s integer viewTally for the house is at 42 today  Whenever someone wants info about the blue Tiny House at 1234 Main St  they ask Bob  Bob looks up his Listing tinyHouseAt1234Main and tells them all about it - the color  the nice lawn  the loft bed and the composting toilet  etc  Then he adds their inquiry to his viewTally  He doesn t tell them the real  physical address though  because Bob s firm specializes in Tiny Houses that could be moved at any time  The tally is now 43  At another firm  Realtors might explicitly say their listing  quot points quot  to the house at 1234 Main St  denoting this with a little   next to it  because they mainly deal with houses that rarely ever move  though presumably there are reasons for doing so   Bob s firm doesn t bother doing this  Now  of course Bob doesn t physically go and put the actual house on a truck to show it to clients directly - that would be impractical and a ridiculous waste of resources  Passing a full copy of his tally sheet is one thing  but passing around the whole house all the time is costly and ridiculous   Aside  Bob s firm also doesn t 3D print new  amp  unique copies of a listed house every single time someone asks about it  That s what the upstart  similarly named web-based firm  amp  its spinoffs do - that s expensive and slower  and people often get the 2 firms confused  but they re quite popular anyway   At some other  older firms closer to the Sea  a realtor like Bob might not even exist to manage the Listings  Clients might instead consult the Rolodex  quot Annie quot    amp  for short  for the direct address of the house  Instead of reading off the referenced house details from the listing like Bob does  clients instead get the house address from Annie   amp    and go directly to 1234 Main St  sometimes w no idea what they might find there  One day  Bob s firm begins offering a new automated service that needs the listing for a house the client is interested in  Well  the person with that info is Bob  so the client has Bob call up the service and send it a copy of the listing  jobKillingAutomatedListingService Listing tinyHouseAt1234Main  int viewTally  Bob sends along     The service  on its end  calls this Listing houseToLookAt  but really what it receives is an exact copy of Bob s listing  with the exact same VALUEs in it  that refer to the house at 1234 Main St  This new service also has its own internal tally of how many people have viewed the listing  The service accepts Bob s tally out of professional courtesy  but it doesn t really care and overwrites it entirely with its own local copy anyway  It s tally for today is 1  while Bob s is still 43  The realty firms call this  quot pass-by-value quot  since Bob s passing the current value of his viewTally and his Listing tinyHouseAt1234Main  He s not actually passing along the entire physical house  because that s impractical  Nor is he passing the real physical address like Annie  amp   would do  But he IS passing a copy of the value OF the reference he has to the house  Seems like a silly pedantic difference in some ways  but that s how his firm works                    PT II  Where things get confusing and dangerous     The new automated service  not being all functional and math-oriented like some other trendy financial  amp  scientific firms  can have unforeseen side effects    Once given a Listing object it allows clients to actually repaint the REAL house at 1234 Main St  using a remote drone robot fleet  It allows clients to control a robot bulldozer to ACTUALLY dig up the flower bed  This is madness    The service also lets clients completely redirect houseToLookAt to some other house at another address  without involving Bob or his listing  All of a sudden they could be looking at 4321 Elm St  instead  which has no connection whatsoever to Bob s listing  thankfully they can t do anymore damage   Bob watches all this on his realtime webcam  Resigned to the drudgery of his sole job responsibility  he tells clients about the new ugly paint job  amp  sudden lack of curb appeal  His Listing is still for 1234 Main St   after all  The new service s houseToLookAt couldn t change that  Bob reports the details of his tinyHouseAt1234Main accurately and dutifully as always  until he gets fired or the house is destroyed entirely by The Nothing  Really the only thing the service CAN T do with its houseToLookAt copy of the Bob s original listing is change the address from 1234 Main St  to some other address  or to a void of nothingness  or to some random type of object like a Platypus  Bob s Listing still always points to 1234 Main St  for whatever it s still worth  He passes its current value around like always  This bizarre side-effect of passing a listing to the new automated service is confusing for people who ask about how it works  Really  what s the difference between the ability to remotely control robots that alter the state of the house at 1234 Main  vs  actually physically going there and wreaking havoc because Annie gave you the address   Seems like kind of a nitpicky semantic argument if what you generally care about is the state of the house in the listing being copied and passed around  right  I mean  if you were in the business of actually picking up houses and physically moving them to other addresses  not like mobile or Tiny Homes where that s sort of an expected function of the platform   or you were accessing  renaming  and shuffling entire neighborhoods like some sort of low-level God-playing madman  THEN maybe you d care more about passing around those specific address references instead of just copies of the the latest value of the house details

User · Answer

Please read  this   Many programming languages allow passing parameters by reference or by value  In Java  we can only pass parameters by value  This imposes some limits and also raises questions  For instance  if the parameter value is changed in the method  what happens to the value following method execution  You may also wonder how Java manages object values in the memory heap  This Java Challenger helps you resolve these and other common questions about object references in Java   For the more   https   www javaworld com article 3512039 does-java-pass-by-reference-or-pass-by-value html

User · Answer

I always think of it as  pass by copy   It is a copy of the value be it primitive or reference  If it is a primitive it is a copy of the bits that are the value and if it is an Object it is a copy of the reference   public class PassByCopy      public static void changeName Dog d           d name    Fido             public static void main String   args           Dog d   new Dog  Maxx            System out println  name     d name           changeName d           System out println  name     d name           class Dog      public String name      public Dog String s           this name   s            output of java PassByCopy      name  Maxx   name  Fido   Primitive wrapper classes and Strings are immutable so any example using those types will not work the same as other types objects

User · Answer

Java passes primitive types by value and class types by reference  Now  people like to bicker endlessly about whether  pass by reference  is the correct way to describe what Java et al  actually do  The point is this    Passing an object does not copy the object  An object passed to a function can have its members modified by the function  A primitive value passed to a function cannot be modified by the function  A copy is made    In my book that s called passing by reference     8212  Brian Bi - Which programming languages are pass by reference

User · Answer

public class Test        static class Dog           String name            Override         public int hashCode                 final int prime   31              int result   1              result   prime   result     name    null    0   name hashCode                 return result                      Override         public boolean equals Object obj                if  this    obj                  return true              if  obj    null                  return false              if  getClass      obj getClass                    return false              Dog other    Dog  obj              if  name    null                    if  other name    null                      return false                else if   name equals other name                   return false              return true                     public String getName                 return name                     public void setName String nb                this name   nb                     Dog String sd                this name   sd                                          param args             public static void main String   args            Dog aDog   new Dog  Max                we pass the object to foo         foo aDog           Dog oldDog   aDog           System out println   1      aDog getName   equals  Max        false         System out println   2     aDog getName   equals  huahua        false         System out println   3     aDog getName   equals  moron        true         System out println   4            aDog    oldDog       true             part2         Dog aDog1   new Dog  Max             foo aDog1  5           Dog oldDog1   aDog           System out println   5       aDog1 getName   equals  huahua        true         System out println   part2        aDog1    oldDog1       false          Dog oldDog2   foo aDog1  5  6           System out println   6      aDog1    oldDog2       true         System out println   7      aDog1    oldDog       false         System out println   8      aDog    oldDog2       false                                param d             public static void foo Dog d            System out println d getName   equals  Max        true          d setName  moron             d   new Dog  huahua            System out println   - -      d getName   equals  huahua        true                                param d         param a             public static void foo Dog d  int a            d getName   equals  Max       true          d setName  huahua                                   param d         param a         param b         return             public static Dog foo Dog d  int a  int b            d getName   equals  Max       true         d setName  huahua            return d            The sample code to demonstrate the impact of changes to the  object at different functions

User · Answer

Java is pass by constant reference where a copy of the reference is passed which means that it is basically a pass by value  You might change the contents of the reference if the class is mutable but you cannot change the reference itself  In other words the address can not be changed since it is passed by value but the content that is pointed by the address can be changed  In case of immutable classes  the content of the reference cannot be changed either

User · Answer

It s a bit hard to understand  but Java always copies the value - the point is  normally the value is a reference  Therefore you end up with the same object without thinking about it

User · Answer

A reference is always a value when represented  no matter what language you use   Getting an outside of the box view  let s look at Assembly or some low level memory management  At the CPU level a reference to anything immediately becomes a value if it gets written to memory or to one of the CPU registers   That is why pointer is a good definition  It is a value  which has a purpose at the same time    Data in memory has a Location and at that location there is a value  byte word  whatever   In Assembly we have a convenient solution to give a Name to certain Location  aka variable   but when compiling the code  the assembler simply replaces Name with the designated location just like your browser replaces domain names with IP addresses   Down to the core it is technically impossible to pass a reference to anything in any language without representing it  when it immediately becomes a value    Lets say we have a variable Foo  its Location is at the 47th byte in memory and its Value is 5  We have another variable Ref2Foo which is at 223rd byte in memory  and its value will be 47  This Ref2Foo might be a technical variable  not explicitly created by the program  If you just look at 5 and 47 without any other information  you will see just two Values  If you use them as references then to reach to 5 we have to travel    Name  Location  - gt   Value at the Location  ---------------------  Ref2Foo  223   - gt  47  Foo  47        - gt  5   This is how jump-tables work    If we want to call a method function procedure with Foo s value  there are a few possible way to pass the variable to the method  depending on the language and its several method invocation modes    5 gets copied to one of the CPU registers  ie  EAX   5 gets PUSHd to the stack  47 gets copied to one of the CPU registers 47 PUSHd to the stack  223 gets copied to one of the CPU registers  223 gets PUSHd to the stack    In every cases above a value - a copy of an existing value - has been created  it is now upto the receiving method to handle it  When you write  Foo  inside the method  it is either read out from EAX  or automatically  dereferenced  or double dereferenced  the process depends on how the language works and or what the type of Foo dictates  This is hidden from the developer until she circumvents the dereferencing process  So a reference is a value when represented  because a reference is a value that has to be processed  at language level    Now we have passed Foo to the method    in case 1  and 2  if you change Foo  Foo   9  it only affects local scope as you have a copy of the Value  From inside the method we cannot even determine where in memory the original Foo was located  in case 3  and 4  if you use default language constructs and change Foo  Foo   11   it could change Foo globally  depends on the language  ie  Java or like Pascal s procedure findMin x  y  z  integer var m  integer     However if the language allows you to circumvent the dereference process  you can change 47  say to 49  At that point Foo seems to have been changed if you read it  because you have changed the local pointer to it  And if you were to modify this Foo inside the method  Foo   12  you will probably FUBAR the execution of the program  aka  segfault  because you will write to a different memory than expected  you can even modify an area that is destined to hold executable program and writing to it will modify running code  Foo is now not at 47   BUT Foo s value of 47 did not change globally  only the one inside the method  because 47 was also a copy to the method  in case 5  and 6  if you modify 223 inside the method it creates the same mayhem as in 3  or 4   a pointer  pointing to a now bad value  that is again used as a pointer  but this is still a local problem  as 223 was copied  However if you are able to dereference Ref2Foo  that is 223   reach to and modify the pointed value 47  say  to 49  it will affect Foo globally  because in this case the methods got a copy of 223  but the referenced 47 exists only once  and changing that to 49 will lead every Ref2Foo double-dereferencing to a wrong value    Nitpicking on insignificant details  even languages that do pass-by-reference will pass values to functions  but those functions know that they have to use it for dereferencing purposes  This pass-the-reference-as-value is just hidden from the programmer because it is practically useless and the terminology is only pass-by-reference   Strict pass-by-value is also useless  it would mean that a 100 Mbyte array should have to be copied every time we call a method with the array as argument  therefore Java cannot be stricly pass-by-value  Every language would pass a reference to this huge array  as a value  and either employs copy-on-write mechanism if that array can be changed locally inside the method or allows the method  as Java does  to modify the array globally  from the caller s view  and a few languages allows to modify the Value of the reference itself   So in short and in Java s own terminology  Java is pass-by-value where value can be  either a real value or a value that is a representation of a reference

User · Answer

Java is pass by value    There are already great answers on this thread  Somehow  I was never clear on pass by value reference with respect to primitive data types and with respect to objects  Therefore  I tested it out for my satisfaction and clarity with the following piece of code  might help somebody seeking similar clarity   class Test       public static void main  String   args  throws java lang Exception          Primitive type     System out println  Primitve         int a   5      primitiveFunc a       System out println  Three      a        5        Object     System out println  Object         DummyObject dummyObject   new DummyObject        System out println  One      dummyObject getObj          555     objectFunc dummyObject       System out println  Four      dummyObject getObj          666  555 if line in method uncommented       private static void primitiveFunc int b           System out println  One      b        5     b   10      System out println  Two     b        10    private static void objectFunc DummyObject b          System out println  Two      b getObj          555       b   new DummyObject        b setObj 666       System out println  Three     b getObj          666       class DummyObject         private int obj   555      public int getObj     return obj        public void setObj int num    obj   num        If the line b   new DummyObject   is uncommented  the modifications made thereafter are made on a new object  a new instantiation  Hence  it is not reflected in the place where the method is called from  However  otherwise  the change is reflected as the modifications are only made on a  reference  of the object  i e - b points to the same dummyObject    Illustrations in one of the answers in this thread  https   stackoverflow com a 12429953 4233180  can help gain a deeper understanding

User · Answer

Java passes parameters by VALUE  and by value ONLY   To cut long story short      For those coming from C   THERE IS NO  out  parameter       For those coming from PASCAL  THERE IS NO  var  parameter    It means you can t change the reference from the object itself  but you can always change the object s properties   A workaround is to use StringBuilder parameter instead String  And you can always use arrays

User · Answer

Java passes parameters by value  There is no option of passing a reference in Java   But at the complier binding level layer  It uses reference internally not exposed to the user   It is essential as it saves a lot of memory and improves speed

User · Answer

Basically  reassigning Object parameters doesn t affect the argument  e g    private void foo Object bar        bar   null     public static void main String   args        String baz    Hah        foo baz       System out println baz       will print out  Hah   instead of null  The reason this works is because bar is a copy of the value of baz  which is just a reference to  Hah    If it were the actual reference itself  then foo would have redefined baz to null

User · Answer

Throughout all the answers we see that Java pass-by-value or rather as  Gevorg  wrote   pass-by-copy-of-the-variable-value  and this is the idea that we should have in mind all the time    I am focusing on examples that helped me understand the idea and it is rather addendum to previous answers   From  1  In Java you always are passing arguments by copy  that is you re always creating a new instance of the value inside the function  But there are certain behaviors that can make you think you re passing by reference    Passing by copy  When a variable is passed to a method function  a copy is made  sometimes we hear that when you pass primitives  you re making copies   Passing by reference  When a variable is passed to a method function  the code in the method function operates on the original variable  You re still passing by copy  but references to values inside the complex object are parts of both versions of the variable  both the original and the version inside the function  The complex objects themselves are being copied  but the internal references are being retained    Examples of Passing by copy  by value  Example from  ref 1   void incrementValue int inFunction     inFunction       System out println  In function      inFunction      int original   10  System out print  Original before      original   incrementValue original   System out println  Original after      original    We see in the console    gt  Original before  10   gt  In Function  11   gt  Original after  10  NO CHANGE    Example from  ref 2      shows nicely the mechanism   watch max 5 min    Passing by reference  pass-by-copy-of-the-variable-value  Example from  ref 1   remember that an array is an object   void incrementValu int   inFuncion     inFunction 0       System out println  In Function      inFunction 0       int   arOriginal    10  20  30   System out println  Original before      arOriginal 0    incrementValue arOriginal     System out println  Original before      arOriginal 0     We see in the console     gt Original before  10    gt In Function  11    gt Original before  11  CHANGE    The complex objects themselves are being copied  but the internal references are being retained   Example from ref 3   package com pritesh programs   class Rectangle     int length    int width     Rectangle int l  int b        length   l      width   b         void area Rectangle r1        int areaOfRectangle   r1 length   r1 width      System out println  Area of Rectangle                                    areaOfRectangle          class RectangleDemo     public static void main String args          Rectangle r1   new Rectangle 10  20       r1 area r1           The area of the rectangle is 200 and the length 10 and width 20  Last thing I would like to share was this moment of the lecture  Memory Allocation which I found very helpful in understanding the Java passing by value or rather    pass-by-copy-of-the-variable-value    as  Gevorg has written    REF 1 Lynda com REF 2 Professor Mehran Sahami   watch max 5 min Memory Allocation  REF 3 c4learn   passing-object-as-parameter-to-method

User · Answer

I d say it in another way  In java references are passed  but not objects  and these references are passed-by-value   the reference itself is copied and you have 2 references as a result and you have no control under the 1st reference in the method   Just saying  pass-by-value might be not clear enough for beginners  For instance in Python the same situation but there are articles  which describe that they call it pass-by-reference  only cause references are used

User · Answer

I just noticed you referenced my article   The Java Spec says that everything in Java is pass-by-value  There is no such thing as  pass-by-reference  in Java   The key to understanding this is that something like  Dog myDog    is not a Dog  it s actually a pointer to a Dog   What that means  is when you have  Dog myDog   new Dog  Rover    foo myDog     you re essentially passing the address of the created Dog object to the foo method    I say essentially because Java pointers aren t direct addresses  but it s easiest to think of them that way   Suppose the Dog object resides at memory address 42  This means we pass 42 to the method   if the Method were defined as  public void foo Dog someDog        someDog setName  Max           AAA     someDog   new Dog  Fifi        BBB     someDog setName  Rowlf         CCC     let s look at what s happening    the parameter someDog is set to the value 42 at line  AAA    someDog is followed to the Dog it points to  the Dog object at address 42  that Dog  the one at address 42  is asked to change his name to Max  at line  BBB    a new Dog is created  Let s say he s at address 74 we assign the parameter someDog to 74   at line  CCC    someDog is followed to the Dog it points to  the Dog object at address 74  that Dog  the one at address 74  is asked to change his name to Rowlf  then  we return   Now let s think about what happens outside the method   Did myDog change   There s the key   Keeping in mind that myDog is a pointer  and not an actual Dog  the answer is NO  myDog still has the value 42  it s still pointing to the original Dog  but note that because of line  AAA   its name is now  Max  - still the same Dog  myDog s value has not changed    It s perfectly valid to follow an address and change what s at the end of it  that does not change the variable  however   Java works exactly like C  You can assign a pointer  pass the pointer to a method  follow the pointer in the method and change the data that was pointed to  However  you cannot change where that pointer points   In C    Ada  Pascal and other languages that support pass-by-reference  you can actually change the variable that was passed   If Java had pass-by-reference semantics  the foo method we defined above would have changed where myDog was pointing when it assigned someDog on line BBB   Think of reference parameters as being aliases for the variable passed in  When that alias is assigned  so is the variable that was passed in

User · Answer

In Java only references are passed and are passed by value   Java arguments are all passed by value  the reference is copied when used by the method     In the case of primitive types  Java behaviour is simple   The value is copied in another instance of the primitive type   In case of Objects  this is the same   Object variables are pointers  buckets  holding only Object   s address that was created using the  new  keyword  and are copied like primitive types   The behaviour can appear different from primitive types  Because the copied object-variable contains the same address  to the same Object   Object s content members might still be modified within a method and later access outside  giving the illusion that the  containing  Object itself was passed by reference     String  Objects appear to be a good counter-example to the urban legend saying that  Objects are passed by reference    In effect  using a method  you will never be able  to update the value of a String passed as argument   A String Object  holds characters by an array declared final that can t be modified  Only the address of the Object might be replaced by another using  new    Using  new  to update the variable  will not let the Object be accessed from outside  since the variable was initially passed by value and copied

User · Answer

Java is a call by value How it works  You always pass a copy of the bits of the value of the reference   If it s a primitive data type these bits contain the value of the primitive data type itself  That s why if we change the value of header inside the method then it does not reflect the changes outside   If it s an object data type like Foo foo new Foo   then in this case copy of the address of the object passes like file shortcut    suppose we have a text file abc txt at C  desktop and suppose we make shortcut of the same file and put this inside C  desktop abc-shortcut so when you access the file from C  desktop abc txt and write  Stack Overflow  and close the file and again you open the file from shortcut then you write   is the largest online community for programmers to learn  then total file change will be  Stack Overflow is the largest online community for programmers to learn  which means it doesn t matter from where you open the file   each time we were accessing the same file   here we can assume Foo as a file and suppose foo stored at 123hd7h original address like C  desktop abc txt   address and 234jdid copied address like C  desktop abc-shortcut which actually contains the original address of the file inside     So for better understanding make shortcut file and feel

User · Answer

It s really quite  quite simple   For a variable of primitive type  eg  int  boolean  char  etc      when you use its name for a method argument  you are passing the value contained in it  5  true  or  c    This value gets  copied   and the variable retains its value even after the method invocation   For a variable of reference type  eg  String  Object  etc      when you use its name for a method argument  you are passing the value contained in it  the reference value that  points  to the object   This reference value gets  copied   and the variable retains its value even after the method invocation  The reference variable keeps  pointing  to the same object   Either way  you re always passing stuff by value     Compare this to say C   where you can have a method to take an int amp   or in C  where you could have take a ref int  although  in this case  you also have to use the ref modifier when passing the variable s name to the method

User · Answer

Java always passes parameters by value  All object references in Java are passed by value  This means that a copy of the value will be passed to a method  But the trick is that passing a copy of the value also changes the real value of the object  Please refer to the below example  public class ObjectReferenceExample        public static void main String    doYourBest                Student student   new Student                transformIntoHomer student               System out println student name              static void transformIntoDuleepa Student student                student name    quot Duleepa quot           class Student       String name     In this case  it will be Duleepa  The reason is that Java object variables are simply references that point to real objects in the memory heap  Therefore  even though Java passes parameters to methods by value  if the variable points to an object reference  the real object will also be changed

User · Answer

In an attempt to add even more to this  I thought I d include the SCJP Study Guide section on the topic  This is from the guide that is made to pass the Sun Oracle test on the behaviour of Java so it s a good source to use for this discussion      Passing Variables into Methods  Objective 7 3       7 3 Determine the effect upon object references and primitive values when they are passed into methods that perform assignments or other modifying operations on the parameters       Methods can be declared to take primitives and or object references  You need to know how  or if  the caller s variable can be affected by the called method  The difference between object reference and primitive variables  when passed into methods  is huge and important  To understand this section  you ll need to be comfortable with the assignments section covered in the first part of this chapter       Passing Object Reference Variables      When you pass an object variable into a method  you must keep in mind that you re passing the object reference  and not the actual object itself  Remember that a reference variable holds bits that represent  to the underlying VM  a way to get to a specific object in memory  on the heap   More importantly  you must remember that you aren t even passing the actual reference variable  but rather a copy of the reference variable  A copy of a variable means you get a copy of the bits in that variable  so when you pass a reference variable  you re passing a copy of the bits representing how to get to a specific object  In other words  both the caller and the called method will now have identical copies of the reference  and thus both will refer to the same exact  not a copy  object on the heap       For this example  we ll use the Dimension class from the java awt package    1  import java awt Dimension  2  class ReferenceTest   3      public static void main  String    args    4          Dimension d   new Dimension 5 10   5          ReferenceTest rt   new ReferenceTest    6          System out println  Before modify   d height       d height   7          rt modify d   8          System out println  After modify   d height     9        10  11  12  13      14         When we run this class  we can see that the modify   method was indeed able to modify the original  and only  Dimension object created on line 4     C  Java Projects Reference java ReferenceTest Before modify   d height   10 dim   11 After modify   d height   11      Notice when the Dimension object on line 4 is passed to the modify   method  any changes to the object that occur inside the method are being made to the object whose reference was passed  In the preceding example  reference variables d and dim both point to the same object       Does Java Use Pass-By-Value Semantics       If Java passes objects by passing the reference variable instead  does that mean Java uses pass-by-reference for objects  Not exactly  although you ll often hear and read that it does  Java is actually pass-by-value for all variables running within a single VM  Pass-by-value means pass-by-variable-value  And that means  pass-by-copy-of- the-variable   There s that word copy again        It makes no difference if you re passing primitive or reference variables  you are always passing a copy of the bits in the variable  So for a primitive variable  you re passing a copy of the bits representing the value  For example  if you pass an int variable with the value of 3  you re passing a copy of the bits representing 3  The called method then gets its own copy of the value  to do with it what it likes       And if you re passing an object reference variable  you re passing a copy of the bits representing the reference to an object  The called method then gets its own copy of the reference variable  to do with it what it likes  But because two identical reference variables refer to the exact same object  if the called method modifies the object  by invoking setter methods  for example   the caller will see that the object the caller s original variable refers to has also been changed  In the next section  we ll look at how the picture changes when we re talking about primitives       The bottom line on pass-by-value  the called method can t change the caller s variable  although for object reference variables  the called method can change the object the variable referred to  What s the difference between changing the variable and changing the object  For object references  it means the called method can t reassign the caller s original reference variable and make it refer to a different object  or null  For example  in the following code fragment            void bar                Foo f   new Foo               doStuff f                     void doStuff Foo g               g setName  Boo               g   new Foo                   reassigning g does not reassign f  At the end of the bar   method  two Foo objects have been created  one referenced by the local variable f and one referenced by   the local  argument  variable g  Because the doStuff   method has a copy of the reference variable  it has a way to get to the original Foo object  for instance to call the setName   method  But  the doStuff   method does not have a way to get to the f reference variable  So doStuff   can change values within the object f refers to  but doStuff   can t change the actual contents  bit pattern  of f  In other words  doStuff   can change the state of the object that f refers to  but it can t make f refer to a different object       Passing Primitive Variables      Let s look at what happens when a primitive variable is passed to a method    class ReferenceTest       public static void main  String    args          int a   1        ReferenceTest rt   new ReferenceTest          System out println  Before modify   a       a         rt modify a         System out println  After modify   a       a             void modify int number          number   number   1        System out println  number       number                In this simple program  the variable a is passed to a method called modify      which increments the variable by 1  The resulting output looks like this      Before modify   a   1   number   2   After modify   a   1      Notice that a did not change after it was passed to the method  Remember  it was a copy of a that was passed to the method  When a primitive variable is passed to a method  it is passed by value  which means pass-by-copy-of-the-bits-in-the-variable

User · Answer

Java  for sure  without a doubt  is  pass by value   Also  since Java is  mostly  object-oriented and objects work with references  it s easy to get confused and think of it to be  pass by reference   Pass by value means you pass the value to the method and if the method changes the passed value  the real entity doesn t change  Pass by reference  on the other hand  means a reference is passed to the method  and if the method changes it  the passed object also changes   In Java  usually when we pass an object to a method  we basically pass the reference of the object as-a-value because that s how Java works  it works with references and addresses as far as Object in the heap goes   But to test if it is really pass by value or pass by reference  you can use a primitive type and references    Test public void sampleTest        int i   5      incrementBy100 i       System out println  passed    gt     i       Integer j   new Integer 5       incrementBy100 j       System out println  passed    gt     j             param i     private void incrementBy100 int i        i    100      System out println  incremented      i       The output is   incremented   105 passed    gt  5 incremented   105 passed    gt  5   So in both cases  whatever happens inside the method doesn t change the real Object  because the value of that object was passed  and not a reference to the object itself   But when you pass a custom object to a method  and the method and changes it  it will change the real object too  because even when you passed the object  you passed it s reference as a value to the method  Let s try another example    Test public void sampleTest2        Person person   new Person 24   John        System out println person       alterPerson person       System out println person              param person     private void alterPerson Person person        person setAge 45       Person altered   person      altered setName  Tom       private static class Person      private int age      private String name        public Person int age  String name            this age age          this name  name             public int getAge             return age             public void setAge int age            this age   age             public String getName             return name             public void setName String name            this name   name              Override     public String toString             StringBuilder builder   new StringBuilder            builder append  Person  age             builder append age           builder append    name             builder append name           builder append               return builder toString               In this case  the output is   Person  age 24  name John  Person  age 45  name Tom

User · Answer

One of the biggest confusion in Java programming language is whether Java is Pass by Value or Pass by Reference   First of all  we should understand what is meant by pass by value or pass by reference   Pass by Value  The method parameter values are copied to another variable and then the copied object is passed  that   s why it   s called pass by value   Pass by Reference  An alias or reference to the actual parameter is passed to the method  that   s why it   s called pass by reference   Let   s say we have a class Balloon like below   public class Balloon        private String color       public Balloon          public Balloon String c           this color c             public String getColor             return color             public void setColor String color            this color   color            And we have a simple program with a generic method to swap two objects  the class looks like below   public class Test        public static void main String   args             Balloon red   new Balloon  Red      memory reference 50         Balloon blue   new Balloon  Blue      memory reference 100          swap red  blue           System out println  red color   red getColor             System out println  blue color   blue getColor              foo blue           System out println  blue color   blue getColor                 private static void foo Balloon balloon      baloon 100         balloon setColor  Red      baloon 100         balloon   new Balloon  Green      baloon 200         balloon setColor  Blue      baloon   200              Generic swap method     public static void swap Object o1  Object o2           Object temp   o1          o1 o2          o2 temp            When we execute the above program  we get following output   red color Red blue color Blue blue color Red   If you look at the first two lines of the output  it   s clear that swap method didn   t work  This is because Java is passed by value  this swap   method test can be used with any programming language to check whether it   s pass by value or pass by reference   Let   s analyze the program execution step by step   Balloon red   new Balloon  Red    Balloon blue   new Balloon  Blue      When we use the new operator to create an instance of a class  the instance is created and the variable contains the reference location of the memory where the object is saved  For our example  let   s assume that    red    is pointing to 50 and    blue    is pointing to 100 and these are the memory location of both Balloon objects   Now when we are calling swap   method  two new variables o1 and o2 are created pointing to 50 and 100 respectively   So below code snippet explains what happened in the swap   method execution   public static void swap Object o1  Object o2     o1 50  o2 100     Object temp   o1    temp 50  o1 50  o2 100     o1 o2    temp 50  o1 100  o2 100     o2 temp    temp 50  o1 100  o2 50     method terminated   Notice that we are changing values of o1 and o2 but they are copies of    red    and    blue    reference locations  so actually  there is no change in the values of    red    and    blue    and hence the output   If you have understood this far  you can easily understand the cause of confusion  Since the variables are just the reference to the objects  we get confused that we are passing the reference so Java is passed by reference  However  we are passing a copy of the reference and hence it   s pass by value  I hope it clears all the doubts now   Now let   s analyze foo   method execution   private static void foo Balloon balloon      baloon 100     balloon setColor  Red      baloon 100     balloon   new Balloon  Green      baloon 200     balloon setColor  Blue      baloon   200     The first line is the important one when we call a method the method is called on the Object at the reference location  At this point  the balloon is pointing to 100 and hence it   s color is changed to Red   In the next line  balloon reference is changed to 200 and any further methods executed are happening on the object at memory location 200 and not having any effect on the object at memory location 100  This explains the third line of our program output printing blue color Red   I hope above explanation clear all the doubts  just remember that variables are references or pointers and its copy is passed to the methods  so Java is always passed by value  It would be more clear when you will learn about Heap and Stack memory and where different objects and references are stored

User · Answer

I have created a thread devoted to these kind of questions for any programming languages here   Java is also mentioned  Here is the short summary    Java passes it parameters by value  by value  is the only way in java to pass a parameter to a method using methods from the object given as parameter will alter the object as the references point to the original objects   if that method itself alters some values

User · Answer

Java passes parameters by value  but for object variables  the values are essentially references to objects  Since arrays are objects the following example code shows the difference   public static void dummyIncrease int   x  int y        x 0         y      public static void main String   args        int   arr    3  4  5       int b   1      dummyIncrease arr  b          arr 0  is 4  but b is still 1    main     arr  ---         --- --- ---              ---- gt    3   4   5          ---         --- --- ---    b    ---                        1                         ---                                          dummyIncrease               x    ---                            ------------         ---          y    ---           1           ---

User · Answer

No  it s not pass by reference   Java is pass by value according to the Java Language Specification      When the method or constructor is invoked    15 12   the values of the actual argument expressions initialize newly created parameter variables  each of the declared type  before execution of the body of the method or constructor  The Identifier that appears in the DeclaratorId may be used as a simple name in the body of the method or constructor to refer to the formal parameter

User · Answer

passed by reference   caller and callee use same variable for parameter    passed by value   caller and callee have two independent variables with same value    Java uses pass by value    When passing primitive data  it copies the value of primitive data type  When passing object  it copies the address of object and passes to callee method variable     Example using primitive data type    public class PassByValuePrimitive       public static void main String   args            int i 5          System out println i      prints 5         change i           System out println i      prints 5             private static void change int i            System out println i      prints 5         i 10          System out println i     prints 10            Example using object   public class PassByValueObject       public static void main String   args            List lt String gt  list   new ArrayList lt  gt             list add  prem            list add  raj            new PassByValueObject   change list           System out println list      prints  prem  raj  ram               private  void change List list            System out println list get 0       prem         list add  ram            list null          System out println list add  bheem       gets NullPointerException

User · Answer

Not to repeat  but one point to those who might still be confused after reading many answers   pass by value in Java is NOT EQUAL to pass by value in C    though it sounds like that  which is probably why there s confusion  Breaking it down   pass by value in C   means passing the value of the object  if object   literarily the copy of the object pass by value in Java means passing the address value of the object  if object   not really the  quot value quot   a copy  of the object like C   By pass by value in Java  operating on an object  e g  myObj setName  quot new quot    inside a function has effects on the object outside the function  by pass by value in C    it has NO effects on the one outside  However  by pass by reference in C    operating on an object in a function DOES have effects on the one outside  Similar  just similar  not the same  to pass by value in Java  no    and people always repeat  quot there s no pass by reference in Java quot     gt  BOOM  confusion starts     So  friends  all is just about the difference of terminology definition  across languages   you just need to know how it works and that s it  though sometimes a bit confusing how it s called I admit

User · Answer

A lot of the confusion surrounding this issue comes from the fact that Java has attempted to redefine what  Pass by value  and  Pass by reference  mean  It s important to understand that these are Industry Terms  and cannot be correctly understood outside of that context  They are meant to help you as you code and are valuable to understand  so let s first go over what they mean    A good description of both can be found here   Pass By Value The value the function received is a copy of the object the caller is using  It is entirely unique to the function and anything you do to that object will only be seen within the function   Pass By Reference The value the function received is a reference to the object the caller is using  Anything the function does to the object that value refers to will be seen by the caller and it will be working with those changes from that point on   As is clear from those definitions  the fact that the reference is passed by value is irrelevant  If we were to accept that definition  then these terms become meaningless and all languages everywhere are only Pass By Value   No matter how you pass the reference in  it can only ever be passed by value  That isn t the point  The point is that you passed a reference to your own object to the function  not a copy of it  The fact that you can throw away the reference you received is irrelevant  Again  if we accepted that definition  these terms become meaningless and everyone is always passing by value   And no  C   s special  pass by reference  syntax is not the exclusive definition of pass by reference  It is purely a convenience syntax meant to make it so that you don t need to use pointer syntax after passing the pointer in  It is still passing a pointer  the compiler is just hiding that fact from you  It also still passes that pointer BY VALUE  the compiler is just hiding that from you   So  with this understanding  we can look at Java and see that it actually has both  All Java primitive types are always pass by value because you receive a copy of the caller s object and cannot modify their copy  All Java reference types are always pass by reference because you receive a reference to the caller s object and can directly modify their object    The fact that you cannot modify the caller s reference has nothing to do with pass by reference and is true in every language that supports pass by reference

User · Answer

There are already great answers that cover this  I wanted to make a small contribution by sharing a very simple example  which will compile  contrasting the behaviors between Pass-by-reference in c   and Pass-by-value in Java   A few points    The term  reference  is a overloaded with two separate meanings  In Java it simply means a pointer  but in the context of  Pass-by-reference  it means a handle to the original variable which was passed in  Java is Pass-by-value  Java is a descendent of C  among other languages   Before C  several  but not all  earlier languages like FORTRAN and COBOL supported PBR  but C did not  PBR allowed these other languages to make changes to the passed variables inside sub-routines  In order to accomplish the same thing  i e  change the values of variables inside functions   C programmers passed pointers to variables into functions  Languages inspired by C  such as Java  borrowed this idea and continue to pass pointer to methods as C did  except that Java calls its pointers References  Again  this is a different use of the word  Reference  than in  Pass-By-Reference   C   allows Pass-by-reference by declaring a reference parameter using the   amp   character  which happens to be the same character used to indicate  the address of a variable  in both C and C     For example  if we pass in a pointer by reference  the parameter and the argument are not just pointing to the same object  Rather  they are the same variable  If one gets set to a different address or to null  so does the other  In the C   example below I m passing a pointer to a null terminated string by reference  And in the Java example below I m passing a Java reference to a String  again  the same as a pointer to a String  by value  Notice the output in the comments    C   pass by reference example   using namespace std   include  lt iostream gt   void change  char   amp str        the   amp   makes this a reference parameter     str   NULL     int main         char  str    not Null       change str       cout lt  lt  str is    lt  lt  str             gt str is  lt null gt      Java pass  a Java reference  by value example  public class ValueDemo       public void change  String str           str   null              public static void main String   args           ValueDemo vd   new ValueDemo            String str    not null           vd change str           System out println  str is     str            gt  str is not null                                                      Note that if  str  was                                                    passed-by-reference  it                                                    WOULD BE NULL after the                                                    call to change               EDIT  Several people have written comments which seem to indicate that either they are not looking at my examples or they don t get the c   example  Not sure where the disconnect is  but guessing the c   example is not clear  I m posting the same example in pascal because I think pass-by-reference looks cleaner in pascal  but I could be wrong  I might just be confusing people more  I hope not   In pascal  parameters passed-by-reference are called  var parameters   In the procedure setToNil below  please note the keyword  var  which precedes the parameter  ptr   When a pointer is passed to this procedure  it will be passed by reference  Note the behavior  when this procedure sets ptr to nil  that s pascal speak for NULL   it will set the argument to nil--you can t do that in Java   program passByRefDemo  type     iptr    integer  var    ptr  iptr      procedure setToNil var ptr   iptr      begin        ptr    nil     end   begin    new ptr      ptr     10     setToNil ptr      if  ptr   nil  then        writeln  ptr seems to be nil          ptr should be nil  so this line will run    end    EDIT 2  Some excerpts from  THE Java Programming Language  by Ken Arnold  James Gosling  the guy who invented Java   and David Holmes  chapter 2  section 2 6 5     All parameters to methods are passed  by value   In other words    values of parameter variables in a method are copies of the invoker   specified as arguments    He goes on to make the same point regarding objects            You should note that when the parameter is an object reference  it is   the object reference-not the object itself-that is passed  by value     And towards the end of the same section he makes a broader statement about java being only pass by value and never pass by reference      The Java programming language does not pass objects by reference  it   passes object references by value  Because two copies of the same   reference refer to the same actual object  changes made through one   reference variable are visible through the other  There is exactly one   parameter passing mode-pass by value-and that helps keep things   simple    This section of the book has a great explanation of parameter passing in Java and of the distinction between pass-by-reference and pass-by-value and it s by the creator of Java  I would encourage anyone to read it  especially if you re still not convinced   I think the difference between the two models is very subtle and unless you ve done programming where you actually used pass-by-reference  it s easy to miss where two models differ   I hope this settles the debate  but probably won t   EDIT 3  I might be a little obsessed with this post  Probably because I feel that the makers of Java inadvertently spread misinformation  If instead of using the word  reference  for pointers they had used something else  say  dingleberry  there would ve been no problem  You could say   Java passes dingleberries by value and not by reference   and nobody would be confused   That s the reason only Java developers have issue with this  They look at the word  reference  and think they know exactly what that means  so they don t even bother to consider the opposing argument   Anyway  I noticed a comment in an older post  which made a balloon analogy which I really liked  So much so that I decided to glue together some clip-art to make a set of cartoons to illustrate the point   Passing a reference by value--Changes to the reference are not reflected in the caller s scope  but the changes to the object are  This is because the reference is copied  but the both the original and the copy refer to the same object    Pass by reference--There is no copy of the reference  Single reference is shared by both the caller and the function being called  Any changes to the reference or the Object s data are reflected in the caller s scope    EDIT 4  I have seen posts on this topic which describe the low level implementation of parameter passing in Java  which I think is great and very helpful because it makes an abstract idea concrete  However  to me the question is more about the behavior described in the language specification than about the technical implementation of the behavior  This is an exerpt from the Java Language Specification  section 8 4 1       When the method or constructor is invoked    15 12   the values of the   actual argument expressions initialize newly created parameter   variables  each of the declared type  before execution of the body of   the method or constructor  The Identifier that appears in the   DeclaratorId may be used as a simple name in the body of the method or   constructor to refer to the formal parameter    Which means  java creates a copy of the passed parameters before executing a method  Like most people who studied compilers in college  I used  The Dragon Book  which is THE compilers book  It has a good description of  Call-by-value  and  Call-by-Reference  in Chapter 1  The Call-by-value description matches up with Java Specs exactly   Back when I studied compilers-in the 90 s  I used the first edition of the book from 1986 which pre-dated Java by about 9 or 10 years  However  I just ran across a copy of the 2nd Eddition from 2007 which actually mentions Java  Section 1 6 6 labeled  Parameter Passing Mechanisms  describes parameter passing pretty nicely  Here is an excerpt under the heading  Call-by-value  which mentions Java      In call-by-value  the actual parameter is evaluated  if it is an   expression  or copied  if it is a variable   The value is placed in   the location belonging to the corresponding formal parameter of the   called procedure  This method is used in C and Java  and is a common   option in C     as well as in most other languages

User · Answer

Java passes references to objects by value

User · Answer

As far as I know  Java only knows call by value  This means for primitive datatypes you will work with an copy and for objects you will work with an copy of the reference to the objects  However I think there are some pitfalls  for example  this will not work   public static void swap StringBuffer s1  StringBuffer s2        StringBuffer temp   s1      s1   s2      s2   temp      public static void main String   args        StringBuffer s1   new StringBuffer  Hello        StringBuffer s2   new StringBuffer  World        swap s1  s2       System out println s1       System out println s2       This will populate Hello World and not World Hello because in the swap function you use copys which have no impact on the references in the main  But if your objects are not immutable you can change it for example   public static void appendWorld StringBuffer s1        s1 append   World       public static void main String   args        StringBuffer s   new StringBuffer  Hello        appendWorld s       System out println s       This will populate Hello World on the command line  If you change StringBuffer into String it will produce just Hello because String is immutable  For example   public static void appendWorld String s       s   s   World      public static void main String   args        String s   new String  Hello        appendWorld s       System out println s       However you could make a wrapper for String like this which would make it able to use it with Strings   class StringWrapper       public String value       public StringWrapper String value            this value   value           public static void appendWorld StringWrapper s       s value   s value    World      public static void main String   args        StringWrapper s   new StringWrapper  Hello        appendWorld s       System out println s value       edit  i believe this is also the reason to use StringBuffer when it comes to  adding  two Strings because you can modifie the original object which u can t with immutable objects like String is

User · Answer

I made this little diagram that shows how the data gets created and passed    Note  Primitive values are passed as a value  the first reference to to that value is the method s argument  That means    You can change the value of myObject inside the function But you can t change what myObject references to  inside the function  because point is not myObject Remember  both point and myObject are references  different references  however  those references point at the same new Point 0 0

User · Answer

Long story short     Non-primitives  Java passes the Value of the Reference    Primitives  just value     The End    2  is too easy  Now if you want to think of what  1  implies  imagine you have a class Apple   class Apple       private double weight      public Apple double weight            this weight   weight               getters and setters          then when you pass an instance of this class to the main method   class Main       public static void main String   args            Apple apple   new Apple 3 14           transmogrify apple           System out println apple getWeight      the goose drank wine                  private static void transmogrify Apple apple               does something with apple             apple setWeight apple getWeight   0 55             oh   but you probably know that  you re interested in what happens when you do something like this   class Main       public static void main String   args            Apple apple   new Apple 3 14           transmogrify apple           System out println  Who ate my    apple getWeight        will it still be 3 14               private static void transmogrify Apple apple               assign a new apple to the reference passed            apple   new Apple 2 71

User · Answer

The Java programming language passes arguments only by value  that is  you cannot change the argument value in the calling method from within the called method     However  when an object instance is passed as an argument to a method  the value of the argument is not the object itself but a reference to the object  You can change the contents of the object in the called method but not the object reference     To many people  this looks like pass-by-reference  and behaviorally  it has much in common with pass-by-reference  However  there are two reasons this is inaccurate    Firstly  the ability to change the thing passed into a method only applies to objects  not primitive values   Second  the actual value associated with a variable of object type is the reference to the object  and not the object itself  This is an important distinction in other ways  and if clearly understood  is entirely supporting of the point that the Java programming language passes arguments by value      The following code example illustrates this point  1 public class PassTest   2 3      Methods to change the current values 4   public static void changeInt int value    5     value   55  6    7   public static void changeObjectRef MyDate ref    8     ref   new MyDate 1  1  2000   9    10   public static void changeObjectAttr MyDate ref    11     ref setDay 4   12     13 14 public static void main String args      15     MyDate date  16     int val  17 18        Assign the int 19     val   11  20        Try to change it 21     changeInt val   22        What is the current value  23     System out println  Int value is      val   24 25    Assign the date 26     date   new MyDate 22  7  1964   27        Try to change it 28     changeObjectRef date   29        What is the current value  30 System out println  MyDate      date   31 32    Now change the day attribute 33        through the object reference 34     changeObjectAttr date   35        What is the current value  36 System out println  MyDate      date   37     38       This code outputs the following  java PassTest Int value is  11 MyDate  22-7-1964 MyDate  4-7-1964 The MyDate object is not changed by the changeObjectRef method  however  the changeObjectAttr method changes the day attribute of the MyDate object

User · Answer

You can never pass by reference in Java  and one of the ways that is obvious is when you want to return more than one value from a method call  Consider the following bit of code in C     void getValues int amp  arg1  int amp  arg2        arg1   1      arg2   2    void caller         int x      int y      getValues x  y       cout  lt  lt   Result     lt  lt  x  lt  lt       lt  lt  y  lt  lt  endl      Sometimes you want to use the same pattern in Java  but you can t  at least not directly  Instead you could do something like this   void getValues int   arg1  int   arg2        arg1 0    1      arg2 0    2    void caller         int   x   new int 1       int   y   new int 1       getValues x  y       System out println  Result      x 0          y 0        As was explained in previous answers  in Java you re passing a pointer to the array as a value into getValues  That is enough  because the method then modifies the array element  and by convention you re expecting element 0 to contain the return value  Obviously you can do this in other ways  such as structuring your code so this isn t necessary  or constructing a class that can contain the return value or allow it to be set  But the simple pattern available to you in C   above is not available in Java

User · Answer

The distinction  or perhaps just the way I remember as I used to be under the same impression as the original poster is this  Java is always pass by value  All objects  in Java  anything except for primitives  in Java are references  These references are passed by value

User · Answer

As many people mentioned it before  Java is always pass-by-value  Here is another example that will help you understand the difference  the classic swap example    public class Test     public static void main String   args        Integer a   new Integer 2       Integer b   new Integer 3       System out println  Before  a       a      b       b       swap a b       System out println  After  a       a      b       b          public static swap Integer iA  Integer iB        Integer tmp   iA      iA   iB      iB   tmp          Prints        Before  a   2  b   3   After  a   2  b   3   This happens because iA and iB are new local reference variables that have the same value of the passed references  they point to a and b respectively   So  trying to change the references of iA or iB will only change in the local scope and not outside of this method

User · Answer

There is a workaround in Java for the reference  Let me explain by this example   public class Yo   public static void foo int x       System out println x     out 2     x   x 2      System out println x      out 4   public static void foo int   x       System out println x 0      1     x 0    x 0  2      System out println x 0      3   public static void main String   args        int t   2      foo t       System out println t      out 2  t did not change in foo       int   tab   new int   1       foo tab       System out println tab 0       out 3  tab 0  did change in foo       I hope this helps

User · Answer

Shortest answer      Java has pass-by-value  and pass-reference-by-value    C  also has pass-by-reference   In C  this is accomplished with the  out  and  ref  keywords    Pass By Reference  The variable is passed in such a way that a reassignment inside the method is reflected even outside the method   Here follows an example of passing-by-reference  C    This feature does not exist in java   class Example       static void InitArray out int   arr                arr   new int 5    1  2  3  4  5               static void Main                 int   someArray          InitArray out someArray               This is true           boolean isTrue    someArray 0     1             See also  MSDN library  C    passing arrays by ref and out  See also  MSDN library  C    passing by by value and by reference

User · Answer

I thought I d contribute this answer to add more details from the Specifications   First  What  39 s the difference between passing by reference vs  passing by value      Passing by reference means the called functions  parameter will be the   same as the callers  passed argument  not the value  but the identity   - the variable itself         Pass by value means the called functions  parameter will be a copy of   the callers  passed argument    Or from wikipedia  on the subject of pass-by-reference     In call-by-reference evaluation  also referred to as   pass-by-reference   a function receives an implicit reference to a   variable used as argument  rather than a copy of its value  This   typically means that the function can modify  i e  assign to  the   variable used as argument   something that will be seen by its caller    And on the subject of pass-by-value     In call-by-value  the argument expression is evaluated  and the   resulting value is bound to the corresponding variable in the function           If the function or procedure is able to assign values to its   parameters  only its local copy is assigned          Second  we need to know what Java uses in its method invocations  The Java Language Specification states     When the method or constructor is invoked    15 12   the values of the   actual argument expressions initialize newly created parameter   variables  each of the declared type  before execution of the body of   the method or constructor    So it assigns  or binds  the value of the argument to the corresponding parameter variable    What is the value of the argument   Let s consider reference types  the Java Virtual Machine Specification states     There are three kinds of reference types  class types  array types    and interface types  Their values are references to dynamically   created class instances  arrays  or class instances or arrays that   implement interfaces  respectively    The Java Language Specification also states     The reference values  often just references  are pointers to these objects  and a special null reference  which refers to no object    The value of an argument  of some reference type  is a pointer to an object  Note that a variable  an invocation of a method with a reference type return type  and an instance creation expression  new      all resolve to a reference type value   So  public void method  String param         String var   new String  ref    method var   method var toString     method new String  ref       all bind the value of a reference to a String instance to the method s newly created parameter  param  This is exactly what the definition of pass-by-value describes  As such  Java is pass-by-value   The fact that you can follow the reference to invoke a method or access a field of the referenced object is completely irrelevant to the conversation  The definition of pass-by-reference was     This typically means that the function can modify  i e  assign to  the   variable used as argument   something that will be seen by its caller    In Java  modifying the variable means reassigning it  In Java  if you reassigned the variable within the method  it would go unnoticed to the caller  Modifying the object referenced by the variable is a different concept entirely      Primitive values are also defined in the Java Virtual Machine Specification  here  The value of the type is the corresponding integral or floating point value  encoded appropriately  8  16  32  64  etc  bits

User · Answer

Simple program  import java io    class Aclass       public int a    public class test       public static void foo obj Aclass obj                obj a 5            public static void foo int int a                a 3            public static void main String args                    test passing an object         Aclass ob   new Aclass            ob a 0          foo obj ob           System out println ob a    prints 5            test passing an integer         int i 0          foo int i           System out println i    prints 0           From a C C   programmer s point of view  java uses pass by value  so for primitive data types  int  char etc  changes in the function does not reflect in the calling function  But when you pass an object and in the function you change its data members or call member functions which can change the state of the object  the calling function will get the changes

User · Answer

Java does manipulate objects by reference  and all object variables are references  However  Java doesn t pass method arguments by reference  it passes them by value   Take the  badSwap    method for example       public void badSwap int var1  int  var2  int temp   var1  var1   var2  var2    temp      When  badSwap    returns  the variables passed as arguments will still hold their original values  The method will also fail if we change the arguments type from  int  to  Object  since Java passes object references by value as well  Now  here is where it gets tricky   public void tricky Point arg1  Point   arg2    arg1 x   100  arg1 y   100  Point temp   arg1  arg1   arg2  arg2   temp    public static void main String    args       Point pnt1   new Point 0 0   Point pnt2    new Point 0 0   System out println  X       pnt1 x     Y     pnt1 y         System out println  X      pnt2 x     Y      pnt2 y   System out println             tricky pnt1 pnt2    System out println  X      pnt1 x     Y     pnt1 y         System out println  X      pnt2 x     Y     pnt2 y       If we execute this  main    method  we see the following output   X  0 Y  0 X  0 Y  0 X  100 Y  100 X  0 Y  0  The method successfully alters the value ofpnt1  even though it is passed by value  however  a swap of  pnt1  and  pnt2  fails  This is the major source of confusion  In themain    method   pnt1  and  pnt2  are nothing more than object references  When you passpnt1  and  pnt2  to the  tricky    method  Java passes the references by value just like any other parameter  This means the references passed to the method are actually  copies  of the original references  Figure 1 below shows two references pointing to the same object after Java passes an object to a method   Java copies and passes the  reference  by value  not the object  Thus  method manipulation will alter the objects  since the references point to the original objects  But since the references are copies  swaps will fail  As Figure 2 illustrates  the method references swap  but not the original references  Unfortunately  after a method call  you are left with only the unswapped original references  For a swap to succeed outside of the method call  we need to swap the original references  not the copies

User · Answer

Everything is passed by value  Primitives and Object references  But objects can be changed  if their interface allows it   When you pass an object to a method  you are passing a reference  and the object can be modified by the method implementation    void bithday Person p        p age        The reference of the object itself  is passed by value  you can reassign the parameter  but the change is not reflected back   void renameToJon Person p         p   new Person  Jon       this will not work    jack   new Person  Jack    renameToJon jack   sysout jack      jack is unchanged   As matter of effect   p  is reference  pointer to the object  and can t be changed    Primitive types are passed by value  Object s reference can be considered a primitive type too    To recap  everything is passed by value

User · Answer

Understand it in 2 Steps    You can t change the reference to the object itself but you can work with this passed parameter as a reference to the object   If you want to change the value behind the reference you will only declare a new variable on the stack with the same name  d   Look at the references with the sign   and you will find out that the reference has been changed   public static void foo Dog d      d Name    belly     System out println d     Reference  Dog 1540e19d    d   new Dog  wuffwuff      System out println d     Dog 677327b6   public static void main String   args  throws Exception    Dog lisa   new Dog  Lisa      foo lisa     System out println lisa Name     belly

User · Answer

Just to show the contrast  compare the following C   and Java snippets   In C    Note  Bad code - memory leaks   But it demonstrates the point   void cppMethod int val  int  amp ref  Dog obj  Dog  amp objRef  Dog  objPtr  Dog   amp objPtrRef        val   7     Modifies the copy     ref   7     Modifies the original variable     obj SetName  obj       Modifies the copy of Dog passed     objRef SetName  objRef       Modifies the original Dog passed     objPtr- gt SetName  objPtr       Modifies the original Dog pointed to                                    by the copy of the pointer passed      objPtr   new Dog  newObjPtr        Modifies the copy of the pointer                                         leaving the original object alone      objPtrRef- gt SetName  objRefPtr       Modifies the original Dog pointed to                                         by the original pointer passed       objPtrRef   new Dog  newObjPtrRef       Modifies the original pointer passed    int main         int a   0      int b   0      Dog d0   Dog  d0        Dog d1   Dog  d1        Dog  d2   new Dog  d2        Dog  d3   new Dog  d3        cppMethod a  b  d0  d1  d2  d3          a is still set to 0        b is now set to 7        d0 still have name  d0         d1 now has name  objRef         d2 now has name  objPtr         d3 now has name  newObjPtrRef      In Java    public static void javaMethod int val  Dog objPtr       val   7     Modifies the copy    objPtr SetName  objPtr      Modifies the original Dog pointed to                                 by the copy of the pointer passed     objPtr   new Dog  newObjPtr        Modifies the copy of the pointer                                        leaving the original object alone     public static void main         int a   0      Dog d0   new Dog  d0        javaMethod a  d0          a is still set to 0        d0 now has name  objPtr      Java only has the two types of passing  by value for built-in types  and by value of the pointer for object types

User · Answer

The bottom line on pass-by-value  the called method can t change the caller s variable  although for object reference variables  the called method can change the object the variable referred to  What s the difference between changing the variable and changing the object  For object references  it means the called method can t reassign the caller s original reference variable and make it refer to a different object  or null    I took this code and explanation from a book on Java Certification and made some minor changes  I think it s a good illustration to the pass by value of an object   In the code below   reassigning g does not reassign f  At the end of the bar   method  two Foo objects have been created  one referenced by the local variable f and one referenced by the local  argument  variable g    Because the doStuff   method has a copy of the reference variable  it has a way to get  to the original Foo object  for instance to call the setName   method  But  the doStuff   method does not have a way to get to the f reference variable  So doStuff   can change values within the object f refers to  but doStuff   can t change the actual contents  bit pattern  of f  In other words  doStuff   can change the state of the object that f refers to  but it can t make f refer to a different object   package test abc   public class TestObject                    param args             public static void main String   args            bar               static void bar             Foo f   new Foo            System out println  Object reference for f      f           f setName  James            doStuff f           System out println f getName               Can change the state of an object variable in f  but can t change the object reference for f            You still have 2 foo objects          System out println  Object reference for f      f                  static void doStuff Foo g                g setName  Boo                g   new Foo                System out println  Object reference for g      g                 package test abc   public class Foo       public String name            public String getName             return name             public void setName String name            this name   name             Note that the object reference has not changed in the console output below   Console output   Object reference for f  test abc Foo 62f72617  Object reference for g  test abc Foo 4fe5e2c3  Boo Object reference for f  test abc Foo 62f72617

User · Answer

It seems everything is call by value in java as i have tried to understand by the following program Class-S class S  String name  quot alam quot   public void setName String n   this name n       Class-Sample     public class Sample      public static void main String args         S s new S        S t new S        System out println s name       System out println t name       t setName  quot taleev quot        System out println t name       System out println s name       s setName  quot Harry quot        System out println t name       System out println s name           Output  alam alam taleev alam taleev harry  As we have define class S with instance variable name with value taleev so for all the objects that we initialize from it will have the name variable with value of taleev but if we change the name s value of any objects then it is changing the name of only that copy of the class Object  not for every class so after that also when we do System out println s name  it is printing taleev only we can not change the name s value that we have defined originally  and the value that we are changing is the object s value not the instance variable value so once we have define instance variable we are unable to change it So i think that is how it shows that java deals with values only not with the references The memory allocation for the primitive variables can be understood by  this

User · Answer

Java always passes arguments by value  NOT by reference   Let me explain this through an example  public class Main         public static void main String   args              Foo f   new Foo  quot f quot              changeReference f      It won t change the reference            modifyReference f      It will modify the object that the reference variable  quot f quot  refers to               public static void changeReference Foo a              Foo b   new Foo  quot b quot              a   b               public static void modifyReference Foo c              c setAttribute  quot c quot               I will explain this in steps   Declaring a reference named f of type Foo and assign it a new object of type Foo with an attribute  quot f quot   Foo f   new Foo  quot f quot       From the method side  a reference of type Foo with a name a is declared and it s initially assigned null  public static void changeReference Foo a     As you call the method changeReference  the reference a will be assigned the object which is passed as an argument  changeReference f      Declaring a reference named b of type Foo and assign it a new object of type Foo with an attribute  quot b quot   Foo b   new Foo  quot b quot       a   b makes a new assignment to the reference a  not f  of the object whose attribute is  quot b quot     As you call modifyReference Foo c  method  a reference c is created and assigned the object with attribute  quot f quot     c setAttribute  quot c quot    will change the attribute of the object that reference c points to it  and it s the same object that reference f points to it     I hope you understand now how passing objects as arguments works in Java

User · Answer

Java is always pass-by-value  the parameters are copies of what the variables passed  all Objects are defined using a reference  and reference is a variable that stores a memory address of where the object is in memory   Check the comments to understand what happens in execution  follow numbers as they show the flow of execution     class Example       public static void test  Cat ref                   3 -  lt ref gt  is a copy of the reference  lt a gt             both currently reference Grumpy         System out println ref getName                 4 - now  lt ref gt  references a new  lt Cat gt  object named  Nyan          ref   new Cat  Nyan                5 - this should print  Nyan          System out println  ref getName                 public static void main  String    args                   1 - a is a  lt Cat gt  reference that references a Cat object in memory with name  Grumpy          Cat a   new Cat  Grumpy                2 - call to function test which takes a  lt Cat gt  reference         test  a               6 - function call ends  and  lt ref gt  life-time ends             Nyan  object has no references and the Garbage            Collector will remove it from memory when invoked             7 - this should print  Grumpy          System out println a getName

User · Answer

Mr  Scott Stanchfield wrote an excellent answer  Here is the class that would you to verify exactly what he meant   public class Dog        String dog       static int x static      int y not static       public String getName                 return this dog             public Dog String dog                this dog   dog             public void setName String name                this dog   name             public static void foo Dog someDog                x static   1             y not static   2      not possible            someDog setName  Max           AAA         someDog   new Dog  Fifi        BBB         someDog setName  Rowlf         CCC            public static void main String args                  Dog myDog   new Dog  Rover            foo myDog           System out println myDog getName               So  we pass from main   a dog called Rover  then we assign a new address to the pointer that we passed  but at the end  the name of the dog is not Rover  and not Fifi  and certainly not Rowlf  but Max

User · Answer

Java has only pass by value  A very simple example to validate this   public void test         MyClass obj   null      init obj         After calling init method  obj still points to null       this is because obj is passed as value and not as reference    private void init MyClass objVar        objVar   new MyClass

[java] Is Java "pass-by-reference" or "pass-by-value"?

Examples related to java

Examples related to methods

Examples related to parameter-passing

Examples related to pass-by-reference

Examples related to pass-by-value