What operations take place when we pass argument to method?

Question

I know, that if i pass:

• primitive type, then copy of element will be sent
• object type, then copy of reference will be sent

I assume that (please verify):

• Reference size is equal with object element size
• Object size is sum of all primitive and reference type sizes that it contains
• Static variables are not contained in object
• if primitive type differs, then resulting type is always at least widest of two types.

I am not sure what happens if i pass:

• 'null' (empty reference?)
• object type differs (first common parent?)(how is that found???)
• enum (copy of int ?)
• anonymous class

Answer 1

If you are talking about in-memory method calls (and not RMI or something like that) the size of all references are the same. They are a handle to an object on the heap. It doesn't matter what the size of the object is.

Assuming you can compile the code, the primitive type will match the calling method in some way. Either by an explicit cast, or by an automatic widening, depending on what you are doing (are you calling a long method with an int, or an int method with a long).

The reference is always the same regardless if it is an enum, cast as a different object type (the object is the same, just the type reference is different) or an anonymous class. In all cases it is a reference to an object instance on the heap.

An anonymous class (or any inner class not declared static) does have an implicit hidden reference to its parent.

Null represents no reference, so I don't know about size, but the JVM will have some internal representation of that. I doubt in practice it is actually smaller than an object reference, in terms of amount of memory, but it may be, especially in JavaME.

It should be pointed out that in practice java developers don't think about these things much. Only someone implementing a JVM would care about these issues (size of references, for example). You can't do anything about them in the language, so if you have performance issues because of it, pick a different language.

Answer 2

Why don't you check out google?

http://www.yoda.arachsys.com/java/passing.html

Also - there's no sizeof in Java.

Answer 3

I'm not sure what you are looking for with the "Reference Size" points, but here are the few I can answer with some certainty:

if primitive type differs, then resulting type is always at least widest of two types.

isn't quite true. If you specify int and pass in a long, you have to downcast to int and what will be passed is an int. If you pass a byte, it will automatically be up-casted to an int. It will always pass an int.

Object size is sum of all primitive and reference type sizes that it contains

There is also a function pointer table and some other stuff, I don't think it's this straight-forward.

Static variables are not contained in object

I would say they are not contained in the object Instance, but there may be a pointer to them in the object instance (in that pointer table I was talking about)... but I don't think so.

'null' (empty reference?)

If you pass null it will act much like c (I believe a pointer to 0 or some other predefined bad location that means "Null") but you don't have any access to this except to compare it to null or get an NPE, you can't deal with it in other ways like you can in c

object type differs (first common parent?)(how is that found???)

There is meta-data stored in an object to tell you what type it is, but more importantly there is a pointer table so that the "Correct" method to call is always just a de-reference of a pointer, you don't have to figure out what class you actually have and scan up the "Extends" tree to find the first implementation of a given method, instead regardless of what your class is casted to there is a pointer to the correct "toString" method that you should be using.

anonymous class

These are given magic names based on the parent's class name and compiled as regular classes with some special exceptions.