1980年代末~1990年代中頃に出版されてたものって翻訳物も含めて
今も有効なもの、というか今こそ使えるようなことが書かれているのに
絶版状態ってのが多い気がする今日この頃。
古本にバカみたいな値段がついてるのはそう多くはないのかもしれないけど。
なんかまたついったの一部で盛り上がってまして
図解 javaは参照渡しではなく参照の値渡しであるという事 - 蟻の実験工房(別館ラボ)
はてブのコメントの中にこういうのが
はてなブックマーク - tmurakamのブックマーク - 2013年7月16日
それを参照渡しというんだっつーの
はいはい。Does Java pass by reference or pass by value? - JavaWorld
あと、Evaluation strategy - Wikipedia, the free encyclopedia
call by value のとこと、そのすぐ後の Implicit limitations ね。
In some cases, the term "call-by-value" is problematic, as the value which is passed is not the value of
the variable as understood by the ordinary meaning of value, but an implementation-specific reference to
the value. The effect is that what syntactically looks like call-by-value may end up rather behaving like
call-by-reference or call-by-sharing, often depending on very subtle aspects of the language semantics.
Evaluation strategy - Wikipedia, the free encyclopedia
Call 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.
Call-by-reference can therefore be used to provide an additional channel of communication between the called
function and the calling function. The same effect can be emulated in languages like C by passing a pointer
(not to be confused with call-by-reference), or in languages like Java by passing a holding object, that can
be set by the caller. A call-by-reference language makes it more difficult for a programmer to track the
effects of a function call, and may introduce subtle bugs.
Evaluation strategy - Wikipedia, the free encyclopedia
Call by sharing
Also known as "call by object" or "call by object-sharing" is an evaluation strategy first
named by Barbara Liskov et al. for the language CLU in 1974.[3] It is used by languages such as Python,[4]
Iota, Java (for object references),[5] Ruby, Scheme, OCaml, AppleScript, and many other languages. However,
the term "call by sharing" is not in common use; the terminology is inconsistent across different
sources. For example, in the Java community, they say that Java is pass-by-value, whereas in the Ruby
community, they say that Ruby is pass-by-reference[citation needed], even though the two languages exhibit the
same semantics. Call-by-sharing implies that values in the language are based on objects rather than primitive
types.
The semantics of call-by-sharing differ from call-by-reference in that assignments to function arguments within
the function aren't visible to the caller (unlike by-reference semantics)[citation needed], so e.g. if a
variable was passed, it is not possible to simulate an assignment on that variable in the caller's scope.
However since the function has access to the same object as the caller (no copy is made), mutations to those
objects, if the objects are mutable, within the function are visible to the caller, which may appear to differ
from call-by-value semantics. For immutable objects, there is no real difference between call-by-sharing and
call-by-value, except for the object identity.
Javaの言語仕様にはなんか書かれてたっけか