Unit 2: Data Types, Variables & Wrapper Classes

Opening Hook — The Data Behind Every Rupee

Learning Outcomes — Bloom's Taxonomy Mapped (12 Outcomes)

Concept Explanation — Data Types, Variables & Wrapper Classes from Scratch

1. The 8 Primitive Data Types

Java is a strongly typed language — every variable must have a declared type before you use it. Think of data types as different-sized containers in your kitchen. You don't store rice in a teacup (too small) or water in a thali (wrong shape). Similarly, Java gives you exactly 8 primitive "containers," each designed for a specific kind of data.

Java
// Real-world data types in action — Paytm-style payment record
byte paymentMode = 2;              // 1=UPI, 2=Wallet, 3=Card
short bankCode = 1234;             // IFSC prefix number
int transactionAmount = 500;       // ₹500 payment
long txnId = 20260623143052001L;   // Unique transaction ID
float cashbackPercent = 2.5f;      // 2.5% cashback
double walletBalance = 2347.50;    // Precise wallet balance
char currency = '₹';               // Indian Rupee symbol (Unicode)
boolean isSuccess = true;          // Payment successful?

2. Type Conversion — Widening & Narrowing

Sometimes you need to store a value of one type into a variable of another type. Java handles this in two ways:

Java
int salary = 500000;
double doubleSalary = salary;   // Automatic: int → double
System.out.println(doubleSalary); // 500000.0

char ch = 'A';
int ascii = ch;                  // Automatic: char → int
System.out.println(ascii);       // 65

Java
double price = 999.99;
int roundedPrice = (int) price;   // Explicit cast: double → int
System.out.println(roundedPrice);  // 999 (decimal part LOST!)

int bigNumber = 130;
byte small = (byte) bigNumber;    // Explicit cast: int → byte
System.out.println(small);         // -126 (overflow!)

3. All 53 Java Keywords

Keywords are reserved words that Java has claimed for its own syntax. You cannot use them as variable names, class names, or method names. Think of them as "government-reserved land" — you can't build your house on it.

Identifiers & Naming Conventions

An identifier is any name you give to a class, method, variable, or label. Rules:

• Can contain letters (A-Z, a-z), digits (0-9), underscore (_), and dollar sign ($)
• Cannot start with a digit
• Cannot be a keyword
• Case-sensitive: salary ≠ Salary ≠ SALARY

4. Variables — Local, Instance & Static

A variable is a named memory location that holds a value. Java has three types of variables, each with different scope (where it's visible) and lifetime (how long it exists).

Java
public class PaytmAccount {
    // Instance variable — each user has their own
    double balance = 0.0;
    String userName;

    // Static variable — shared across ALL accounts
    static int totalAccounts = 0;
    static final double GST_RATE = 0.18;

    public void deposit(double amount) {
        // Local variable — exists only inside this method
        double gst = amount * GST_RATE;
        double net = amount - gst;
        balance += net;
        System.out.println("Deposited ₹" + net);
    }
}

5. Access Modifiers — public, private, protected, default

Access modifiers control who can see and use your classes, methods, and variables. Think of them as security levels at an office building:

Java
public class BankAccount {
    public String bankName = "SBI";            // Anyone can see
    protected String branch = "Connaught Place"; // Same package + subclasses
    String ifscCode = "SBIN0001234";            // Default — same package only
    private double balance = 50000.0;           // Only this class

    public double getBalance() {               // Getter — controlled access
        return balance;
    }
}

6. The static Keyword — 5 Uses

The static keyword means "belongs to the class, not to any specific object." Think of it as a college notice board — it belongs to the college (class), not to any individual student (object).

Java
public class RazorpayTransaction {
    static int totalTransactions = 0;  // 1. Static variable

    static {                              // 3. Static block — runs once when class loads
        System.out.println("Razorpay SDK initialized");
    }

    String orderId;
    double amount;

    RazorpayTransaction(String id, double amt) {
        this.orderId = id;
        this.amount = amt;
        totalTransactions++;              // Shared across all objects
    }

    static int getTotalTransactions() {  // 2. Static method
        return totalTransactions;
    }
}

7. Wrapper Classes — Integer, Double, Character, Boolean

The Big Bazaar Analogy: You buy a gift — say a nice pen. The pen itself is the primitive value. But if you're giving it as a Diwali gift, you wrap it in a decorative box with a ribbon. The wrapper makes it presentable, giftable, and "object-like." That's exactly what Wrapper classes do — they wrap primitive values into objects.

Autoboxing & Unboxing (Java 5+)

Autoboxing = Java automatically wraps a primitive into its Wrapper object.
Unboxing = Java automatically unwraps a Wrapper object back to its primitive.

Java
// AUTOBOXING: primitive → Wrapper (automatic)
int amount = 500;
Integer wrappedAmount = amount;   // int → Integer (autoboxing)

// UNBOXING: Wrapper → primitive (automatic)
Integer price = Integer.valueOf(999);
int rawPrice = price;             // Integer → int (unboxing)

// PARSING: String → primitive
String userInput = "1500";
int rupees = Integer.parseInt(userInput);  // String → int

// TOSTRING: primitive → String
double balance = 2347.50;
String display = Double.toString(balance);  // double → String "2347.5"

// Using Wrappers in Collections
ArrayList<Integer> cart = new ArrayList<>();
cart.add(299);   // autoboxing: int → Integer
cart.add(599);
int first = cart.get(0);  // unboxing: Integer → int

Important Wrapper Class Utility Methods

Java
// Integer utilities
System.out.println(Integer.MAX_VALUE);   // 2147483647
System.out.println(Integer.MIN_VALUE);   // -2147483648
System.out.println(Integer.toBinaryString(10));  // "1010"
System.out.println(Integer.toHexString(255));    // "ff"
System.out.println(Integer.toOctalString(8));    // "10"

// Character utilities
System.out.println(Character.isDigit('9'));       // true
System.out.println(Character.isLetter('A'));      // true
System.out.println(Character.toUpperCase('a'));   // 'A'
System.out.println(Character.isWhitespace(' '));  // true

// Boolean utilities
System.out.println(Boolean.parseBoolean("true"));   // true
System.out.println(Boolean.parseBoolean("yes"));    // false (only "true" works)

Learn by Doing — 3-Tier Lab: Currency Converter INR ↔ USD/EUR/GBP

Java
import java.util.Scanner;

public class CurrencyConverter {
    // Static constants — exchange rates (as of June 2026)
    static final double USD_RATE = 83.50;  // 1 USD = ₹83.50
    static final double EUR_RATE = 91.20;  // 1 EUR = ₹91.20
    static final double GBP_RATE = 106.75; // 1 GBP = ₹106.75

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("=== INR Currency Converter ===");
        System.out.print("Enter amount in INR: ₹");

        // Parse user input using Wrapper class method
        String input = sc.nextLine();
        double inr = Double.parseDouble(input);

        // Type conversion: double → int (narrowing)
        int roundedINR = (int) inr;

        // Calculate conversions
        double usd = inr / USD_RATE;
        double eur = inr / EUR_RATE;
        double gbp = inr / GBP_RATE;

        // Display using Wrapper toString()
        System.out.println("\n--- Conversion Results ---");
        System.out.println("₹" + Double.toString(inr) + " = $"
            + String.format("%.2f", usd) + " USD");
        System.out.println("₹" + roundedINR + " = €"
            + String.format("%.2f", eur) + " EUR");
        System.out.println("₹" + roundedINR + " = £"
            + String.format("%.2f", gbp) + " GBP");

        // Boolean check
        boolean isLargeAmount = inr > 100000;
        System.out.println("Large transaction: " +
            Boolean.toString(isLargeAmount));

        sc.close();
    }
}

Terminal
javac CurrencyConverter.java
java CurrencyConverter

Java
// Hint 1: Parse menu choice
int choice = Integer.parseInt(sc.nextLine());

// Hint 2: Static conversion methods
static double inrToUsd(double inr) {
    return inr / USD_RATE;
}

// Hint 3: Error handling
try {
    double amount = Double.parseDouble(input);
} catch (NumberFormatException e) {
    System.out.println("Invalid input! Enter a number.");
}

Problem Set — Syntax, Programming, Industry & Interview Questions

Syntax Questions (5)

1. Identify and fix the error: float temperature = 36.6;
2. What is the output? System.out.println((int) 99.99);
3. Identify and fix the error: int 2ndPlace = 2;
4. What is the output? char ch = 'A'; System.out.println(ch + 1);
5. Will this compile? byte b = 128; — Explain why or why not.

Programming Questions (8)

1. Write a Java program to find the size of all 8 primitive data types using their Wrapper class constants (e.g., Integer.SIZE, Byte.SIZE).
2. Write a program that accepts a temperature in Fahrenheit (as a String), converts it to Celsius using Double.parseDouble(), and displays the result rounded to 2 decimal places.
3. Create a program that demonstrates widening conversion for all paths: byte → short → int → long → float → double.
4. Write a program that takes a character input and prints whether it is a digit, letter, uppercase, lowercase, or whitespace using Character class methods.
5. Build a simple GST Calculator: input price as String, parse to double, calculate 18% GST, display base price, GST amount, and total.
6. Write a program that demonstrates the difference between Integer.parseInt() and Integer.valueOf() by showing their return types.
7. Create a program with a class Student having: private instance variables (name, rollNo), a static variable (college name), and a static method to display total students.
8. Write a program that converts an integer to binary, octal, and hexadecimal using Integer wrapper methods.

Industry Questions (3)

1. Paytm Scenario: Paytm stores wallet balance as double. Why not float? Calculate the precision difference when storing ₹99,99,999.99 in both types.
2. Aadhaar Scenario: UIDAI stores Aadhaar numbers. A junior developer used int. Explain why this fails and what type should be used. What about leading zeros — should it be a String?
3. Razorpay Scenario: Razorpay processes payments in paise (₹500.00 = 50000 paise) to avoid floating-point errors. Discuss why int in paise is better than double in rupees for financial applications.

Interview Questions (3)

1. TCS favourite: What is the difference between autoboxing and unboxing? Give an example where autoboxing can cause a NullPointerException.
2. Infosys favourite: Can we call a non-static method from a static method? Why or why not? How would you solve this?
3. Wipro favourite: Explain the output: Integer a = 127; Integer b = 127; System.out.println(a == b); and Integer c = 128; Integer d = 128; System.out.println(c == d);

MCQ Assessment Bank — 30 Questions (Bloom's Mapped)

Remember / Identify (Q1–Q5)

Understand / Explain (Q6–Q10)

Apply / Use (Q11–Q15)

Analyze / Compare (Q16–Q20)

Evaluate / Justify (Q21–Q25)

Create / Design (Q26–Q30)

Short Answer Questions (8 Questions)

Long Answer Questions (3 Questions)

Java
Integer x = 42;  // compiler converts to Integer.valueOf(42)
ArrayList<Double> prices = new ArrayList<>();
prices.add(99.99);  // double autoboxed to Double

Java
Integer obj = Integer.valueOf(100);
int val = obj;  // Integer unboxed to int

Java
public class BankAccount {
    static int totalAccounts = 0;           // 1. Static variable
    static { System.out.println("Bank system initialized"); }  // 3. Static block
    private String holder;
    private double balance;
    BankAccount(String name) { holder = name; totalAccounts++; }
    static int getTotalAccounts() { return totalAccounts; } // 2. Static method
}

Lab Programs — Additional Practice

The primary lab for this unit is the Currency Converter covered in Section D (3-Tier Labs). Additional practice programs are included in the Problem Set (Section E). Focus on completing all three tiers of the currency converter lab before moving to the next unit.

Industry Spotlight — A Day in the Life

Earn With It — Currency Converter Widgets & Freelance Income

⏱️ Time to First Earning: 2–4 weeks (complete all 3 lab tiers, push to GitHub, create Fiverr/Internshala gig)

Chapter Summary & Code Tweet

📱 Code Tweet (< 280 chars)

Earning Checkpoint — What You've Mastered

✅ Unit 2 complete. MCQs: 30. Ready for Unit 3!

[QR: Link to EduArtha video tutorial — Java Data Types & Wrapper Classes]