Java Programming Fundamentals and Core Concepts

Posted on May 23, 2026 in Computer Engineering in Information Technologies Engineering

Java Arrays of Objects

The following example demonstrates how to create an array of objects using a Groceries class to manage item data.

public class Groceries {
    int itemId;
    String itemName;
    double price;

    void display() {
        System.out.println("Item ID: " + itemId + ", Item Name: " + itemName + ", Price: " + price);
    }

    public static void main(String[] args) {
        // Array of objects
        Groceries[] items = new Groceries[3];

        // Create objects
        items[0] = new Groceries();
        items[1] = new Groceries();
        items[2] = new Groceries();

        // Assign values
        items[0].itemId = 1;
        items[0].itemName = "Rice";
        items[0].price = 60.50;

        items[1].itemId = 2;
        items[1].itemName = "Sugar";
        items[1].price = 45.00;

        items[2].itemId = 3;
        items[2].itemName = "Oil";
        items[2].price = 150.75;

        // Display output
        for (int i = 0; i < items.length; i++) {
            items[i].display();
        }
    }
}

String Manipulation in Java

This StringDemo class showcases various built-in methods available in the Java String class for text processing.

public class StringDemo {
    public static void main(String[] args) {
        // String creation
        String str1 = "Hello World";
        String str2 = "Java Programming";

        System.out.println("String 1: " + str1);
        System.out.println("String 2: " + str2);
        System.out.println("Length of String 1: " + str1.length());
        System.out.println("Uppercase: " + str1.toUpperCase());
        System.out.println("Lowercase: " + str1.toLowerCase());
        System.out.println("Character at index 1: " + str1.charAt(1));

        String str3 = str1.concat(" ").concat(str2);
        System.out.println("Concatenated String: " + str3);
        System.out.println("Equals: " + str1.equals(str2));
        System.out.println("Equals Ignore Case: " + str1.equalsIgnoreCase("hello world"));
        System.out.println("Substring (0 to 5): " + str1.substring(0, 5));
        System.out.println("Replace 'World' with 'Java': " + str1.replace("World", "Java"));
        System.out.println("Contains 'Java': " + str2.contains("Java"));

        // Trim spaces
        String str4 = " Welcome to Java ";
        System.out.println("Before trim: '" + str4 + "'");
        System.out.println("After trim: '" + str4.trim() + "'");
    }
}

Java Constructors and Overloading

Constructors are used to initialize objects. This example demonstrates default and parameterized constructors.

class Student {
    int id;
    String name;
    int age;

    // Default Constructor
    Student() {
        id = 0;
        name = "Unknown";
        age = 0;
    }

    // Parameterized Constructor (2 arguments)
    Student(int id, String name) {
        this.id = id;
        this.name = name;
        this.age = 0;
    }

    // Parameterized Constructor (3 arguments)
    Student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    void display() {
        System.out.println("ID: " + id + ", Name: " + name + ", Age: " + age);
    }
}

public class ConstructorDemo {
    public static void main(String[] args) {
        Student s1 = new Student(); // Default constructor
        Student s2 = new Student(101, "Ram"); // 2-arg constructor
        Student s3 = new Student(102, "Sita", 20); // 3-arg constructor

        s1.display();
        s2.display();
        s3.display();
    }
}

Instance Methods and Data Handling

Instance methods are used to define the behavior of an object. Here, we use setValues and getValues.

class StudentInstance {
    int id;
    String name;

    void setValues(int id, String name) {
        this.id = id;
        this.name = name;
    }

    void getValues() {
        System.out.println("ID: " + id);
        System.out.println("Name: " + name);
    }
}

public class InstanceMethodDemo {
    public static void main(String[] args) {
        StudentInstance s1 = new StudentInstance();
        s1.setValues(101, "Vamsi");
        s1.getValues();
    }
}

Dynamic Method Invocation and Polymorphism

This section illustrates method overriding and dynamic method invocation (runtime polymorphism).

class Calculator {
    void calculate(int a, int b) {
        System.out.println("Calculator sum: " + (a + b));
    }

    void calculate(double a, double b) {
        System.out.println("Calculator sum (double): " + (a + b));
    }
}

class AdvancedCalculator extends Calculator {
    @Override
    void calculate(int a, int b) {
        System.out.println("AdvancedCalculator product: " + (a * b));
    }

    void calculate(int a, int b, int c) {
        System.out.println("AdvancedCalculator sum of three numbers: " + (a + b + c));
    }
}

public class DynamicMethodInvocationDemo {
    public static void main(String[] args) {
        // Base class reference pointing to derived class object
        Calculator calc = new AdvancedCalculator();
        
        // Dynamic method invocation (resolved at runtime)
        calc.calculate(5, 3);

        // Overloaded method (resolved at compile time)
        calc.calculate(2.5, 3.5);

        // Accessing derived-class-specific overloaded method
        AdvancedCalculator advCalc = new AdvancedCalculator();
        advCalc.calculate(1, 2, 3);
    }
}

Summary of Dynamic Invocation

• Reference: Calculator calc = new AdvancedCalculator();
• Execution: calc.calculate(5, 3); calls the overridden method in the subclass.

Java Wrapper Classes and Autoboxing

Wrapper classes provide a way to use primitive data types as objects. This includes autoboxing and unboxing.

class WrapperExample {
    public static void main(String[] args) {
        // Converting primitive to object (Autoboxing)
        int a = 10;
        Integer obj = Integer.valueOf(a);

        // Converting object to primitive (Unboxing)
        int b = obj.intValue();

        System.out.println("Primitive value: " + a);
        System.out.println("Wrapper object: " + obj);
        System.out.println("Unboxed value: " + b);

        // Wrapper class utility methods
        String str = "123";
        int num = Integer.parseInt(str);
        System.out.println("String to Integer: " + num);

        double d = Double.valueOf("45.67");
        System.out.println("String to Double: " + d);

        char ch = 'A';
        boolean result = Character.isLetter(ch);
        System.out.println("Is letter: " + result);
    }
}