wrapper classes

10/02/13 RENAISSANCE SOFTLABS (P) LTD. 2
Problem with Primitives
 Java is an object-oriented language. Means, everything in
Java is an object
 But, how about primitives?
 Primitives cannot participate in the object activities, such as
 Returned from a method as an object
 Adding to a Collection of objects
 As a solution to this problem, Java allows you to include the
primitives in the family of objects by using Wrapper classes

Creating Wrapper Classes
 For to each primitive data type in Java there is
corresponding wrapper class
 This class encapsulates a single value for the primitive
data type
 The wrapper object of a wrapper class can be created
in one of two ways:
 By instantiating the wrapper class with the new operator
 By invoking a static method on the wrapper class

Primitive Types and Wrapper Classes

Creating Wrapper Classes with new Operator
 Obviously, you can always pass the corresponding primitive data
type as an argument to a wrapper class constructor
 You can also pass a String as an argument to any wrapper class
constructor except Character
 The Character constructor only takes the obvious argument: char
 You can pass double as an argument to the Float constructor but
not vice versa
 All the wrapper classes except Boolean and Character are
subclasses of an abstract class called Number
 Boolean and Character are derived directly from the Object class

Another way of Creating Wrappers
 The wrapped value in a wrapper class cannot be modified
 To wrap another value, you need to create another object
 Wrappers are immutable
 There will be situations in your program when you really don’t
need a new instance of the wrapper class
 but you still want to wrap a primitive
 In this case, use the static method valueOf()

Using Static Method valueOf()

 The valueOf() method in the Character class accepts only
char as an argument
 Any other wrapper class will accept either the corresponding
primitive type or String as an argument
 The valueOf() method in the integer number wrapper classes
(Byte, Short, Integer, and Long) also accepts two arguments
together:
 A String
 A radix, where radix is the base
 For example, a decimal is radix 10 and a binary is radix 2
Using Static Method valueOf()

 A storage capability without the retrieval capability is not of much use
 Once we store a primitive in a wrapper object, often you will want to
retrieve the stored primitive at a later time
 All the number wrapper classes (Byte, Short, Integer, Long, Float, and
Double) have the which can retrieve byte, short, int, long, float, or
double
 This is because all of these classes are subclasses of the Number
class
 It means you can store one primitive type in a wrapper and retrieve
another one
 So you can use the wrappers as a conversion machine
Extracting Wrapped Values

Methods to extract values

 We can use Wrappers for converting the type without
creating the Wrapper
 There is an appropriate static method in every 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)
 Ex: static int parseInt (String s)
 Each of these methods parses the string passed in as a
parameter and returns the corresponding primitive type
Instant use of Wrapper Classes

Methods to Convert Strings to Primitives

 Wrapper classes are used for two main purposes
 To store a primitive type in an object so that it can participate in
object-like operations
 To convert one primitive type into another
 However, as we have seen, you do this conversion between
primitives and objects manually
 If Java is a truly object-oriented language, why do we have to
manually wrap the primitives into objects
 why is the process not made automated? Well, that is exactly what
autoboxing offers
Wrapper Classes

 Boxing and unboxing make using wrapper classes more convenient
 In the old, pre-Java 5 days, if you wanted to make a wrapper, unwrap it,
use it, and then rewrap it, you might do something like this:
Integer y = new Integer(567); // make it
int x = y.intValue(); // unwrap it
x++; // use it
y = new Integer(x); // re-wrap it
System.out.println("y = " + i); // print it
 Now, with new and improved Java 5 you can say
Integer y = new Integer(567); // make it
y++; // unwrap it, increment it,
// rewrap it
System.out.println("y = " + i); // print it
Boxing and Unboxing

 The Intention of the equals() method is to determine whether
two instances of a given class are "meaningfully equivalent"
 This definition is intentionally subjective
 it's up to the creator of the class to determine what
"equivalent" means for objects of the class
 For all wrapper classes, two objects are equal if they are of
the same type and have the same value
Boxing, == and .equals()

 Widening, Var-Args and Auto-Boxing make method overloadig a
little tricky
 When a class has overloaded methods, the compiler's jobs is to
determine which method to use whenever it finds an invocation for
the overloaded method
Auto-Boxing and Overloading

class AddBoxing
{
static void go(Integer x)
{
System.out.println("Integer");
}
static void go(long x)
{
System.out.println("long");
}
public static void main(String [] args)
{
int i = 5;
go(i); // which go() will be invoked?
}
}
Overloading with Boxing and Widening

class AddVarargs
{
static void go(int x, int y)
{
System.out.println("int,int");
}
static void go(byte... x)
{
System.out.println("byte... ");
}
public static void main(String[] args)
{
byte b = 5;
go(b,b); // which go() will be invoked?
}
}
Overloading with Var-Args and Widening

 Even though each invocation will require some sort of
conversion, the compiler will choose the older style
before it chooses the newer style
 This keeps the existing code more robust.
 So far we've seen that
 Widening beats boxing
 Widening beats var-args
 Does does boxing beat var-args?
Reason

class BoxOrVararg
{
static void go(Byte x, Byte y)
{
System.out.println("Byte, Byte");
}
static void go(byte... x)
{
System.out.println("byte... ");
}
public static void main(String [] args)
{
byte b = 5;
go(b,b); // which go() will be invoked?
}
}
Overloading with Var-Args and Boxing

wrapper classes

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie wrapper classes

Ähnlich wie wrapper classes (20)

Mehr von Rajesh Roky

Mehr von Rajesh Roky (8)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

wrapper classes