Primitive wrapper class in Java: Difference between revisions

Revision as of 07:53, 23 March 2016

Latest revision as of 01:53, 14 July 2025

(27 intermediate revisions by 24 users not shown)

Line 1:

{{Short description|none}}

In [[object -oriented programming and in the [[Java (programming language)|Java]] language in particular, a '''wrapper class''' is a [[class (computer programming)|class]] that [[Encapsulation (computer_programming)computer programming)|encapsulates]] [[data type|types]], so that those types can be used to create [[object (computer science)|object]] [[instance (computer science)|instances]] and [[method (computer programming)|methods]] in another class that needneeds those types. So a '''primitive wrapper class''' is a wrapper class that encapsulates, hides or ''wraps'' data types from the eight [[primitive data types type]]s,<ref>S. J., Chapman, ''Introduction to Java'', Prentice Hall, 1999.</ref>, so that these can be used to create instantiated objects with methods in another class or in other classes .<ref name=murach>J. Murach, ''Murach's Java Programming'', 4th Edition, Mike Murach and Associates, Inc., 2011.</ref>, <ref>J. R., Hubbard, ''Programming with Java'', Schaum's Outline Series/McGraw Hill, 1998.</ref>. The primitive wrapper classes are found in the [[Java API]].

Primitive wrapper classes are used to create an {{Javadoc:SE|java/lang|Object}} that needs to represent primitive types in {{Javadoc:SE|java/util|Collection}} classes (i.e., in the Java API), in the {{Javadoc:SE|package=java.util|java/util}} package and in the {{Javadoc:SE|package=java.lang.reflect|java/lang/reflect}} [[Reflection (computer science)|reflection]] package. Collection classes are Java API -defined classes that can store objects in a manner similar to how data structures like arrays can store primitive data types like '''int''', '''double''', '''long''' or '''char''', etc., primitive data types <ref>J. Murach, ''Murach's Java Programming'', 4th Edition, Mike Murach and Associates, Inc., 2011.<name=murach/ref> Butbut arrays store primitive data types while collections actually store objects.

The primitive wrapper classes and their corresponding primitive types are:

:{| class="wikitable"

! Primitive type !! Wrapper class !! Constructor Argumentsarguments

|-

| <code>byte</code> || {{Javadoc:SE|java/lang|Byte}} || <code>byte</code> or <code>String </code>

Line 25 ⟶ 26:

|}

==The difference between wrapper classes and primitive types==

<div style="text-align:justify;">

==The Difference between Wrapper Classes and Primitive Types==

Primitive wrapper classes are not the same thing as are primitive types. TheWhereas mainvariables, differencefor is that whereas variablesexample, can be declared in Java as data types '''double''', '''short''', '''int''', or '''char''', etc., data types, the eight primitive wrapper classes create instantiated objects and methods that inherit but hide the eight primitive data types, not like variables that are assigned the data type values .<ref>J. Murach, ''Murach's Java Programming'', 4th Edition, Mike Murach and Associates, Inc., 2011.<name=murach/ref>.

Therefore, the term ''Primitive wrapper class'' does not mean that wrapper classes are primitive types. It should be understood to be a class that wraps primitive types. Wrapper classes can be used to store the same value as of a primitive type variable but the instances/objects of wrapper classes themselves are ''Non-Primitive''. We cannot say that Wrapper classes themselves are Primitive types. They just wrap the primitive types.

</div>

The <code>Byte</code>, <code>Short</code>, <code>Integer</code>, <code>Long</code>, <code>Float</code>, and <code>Double</code> wrapper classes are all [[subclass (computer science)|subclass]]es of the {{Javadoc:SE|java/lang|Number}} class.

The wrapper classes <code>BigDecimal</code> and <code>BigInteger </code> are not one of the primitive wrapper classes but are immutable.<ref>{{cite web

| url = http://www.javaranch.com/journal/2003/04/immutable.htm

| title = Mutable and Immutable Objects: Which classes are Immutable?

| author = David O'Meara

| date = April 2003-04

| publisher = Java Ranch

| accessdate = 2012-05-14

Line 51 ⟶ 50:

}}</ref>

== Atomic wrapper classes ==asd

==The Wrapper Class Void==

The wrapper class named '''Void''' is not a primitive wrapper class, specifically because '''void''' is not a primitive data type. However the '''Void''' wrapper class can be used to create new objects that have methods that are not expected to return a value.

Although it is a wrapper class, the {{Javadoc:SE|java/lang|Void}} class provides an object representation of the [[void type|<code>void</code>]] return.

== Atomic wrapper classes ==asd

With Java 5.0, additional wrapper classes were introduced in the {{Javadoc:SE|package=java.util.concurrent.atomic|java/util/concurrent/atomic}} package. These classes are mutable and cannot be used as a replacement for the regular wrapper classes. Instead, they provide [[atomic operation]]s for addition, increment and assignment.

Line 76 ⟶ 69:

The <code>AtomicInteger</code> and <code>AtomicLong</code> classes are subclasses of the <code>Number</code> class. The <code>AtomicReference</code> class accepts the [[TypeParameter|type parameter]] <code>V</code> that specifies the type of the object [[reference (computer science)|reference]]. (See "[[Generics in Java]]" for a description of type parameters in Java).

<code>V</code>

== See also ==