Computer science or computing science is the study of the theoretical foundations of information and computation and of practical techniques for their implementation and application in computer systems...
Object-oriented programming is a programming paradigm using "objects" – data structures consisting of data fields and methods together with their interactions – to design applications and computer programs. Programming techniques may include features such as data abstraction,...
to wrap a non-object type to make it look like a dynamic
Reference type
In programming language theory, a reference type is a data type that can only be accessed by references. Unlike objects of value types, objects of reference types cannot be directly embedded into composite objects and are always dynamically allocated...
In computer science, an object is any entity that can be manipulated by the commands of a programming language, such as a value, variable, function, or data structure...
This is a list of object-oriented programming programming languages.-Languages with object-oriented features:*ABAP*Ada 95*AmigaE*BETA*Blue*Boo*C++*C#*COBOL*Cobra*ColdFusion*Common Lisp*COOL*CorbaScript*Clarion*CLU*Curl*D*Dylan*E*Eiffel...
In programming language theory, a reference type is a data type that can only be accessed by references. Unlike objects of value types, objects of reference types cannot be directly embedded into composite objects and are always dynamically allocated...
In computer science, the term value type is commonly used to refer to one of two kinds of data types: Types of values or Types of objects with deep copy semantics.- Types of Values :...
s, often referred to as objects and non-objects on platforms where complex value types don't exist, for reasons such as runtime efficiency and syntax or semantic issues. For example, Java
Java (programming language)
Java is a programming language originally developed by James Gosling at Sun Microsystems and released in 1995 as a core component of Sun Microsystems' Java platform. The language derives much of its syntax from C and C++ but has a simpler object model and fewer low-level facilities...
A primitive wrapper class in the Java programming language is one of eight classes provided in the package to provide object methods for the eight primitive types. All of the primitive wrapper classes in Java are immutable...
In computer science, primitive data type is either of the following:* a basic type is a data type provided by a programming language as a basic building block...
C++ is a statically typed, free-form, multi-paradigm, compiled, general-purpose programming language. It is regarded as an intermediate-level language, as it comprises a combination of both high-level and low-level language features. It was developed by Bjarne Stroustrup starting in 1979 at Bell...
have little or no notion of reference type; thus, the use of object type is of little interest.
Boxing
Boxing is the process of placing a primitive type within an object so that the primitive can be used as a reference object. For example, lists may have certain methods
Method (computer science)
In object-oriented programming, a method is a subroutine associated with a class. Methods define the behavior to be exhibited by instances of the associated class at program run time...
In computer science, an array type is a data type that is meant to describe a collection of elements , each selected by one or more indices that can be computed at run time by the program. Such a collection is usually called an array variable, array value, or simply array...
might not, but the list might also require that all of its members be dynamic objects. In this case, the added functionality of the list might be unavailable to a simple array of numbers.
For a more concrete example, in Java, a can change its size, but an array must have a fixed size. One might desire to have a of s, but the class only lists references to dynamic objects — it cannot list primitive types, which are value types.
To circumvent this, s can be boxed into s, which are dynamic objects, and then added to a of s. (Using generic
Generic programming
In a broad definition, generic programming is a style of computer programming in which algorithms are written in terms of to-be-specified-later types that are then instantiated when needed for specific types provided as parameters...
Java Platform, Standard Edition or Java SE is a widely used platform for programming in the Java language. It is the Java Platform used to deploy portable applications for general use...
5.0, this type is represented as .)
On the other hand, C# has no primitive wrapper classes, but allows boxing of any value type, returning a generic reference.
The boxed object is always a copy of the value object, and is usually immutable
Immutable object
In object-oriented and functional programming, an immutable object is an object whose state cannot be modified after it is created. This is in contrast to a mutable object, which can be modified after it is created...
. Unboxing the object also returns a copy of the stored value. Note that repeated boxing and unboxing of objects can have a severe performance impact, since it dynamically allocates new objects and then makes them eligible for Garbage collection
Garbage collection (computer science)
In computer science, garbage collection is a form of automatic memory management. The garbage collector, or just collector, attempts to reclaim garbage, or memory occupied by objects that are no longer in use by the program...
.
There is a direct equivalence between an unboxed primitive type and a reference to an immutable, boxed object type. In fact, it is possible to substitute all the primitive types in a program with boxed object types. Whereas assignment from one primitive to another will copy its value, assignment from one reference to a boxed object to another will copy the reference value to refer to the same object as the first reference. However, this will not cause any problems, because the objects are immutable, so there is semantically no real difference between two references to the same object or to different objects (unless you look at physical equality). For all operations other than assignment, such as arithmetic, comparison, and logical operators, one can unbox the boxed type, perform the operation, and re-box the result as needed. Thus, it is possible to not store primitive types at all.
Autoboxing
Autoboxing is the term for getting a reference type out of a value type just through type conversion
Type conversion
In computer science, type conversion, typecasting, and coercion are different ways of, implicitly or explicitly, changing an entity of one data type into another. This is done to take advantage of certain features of type hierarchies or type representations...
(either implicit or explicit). The compiler automatically supplies the extra source code which creates the object.
For example, in versions of Java prior to J2SE 5.0, the following code did not compile:
Integer i = new Integer(9);
Integer l = 9; // error in versions prior to 5.0!
Compilers prior to 5.0 would not accept the last line. s are reference objects, on the surface no different from , , and so forth. To convert from an int to an Integer, one had to "manually" instantiate the Integer object. As of J2SE 5.0, the compiler will accept the last line, and automatically transform it so that an Integer object is created to store the value 9. This means that, from J2SE 5.0 on, something like Integer c = a + b;, where a and b are Integers themselves, will compile now, because they are unboxed, the integer values summed up, and the result is autoboxed into a new Integer, which is finally stored inside variable c. Note that the equality operators cannot be used this way, since the equality operators are already defined for reference types, for equality of the references; to test for equality of the value in a boxed type, one must still manually unbox them and compare the primitives.
Another example: J2SE 5.0 allows the programmer to treat a collection (such as a ) as if it contained int values instead of Integer objects. This does not contradict what was said above: the collection still only contains references to dynamic objects, and it cannot list primitive types. It can not be a List<int>, but it must be a List<Integer> instead. However, the compiler automatically transforms the code so that the list will "silently" receive objects, while the source code only mentions primitive values. For example, the programmer can now write list.add(3); and think as if the int 3 were added to the list; but, the compiler will have actually transformed the line into list.add(new Integer(3)).
Unboxing
Unboxing refers to getting the value which is associated to a given object, just through type conversion (either implicit or explicit). The compiler automatically supplies the extra source code which retrieves the value out of that object, either by invoking some method on that object, or by other means.
For example, in versions of Java prior to J2SE 5.0, the following code did not compile:
Integer k = new Integer(4);
int l = k.intValue; // always OK
int m = k; // would have been an error, but okay now - equivalent to previous line
C# doesn't support automatic unboxing in the same meaning as Java, since it doesn't have a separate set of 'primitive types' and 'object types'. All types that have both primitive and object version in Java, are automatically implemented by the C# compiler as either primitive (value) types or object (reference) types.
In both languages, automatic boxing does not downcast automatically, i.e. the following code won't compile:
C#:
int i = 42;
object o = i; // box
int j = o; // unbox (ERROR)
Console.Writeline(j); // outputs "42"
Java:
int i = 42;
Object o = i; // box
int j = o; // unbox (ERROR)
System.out.println(j); // outputs "42"
The source of this article is wikipedia, the free encyclopedia. The text of this article is licensed under the GFDL.
