Section 1.1: Automatic Type Promotion in Arithmetic Operations

One significant trap involves automatic type promotion during arithmetic operations. When performing calculations with smaller data types, such as byte or short, Java automatically promotes these to int. This can lead to unexpected compilation errors if not properly managed.

public class AutoTypePromotion {

public static void main(String[] args) {

byte b1 = 10;

byte b2 = 20;

// This will cause a compilation error because b1 + b2 results in an int.

byte b3 = (byte) (b1 + b2); // Explicit cast back to byte is required

System.out.println(b3);

}

}

Section 1.2: Distinction Between Size and Capacity in Containers

Another common mistake is confusing size with capacity when working with containers like ArrayList. Size refers to the number of elements currently in the list, while capacity indicates how many elements the list can hold before it needs to resize. Misunderstanding this distinction can lead to unexpected behavior.

import java.util.ArrayList;

import java.util.List;

public class ListSizeCapacity {

public static void main(String[] args) {

List<Integer> list = new ArrayList<>(5); // Initial capacity is 5

System.out.println("Initial size: " + list.size()); // Outputs 0

for (int i = 1; i <= 6; i++) {

list.add(i);

}

System.out.println("Size after adding elements: " + list.size()); // Outputs 6

}

}

Section 1.3: String Pool and Object Comparison

Java utilizes a string pool for string literals, which means that identical literals point to the same object. However, strings created using new String() do not get pooled, potentially leading to confusion when using == for comparison.

public class StringPool {

public static void main(String[] args) {

String s1 = "Java";

String s2 = "Java";

String s3 = new String("Java");

System.out.println(s1 == s2); // true, as s1 and s2 refer to the same object in the pool

System.out.println(s1 == s3); // false, as s3 refers to a new object on the heap

}

}

Section 1.4: Default Constructor Behavior

Java automatically provides a no-argument constructor unless a custom constructor is defined. Once you create any constructor, the default constructor is no longer available.

public class ConstructorBehavior {

private int value;

// A constructor with parameters is defined

public ConstructorBehavior(int value) {

this.value = value;

}

// Explicitly defining a no-argument constructor

public ConstructorBehavior() {

this.value = 0;

}

}

Section 1.5: Generics Invariance

Generics in Java exhibit invariance, meaning that a List<Dog> is not a subtype of List<Animal> even if Dog is a subtype of Animal. This can lead to complications when trying to use collections interchangeably.