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
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.