Java is a powerful object-oriented programming language where everything revolves around classes and objects. In Java, a class defines the blueprint for creating objects, and the wrapper classes serve as means for one to work with primitive data types as objects. Understanding the concepts allows for writing efficient, scalable Java programs.

This blog explores Java's classes, objects, wrapper classes, and their significance in Java programming.

1. What is a Class in Java?

A class in Java is a blueprint or template that defines the properties (variables) and behaviors (methods) of an object. It provides structure to the program by encapsulating related data and functionalities.

Defining a Class in Java

A class is declared using the class keyword. 

java
class Car {
    String brand;
    int speed;

    void accelerate() {
        System.out.println(brand + " is accelerating.");
    }
}

In this example, Car is a class with two attributes (brand and speed) and a method (accelerate()).

2. What is an Object in Java?

An object is an instance of a class. It represents a real-world entity and has state (data) and behavior (methods).

Creating an Object in Java

To create an object, we use the new keyword.

java
public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
myCar.brand = "Toyota";
        myCar.speed = 120;
        myCar.accelerate(); 
    }
}

Output: 


Toyota is accelerating.

Here, myCar is an object of the Car class.

3. Types of Classes in Java

Java supports different types of classes:

1. Regular Class

A regular class with member variables and methods.

java
class Animal {
    String name;
}

2. Abstract Class

An abstract class cannot be instantiated and might include abstract methods (methods without implementation).

java
abstract class Shape {
    abstract void draw();  //
}

3. Interface

An interface is a contract that defines methods that a class must implement.

java
interface Vehicle {
void start();
}

4. Anonymous Class

A class without a name that is instantiated at runtime. 

java
Vehicle bike = new Vehicle() {
    public void start() {
        System.out.println("Bike started!");
    }
};

4. What are Wrapper Classes in Java?

Java provides wrapper classes that allow primitive data types (int, char, double, etc.) to be used as objects.

Primitive Type Wrapper Class
int Integer
char Character
double Double
float Float
long Long
short Short
byte Byte
boolean Boolean

Why Use Wrapper Classes?

  • They allow primitive values to be stored in collections like ArrayList.
  • Provide utility methods for data conversion and manipulation.
  • Support autoboxing and unboxing (automatic conversion between primitive types and objects).

Example of Wrapper Class Usage

java
public class WrapperExample {
public static void main(String[] args) {
        Integer num = Integer.valueOf(10); // Boxing
        int value = num.intValue();        // Unboxing

        System.out.println("Value: " + value);
    }
}

5. Autoboxing and Unboxing in Java

Autoboxing (Primitive → Wrapper Object)

Autoboxing is the automatic conversion of a primitive type into its wrapper class object. 

java
Integer num = 10; // Auto-converts int to Integer

Unboxing (Wrapper Object → Primitive)

Unboxing is the automatic conversion of a wrapper object back to its primitive type. 

java
int value = num; // Auto-converts Integer to int

Example of Autoboxing and Unboxing

java
public class AutoUnboxExample {
    public static void main(String[] args) {
        Integer num = 50; // Autoboxing
        int val = num;    // Unboxing
        System.out.println("Value: " + val);
    }
}

6. Useful Methods in Wrapper Classes

Wrapper classes provide several utility methods: 

java
public class WrapperMethods {
    public static void main(String[] args) {
        String str = "123";
        int num = Integer.parseInt(str); // Converts String to int
        System.out.println("Parsed Number: " + num);

Integer val = Integer.valueOf(42);
        System.out.println("Integer Value: " + val);
    }
}

7. Differences Between Primitive Types and Wrapper Classes

Feature Primitive Types Wrapper Classes
Storage Stores actual values Stores objects
------------ -------------------- --------------
Performance Faster Slower (due to object overhead)
Nullability Cannot be null Can be null
Used in Collections No Yes

8. Real-World Example: Using Wrapper Classes in Collections

Since collections like ArrayList can't store primitive types, it makes use of wrapper classes.

java
import java.util.ArrayList;

public class WrapperInCollection {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(10); // Autoboxing (int → Integer)
        numbers.add(20);
        numbers.add(30);

int sum = numbers.get(0) + numbers.get(1); // Unboxing (Integer → int)
        System.out.println("Sum: " + sum);
    }
}

Conclusion

Java's classes and wrapper classes play a fundamental role in structuring applications and managing data efficiently.

  • Classes define objects and encapsulate data and behavior.
  • Wrapper classes allow the use of primitive types as objects, which makes them eligible to be stored in collections and utilized with utility methods. - Autoboxing and unboxing facilitate the conversion from primitives to objects and vice versa, which gives Java a higher degree of flexibility.

This knowledge is very helpful in the development of well-optimized, readable, and scalable Java applications.

Comments(0)