I have a wording / precision question. Sometimes I write "object instance" sometimes "class instance".
Isn't it that an object is always an instance of a class? Therefore "object instance" is not the correct wording, right?
Is it common to say so anyway, or just a "mistake" of mine? I have the feeling "object instance" is superfluous (doubled) because an object is always an instance and would like to know more for clarification of the terms.
No, it is not right that an "object" is always an instance of a class. Just for example, the standard for C (which doesn't have classes at all) defines an object as (§3.14/1): "region of data storage in the execution environment, the contents of which can represent values."
Now, it is true that using "object" to refer to an instance of a class is quite common. In some languages (e.g., Smalltalk) all objects are instances of classes. In others (e.g., C++) the term is somewhat ambiguous, because there is a C-like use of the term and a Smalltalk-like use of the term, so it's not necessarily clear whether "object" is being used to refer specifically to an instance of a class, or just to some region of data storage in the execution environment, which may be an instance of some primitive type rather than a class, or may be (for example) some dynamic storage that hasn't been initialized, so it's not really an instance of any type.
As far as "object instance" making sense, I can see one situation where it could. Going back to Smalltalk: everything in Smalltalk is an instance of a class -- even a class is an instance of a class (called the metaclass). In a case like this, I can see where it could (sort of) make sense to talk about an "object instance", when you were specifically talking about an instance of a class as opposed to the class of the class.
In fairness, however, that usage is undoubtedly quite rare (at most). The vast majority of the time, "object instance" is probably just sloppy wording.
An object, often called an instance, is a specific instantiation of a class. If you instantiate (make an instance of) a class ten times, you get ten objects, but there's still just the one class.
The term object can refer to (at least) three different independent concepts:
An instance of a class. This is the case for object-oriented, strongly-typed, statically-typed languages such as Java and C#. In these languages, the "class" is the definition and "object" is a single manifestation ("instance") of that.
An untyped area in memory containing functions and data/state. This is what you'll find in many dynamically-typed but still object-oriented languages, especially scripting languages such as JavaScript. In this case, there is no "class", and there is no "instance" either, there are just objects, period.
Any addressable memory or data in a program. This was the commonly-accepted definition before OOP existed, and is still part of the C spec, as Jerry Coffin explains.
So this is essentially a two-part question, the answers being:
The term "object" is always correct in object-oriented languages. The term "class instance" is sometimes a synonym, but that depends on the specific language.
The term "object instance" is never correct. In languages that define objects, but not classes, the term "instance" is meaningless because every object is by definition an instance of something.
If you want to be safe, just avoid using the term "instance" unless you specifically need to distinguish between the type definition (class) and an instance of that type, e.g. when referring to an instance member vs. a class or static member.
The class is the compile-time specification of the object. The object is the runtime realisation of that specification.
Therefore when you create an object you are creating an "instance of a class", or "class instance".
An object instance would be something which corresponds to that object in the same way that a class instance corresponds to a class. I am not aware of any mainstream concepts that match that definition...
Also, while it's true that a class instance is always an object, objects are not always class instances : some languages support the creation of objects as literals. Consider, for instance, the JavaScript object defined as:
var bob = { name : "Bob", age : 31, birthday : function() { this.age++ } } ;
Or the OCaml equivalent:
let bob = object
val name = "Bob"
val age = 31
method birthday = {< age <- age + 1 >}
end
Isn't it that an object is always an instance of a class? Therefore "object instance" is not the correct wording, right?
int i;
Disproof by counter-example.
On the other hand, "object instance" is not good, and nor is "class instance", because not every object is an instance of a class. I'd usually just say "instance" or "object".
