Core Java Concepts and Syntax

Understanding Wrapper Class in Java

Board Infinity
Board Infinity
Understanding Wrapper Class in Java

    Java Programs: Know the Best Java Programs for Beginners

    Interesting Java Project Ideas For Beginners

    OOPs Concepts In Java

    Abstraction Vs Encapsulation in Java

    Understanding Overloading in Java

    Understanding Singleton Class in Java

    Understanding Multiple Inheritance in Java

    Learn about Generics in Java

    A quick guide to Access Modifiers in Java

    Understanding Polymorphism in Java

    Understanding the LifeCycle of an Applet in Java

    What is Composition in Java?

    Understanding Servlets in Java

    Understanding Java Comparator Interface

    Learn about Map Stream in Java

    Understanding Wrapper Class in Java

    Learn about JVM in Java

    Understand HashSet in Java

    Learn how to do Pyramid Pattern printing in Java

    Learn about Thread Sleep Method in Java

    Learn about Throw and Throws in Java

    Introduction to StringBuffer in Java

    What is Immutable Class in Java?

    Introduction to Static Keyword in JAVA

    How to sort a list in Java?

    Print Fibonacci Series in JAVA

    Understanding Anonymous Inner Class in JAVA

    Learn to Create an Array of Objects in Java

    Types of Variables in Java

    Learn about Java List

    Classes and Objects in Java

    Abstraction in Java

    Constructor Overloading in Java

    Method Signature In Java

    Method Overloading And Overriding In Java

Introduction

Java provides us with a wrapper class in which objects wrap up or contain primitive data types. When an object of a wrapper class is created, it has fields that accommodate primitive data types. In simple words, we can say that an object of the wrapper class can wrap primitive values.

Why do we need a wrapper class?

  • A wrapper class can convert primitive data types into objects.
  • The Java.util class can handle only objects and therefore wrapper class can be helpful in this scenario also.
  • The collection framework provides data structures like Arraylist and Vector that can store only objects.
  • Objects must support synchronization in multithreading.

Concept of autoboxing and unboxing:

Let us understand the meaning of autoboxing and unboxing in Java:

Autoboxing

It is defined as the automatic conversion of primitive data types into objects of the corresponding wrapper classes. For example, int to Integer, double to Double, etc.

Let us consider the program below:

Source Code:

import java.util.ArrayList;
class HelloWorld {
    public static void main(String[] args) {
        double myValue = 10.05;
 
        // Autoboxing primitive double to Double object conversion
        Double myValueEquivalent = myValue;
 
        ArrayList<Integer> myArrayList = new ArrayList<Integer>();
 
        // Autoboxing because ArrayList stores only objects
        myArrayList.add(25);
        myArrayList.add(50);
        myArrayList.add(75);
        myArrayList.add(100);
       
        // printing the values from object
        System.out.println(myArrayList);
    }
}

Output:

Unboxing

Unboxing is defined as the reverse process of autoboxing. It automatically converts an object of a wrapper class to its primitive type equivalent. For example, conversion of double to Double, etc.

Now let us consider the program below:

Source Code

import java.util.ArrayList;
class HelloWorld {
    public static void main(String[] args) {
       
        // Declaring an arraylist of Integer type
        ArrayList<Integer> myArrayList = new ArrayList<Integer>();
 
        // Autoboxing because ArrayList stores only objects
        myArrayList.add(25);
        myArrayList.add(50);
        myArrayList.add(75);
        myArrayList.add(100);

        int myNumber = myArrayList.get(3);
       
        // Print the number
        System.out.println(myNumber);
    }
}

Output:

Custom wrapper class in Java

The java wrapper class is responsible for wrapping out the primitive data types. Previously, we discussed inbuilt wrapper classes. Now we will see how we can create a custom wrapper class in Java.

Source Code:

/*

    Creating a custom wrapper class

*/

class wrapperClass{ 
   
    // Creating a private data member of
    // Integer type
    private int data;
   
    // Declaring constructors
    wrapperClass(){} 
    wrapperClass(int data){ 
    this.data=data; 
    } 
   
    // Defining getter and setter
    // methods
    public void setter(int data){ 
    this.data=data; 
    }
    public int getter(){ 
    return data; 
    } 
    @Override 
    public String toString() { 
      return Integer.toString(data); 
    } 
} 

class HelloWorld {
    public static void main(String[] args) {
       
        // Creating an object of the wrapper class
        wrapperClass object1 = new wrapperClass(100); 
        wrapperClass object2 = new wrapperClass(200);
        wrapperClass object3 = new wrapperClass(300);
       
       
        // Print objects
        System.out.println(object1);
        System.out.println(object2);
        System.out.println(object3);
    }
}

write your code here: Coding Playground

Output:

Output description:

As you can see in the output, we have wrapped three integer values by creating a custom wrapper class.

Conclusion

In this article, we studied wrapper classes in Java. I hope this article will help you to improve your knowledge in the field of Java.