Wrapper class
Wrapper class were a solution of the primitive data type not
being a part of object oriented approach of java….like being returned from a
method as a method.
Java allows you to
include the primitives in the family of objects by using what are called wrapper classes
There is a wrapper class
for every primitive in java.. the wrapper class for int is Integer, for float
is Float.
The
wrapper classes in the Java API serve two primary purposes:
- To provide a mechanism to
“wrap” primitive values in an object so that the primitives can be
included in activities reserved for objects, like as being added to
Collections, or returned from a method with an object return value.
- To provide an assortment of
utility functions for primitives. Most of these functions are related to
various conversions: converting primitives to and from String objects, and
converting primitives and String objects to and from different bases (or
radix), such as binary, octal, and hexadecimal.
The wrapper object of a
wrapper class can be created in one of two ways: by instantiating the wrapper
class with the new operator or by invoking a static method on the wrapper
class.
Creating wrapper object with new operator
Primitive
datatype-->Wrapper Class-->Constructor arguments
- boolean--> Boolean-->
boolean or String
- byte--> Byte--> byte or
String
- char--> Character--> char
- short--> Short--> short
or String
- int-->Integer--> int or
String
- long--> Long--> long or
String
- float-->Float--> float
double or String
- double-->Double--> double
or String
All the wrapper classes
are declared final. That means you cannot derive a subclass from
any of them.All the wrapper classes except Boolean and Character are subclasses
of an abstract class called Number, whereas Boolean and Character are derived
directly from the Object class.All of the wrapper classes except Character
provide two constructors: one that takes a primitive of the type being
constructed, and one that takes a String representation of the type being
constructed.
Boolean
wboo = new Boolean("false");
Boolean
yboo=new Boolean(false);
Character c1 = new Character('c');
Note that there is no way
to modify a wrapped value—that is, the wrapped values are immutable. To wrap
another value, you need to create another object.
WRAPPING PRIMITIVES USING A STATIC METHOD
All wrapper classes offers static valueOf() methods which
give you another approach to creating wrapper objects. Because it's a static
method, it can be invoked directly on the class (without instantiating it), and
will return the corresponding object that is wrapping what you passed in as an
argument.
this method take a String representation of the
appropriate type of primitive as its first argument, it also takes an
additional argument, int radix, which indicates in what base (for example
binary, octal, or hexadecimal) the first argument is represented
Integer i2 = Integer.valueOf("101011", 2); // converts 101011 to 43 and assigns the
// value 43 to the Integer object i2
USING
WRAPPER CONVERSION UTILITIES
xxxValue()
method
When you need to convert
the value of a wrapped numeric to a primitive, use one of the many xxxValue()
methods. All of the methods in this family are no-arg methods. Each of the six
numeric wrapper classes has six methods, so that any numeric wrapper can be
converted to any primitive numeric type.
Integer i2 = new Integer(42); // make a new wrapper object
byte b = i2.byteValue(); // convert i2's value to a byte primitive
short s = i2.shortValue(); // another of Integer's xxxValue methods
double d = i2.doubleValue(); // yet another of Integer's xxxValue methods
xxx
Parsexxx(String) method
If you do not need to
store a value in a wrapper but just want to convert the type , you can do it by
using an appropriate static method of the appropriate wrapper class. For
example, all the wrapper classes except Character offer a static method that
has the following signature:
static <type> parse<Type>(String s)
The <type> may be
any of the primitive types except char (byte, short, int, long, float, double,
or boolean), and the <Type> is the same as <type> with the first
letter uppercased;
String s = "123";
int i = Integer.parseInt(s);
parseXxx()
and valueOf()
· parseXxx() returns the named primitive.
·
valueOf() returns a newly created wrapped object of the type that
invoked the method.
double d4 = Double.parseDouble("3.14"); // convert a String to a primitive
System.out.println("d4 = " + d4); // result is "d4 = 3.14"
Double d5 = Double.valueOf("3.14"); // create a Double object
System.out.println(d5 instanceof Double ); // result is "true"
toString()
method
All of the wrapper
classes have a no-arg, nonstatic, instance version of toString(). This method
returns a String with the value of the primitive wrapped in the object—
Double d = new Double("3.14");
System.out.println("d = " + d.toString() ); // result is "d = 3.14"
All of the numeric
wrapper classes provide an overloaded, static toString() method that takes a
primitive numeric of the appropriate type (Double.toString() takes a double), and,
of course, returns a String with that primitive’s value.
System.out.println("d = " + Double.toString(3.14); // result is "d = 3.14"
Integer and Long provide
a third toString() method. It is static, its first argument is the appropriate
primitive, and its second argument is a radix. The radix argument tells the
method to take the first argument (which is radix 10 or base 10 by default),
and convert it to the radix provided, then return the result as a String
System.out.println("hex = " + Long.toString(254,16); // result is "hex = fe"
toXxxString()
method(Binary, Hexadecimal, Octal)
The Integer and Long
wrapper classes let you convert numbers in base 10 to other bases. These
conversion methods, toXxxString(), take an int or long, and return a String
representation of the converted number,
String s3 = Integer.toHexString(254); // convert 254 to hex
System.out.println("254 in hex = " + s3); // result is "254 in hex = fe"
String s4 = Long.toOctalString(254); // convert 254 to octal
System.out.println("254 in octal = "+ s4); // result is "254 in octal = 376"
Quick review
- Java uses primitive types, such as
int, char, double to hold the basic data types supported by the language.
- Sometimes it is required to create
an object representation of these primitive types.
- These are collection classes that
deal only with such objects. One needs to wrap the primitive type in a
class.
- To satisfy this need, java
provides classes that correspond to each of the primitive types.
Basically, these classes encapsulate, or wrap, the primitive types within
a class.
- Thus, they are commonly referred
to as type wrapper. Type wrapper are classes that encapsulate a primitive
type within an object.
- The wrapper types are Byte, Short,
Integer, Long, Character, Boolean, Double, Float.
These classes offer a
wide array of methods that allow to fully integrate the primitive types into
Java’s object hierarchy.
Wrapper classes for converting simple types
Simple
Type
|
Wrapper
class
|
boolean
|
Boolean
|
char
|
Character
|
double
|
Double
|
float
|
Float
|
int
|
Integer
|
long
|
Long
|
Converting primitive numbers to Object numbers using constructor
methods
Constructor
calling
|
Conversion
Action
|
Integer IntVal = new Integer(i);
|
Primitive integer to Integer
object
|
Float FloatVal = new Float(f);
|
Primitive float to Float object
|
Double DoubleVal = new Double(d);
|
Primitive double to Double object
|
Long LongVal = new Long(l);
|
Primitive long to Long object
|
NOTE : I, f, d and l are primitive data values
denoting int, float, double and long data types. They may be constants or
variables.
Converting Object numbers to Primitive numbers using typeValue()
method
Method
calling
|
Conversion
Action
|
int i = IntVal.intValue();
|
Object to primitive integer
|
float f = FloatVal.floatValue();
|
Object to primitive float
|
double d =
DoubleVal.doubleValue();
|
Object to primitive double
|
long l = LongVal.longValue();
|
Object to primitive long
|
Converting Numbers to Strings using toString() method
Method
calling
|
Conversion
Action
|
str = Integer.toString(i);
|
Primitive integer i to String str
|
str = Float.toString(f);
|
Primitive float f to String
str
|
str = Double.toString(d);
|
Primitive double d to String str
|
str = Long.toString(l);
|
Primitive long l to String str
|
Converting String Object in to Numeric Object using static
method ValueOf()
Method
calling
|
Conversion
Action
|
IntVal = Integer.ValueOf(str);
|
Convert String into Integer object
|
FloatVal = Float.ValueOf(str);
|
Convert String into Float object
|
DoubleVal = Double.ValueOf(str);
|
Convert String into Double object
|
LongVal = Long.ValueOf(str);
|
Convert String into Long object
|
Converting Numeric Strings to Primitive numbers using Parsing
method
Method
calling
|
Conversion
Action
|
int i = Integer.parseInt(str);
|
Converts String str into primitive
integer i
|
long l = Long.parseLong(str);
|
Converts String str into primitive
long l
|
NOTE : parseInt()
and parseLong() methods throw a Number Format Exception if the value of the str
does not represent an integer.
Posts
