Course: Core Java Training
Topic: Understanding Reference Data Types
Course Link: Core Java Training Course
Demo Link: Register for a Course Demo
Website: JustAcademy Homepage
Java provides different data types for storing and working with information. These types are broadly categorized into primitive data types and reference data types. Primitive types store values such as integers, decimal numbers, characters, and boolean values. Reference types are used to refer to objects, arrays, and other instances created or provided by Java programs.
Reference data types are fundamental to object-oriented programming because they allow developers to work with classes, objects, strings, arrays, interfaces, and custom data structures.
For example, the variable age below has a primitive type, while name has a reference type:
int age = 25;
String name = "Rahul";
System.out.println(age);
System.out.println(name);The int variable stores an integer value directly. The String variable refers to a String object.
new keyword.A reference data type is a type whose variables can hold references to objects or arrays rather than storing the complete object value directly. These references allow a program to access object fields and methods or work with array elements.
Common reference types include:
Student, Employee, and Car.String class represents text.Java also provides many library classes, such as ArrayList, HashMap, and Scanner, which are reference types.
| Feature | Primitive Data Types | Reference Data Types |
|---|---|---|
| Examples | int, char, boolean, double |
String, arrays, classes, interfaces |
| What a variable holds | A primitive value | A reference to an object or array, or null |
| Methods and fields | Primitive values do not have object methods or instance fields | Objects can expose methods and fields according to their types and access rules |
| Can be null? | No | Yes, reference variables can contain null |
| Creation | Values can be assigned directly | Objects are often created with new, though some are created through literals, factories, or other mechanisms |
| Equality | == compares primitive values |
== compares reference identity; equals() may compare logical content |
| Default value for fields | Depends on the primitive type, such as 0 or false |
null |
Important: Local variables do not automatically receive default values. They must be initialized before they can be used. Default values apply to fields and array elements.
A class defines the structure and behavior of objects. An object is an instance of a class and may contain state represented by fields and behavior represented by methods.
Example:
class Student {
String name;
int age;
void displayDetails() {
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}
public class Main {
public static void main(String[] args) {
Student student = new Student();
student.name = "Amit";
student.age = 21;
student.displayDetails();
}
}Output:
Name: Amit
Age: 21Explanation:
Student is a class.student is a reference variable.new Student() creates a new Student object.student.name accesses the object's name field.displayDetails() invokes a method on the referenced object.A reference variable is declared using a reference type, followed by the variable name. It can then be assigned a compatible object reference.
General syntax:
ClassName variableName = new ClassName();Example:
String message = new String("Welcome to Java");
Student student = new Student();For strings, a literal is usually more convenient:
String message = "Welcome to Java";In this example, message refers to a String object. Java manages string literals through its string pool, so explicitly using new String(...) is generally unnecessary for ordinary text.
Class types define objects with fields, constructors, and methods. Developers can create their own classes to represent real-world or application-specific entities.
class Car {
String brand;
void start() {
System.out.println(brand + " is starting.");
}
}
public class Main {
public static void main(String[] args) {
Car car = new Car();
car.brand = "Toyota";
car.start();
}
}Output:
Toyota is starting.The String class represents a sequence of characters. Strings are reference types and are immutable, which means their content cannot be changed after a String object is created.
public class StringExample {
public static void main(String[] args) {
String firstName = "Rahul";
String lastName = "Sharma";
String fullName = firstName + " " + lastName;
System.out.println(fullName);
System.out.println(fullName.length());
}
}Output:
Rahul Sharma
12The concatenation expression creates the resulting string value. The original String objects remain unchanged.
An array is an object that stores a fixed number of elements of a specified component type. Arrays can contain primitive values or references to objects.
public class ArrayExample {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40};
for (int number : numbers) {
System.out.println(number);
}
}
}Output:
10
20
30
40The variable numbers refers to an array object. The array's length is fixed after creation, although its elements can be updated.
An interface defines a contract that implementing classes agree to provide. An interface reference can refer to an object of any compatible implementing class.
interface Animal {
void makeSound();
}
class Dog implements Animal {
public void makeSound() {
System.out.println("Dog barks");
}
}
public class InterfaceExample {
public static void main(String[] args) {
Animal animal = new Dog();
animal.makeSound();
}
}Output:
Dog barksThe variable animal has the interface type Animal, but it refers to a Dog object. This demonstrates polymorphism.
An enum defines a fixed set of named constants. Enum variables are reference variables that refer to enum constant instances.
enum Day {
MONDAY, TUESDAY, WEDNESDAY
}
public class EnumExample {
public static void main(String[] args) {
Day today = Day.MONDAY;
System.out.println(today);
}
}Output:
MONDAYRecords are reference types designed to represent data-oriented objects with a concise declaration. The Java compiler generates common methods such as accessors, equals(), hashCode(), and toString().
record Employee(String name, int id) {}
public class RecordExample {
public static void main(String[] args) {
Employee employee = new Employee("Neha", 101);
System.out.println(employee.name());
System.out.println(employee.id());
}
}Output:
Neha
101Records are available in modern Java releases. Use a Java version that supports records when compiling this example.
The new keyword is commonly used to create objects and arrays. For class instances, it invokes a constructor and produces a reference to the newly created object.
Student student = new Student();This statement can be understood as follows:
Student identifies the reference type.student is the variable that will hold the reference.new Student() creates and initializes a new Student object by invoking its constructor.student.Not all reference values require an explicit new expression. String literals, enum constants, factory methods, and references returned by methods are common examples.
The special literal null represents the absence of an object reference. A reference variable can be assigned null when it does not currently refer to an object.
public class NullExample {
public static void main(String[] args) {
String name = null;
if (name == null) {
System.out.println("Name is not assigned.");
}
}
}Output:
Name is not assigned.Attempting to call an instance method through a null reference causes a NullPointerException.
String name = null;
System.out.println(name.length()); // Throws NullPointerExceptionCheck a reference before calling methods on it when it may be null. Avoid assuming that every reference variable refers to a valid object.
When one reference variable is assigned to another, the object itself is not automatically copied. Both variables may refer to the same object.
class Box {
int value;
}
public class ReferenceAssignment {
public static void main(String[] args) {
Box first = new Box();
first.value = 10;
Box second = first;
second.value = 50;
System.out.println(first.value);
System.out.println(second.value);
}
}Output:
50
50Both variables refer to the same Box object. Changing its value through second is visible when accessing the object through first.
Java always passes arguments by value. When an object reference is passed to a method, the value of the reference is copied into the parameter. The parameter and the original variable can then refer to the same object.
class Counter {
int count;
}
public class MethodReferenceExample {
static void increase(Counter counter) {
counter.count++;
}
public static void main(String[] args) {
Counter counter = new Counter();
counter.count = 5;
increase(counter);
System.out.println(counter.count);
}
}Output:
6The method changes the object's field, so the change is visible to the caller. However, assigning a different object to the method parameter does not replace the caller's reference variable.
For reference types, the == operator checks whether two references identify the same object. The equals() method can check logical equality when the class implements it appropriately.
public class EqualityExample {
public static void main(String[] args) {
String first = new String("Java");
String second = new String("Java");
System.out.println(first == second);
System.out.println(first.equals(second));
}
}Output:
false
trueThe two String objects have the same content, but they are distinct objects. Therefore, == returns false, while equals() returns true.
For custom classes, the default implementation of equals() inherited from Object compares object identity. A class must override or otherwise implement equals() to provide value-based equality.
Wrapper classes represent primitive values as objects. Common examples include Integer, Double, Character, and Boolean.
| Primitive Type | Wrapper Class |
|---|---|
byte |
Byte |
short |
Short |
int |
Integer |
long |
Long |
float |
Float |
double |
Double |
char |
Character |
boolean |
Boolean |
public class WrapperExample {
public static void main(String[] args) {
int number = 100;
Integer referenceNumber = number; // Autoboxing
int anotherNumber = referenceNumber; // Unboxing
System.out.println(referenceNumber);
System.out.println(anotherNumber);
}
}Output:
100
100Autoboxing converts a primitive value to its corresponding wrapper object when required. Unboxing extracts the primitive value from a wrapper object. Unboxing a null wrapper reference causes a NullPointerException.
| Mistake | Why It Happens | How to Avoid It |
|---|---|---|
Calling a method on null |
The reference does not identify an object. | Check for null or use an appropriate null-handling design. |
Using == to compare String content |
== checks reference identity. |
Use equals() for content comparison. |
| Assuming assignment copies an object | Reference assignment copies the reference value. | Use an appropriate copy constructor, factory, or copying strategy when a separate object is required. |
| Accessing an invalid array index | The index falls outside the array's valid range. | Check that the index is between 0 and length - 1. |
| Unboxing a null wrapper | A null reference does not contain a wrapper object to unbox. | Validate wrapper values before unboxing. |
| Assuming every reference type is mutable | Some reference types, such as String, are immutable. |
Understand whether the specific class permits its state to change. |
equals() for logical equality when supported by the type.Create a Student class with fields for name, age, and course. Create an object, assign values, and print the student's details.
Create two String objects containing the same text. Compare them using both == and equals(), then explain the difference in the output.
Create a class named Book with a title field. Assign one reference variable to another and modify the title through the second variable. Observe the first variable's result.
Create a String variable initialized to null. Write a safe conditional check before calling any instance method on it.
Create an interface with one method and implement it in two classes. Use the interface type to refer to objects of both classes and demonstrate polymorphism.
Convert an int to an Integer using autoboxing and convert it back to an int. Explain why wrapper objects are useful in generic collections.
Answer: A reference data type identifies objects or arrays. Variables of these types hold references to objects or arrays, or may contain null.
Answer: Primitive variables hold primitive values, while reference variables hold references to objects or arrays. Reference variables can be null, whereas primitive variables cannot.
Answer: String is a reference type because it is a Java class.
Answer: It is commonly used to create class instances and arrays. For class instances, it invokes a constructor and produces a reference to the created object.
Answer: It is a special literal that represents the absence of an object reference.
Answer: It is an exception commonly caused by attempting an operation that requires an object through a null reference.
Answer: For reference variables, == checks whether the references identify the same object. equals() can compare logical equality, depending on the class implementation.
Answer: The reference value is copied. Both variables may refer to the same object, so changes to that object's mutable state can be observed through either reference.
Answer: Yes. Arrays are objects, and an array variable holds a reference to an array instance.
Answer: Wrapper classes, such as Integer and Double, represent primitive values as objects.
Answer: No. Java always passes arguments by value. When an object reference is passed, the method receives a copy of the reference value.
Answer: A superclass or interface reference can refer to an object of a compatible subclass or implementing class, allowing the appropriate overridden method to execute at runtime.
new.null.Build a strong Java programming foundation by studying data types, variables, classes, objects, methods, inheritance, interfaces, exception handling, collections, and other essential Core Java concepts.
Explore the course: Core Java Training Course
Register for a demo: Register for a Course Demo
Visit the website: JustAcademy Homepage
Reference data types are essential to Java because they allow programs to represent objects, arrays, strings, and custom data structures. Understanding references, object creation, null values, equality, method parameters, and wrapper classes helps developers write safer and more maintainable programs. Practice the examples and exercises in this guide to strengthen your Core Java fundamentals.
