Java Programming (4343203) - Practicals

// Practical01.java - Basic Java program demonstrating output methods

public class Practical01 {
    public static void main(String[] args) {
        System.out.println("Demonstrating Different Output Methods in Java:\n");
        
        // 1. Using println() - prints and moves to next line
        System.out.println("1. Using println():");
        System.out.println("Hello, World!");
        System.out.println("This is a new line");
        System.out.println();
        
        // 2. Using print() - prints without moving to next line
        System.out.println("2. Using print():");
        System.out.print("Hello ");
        System.out.print("World ");
        System.out.print("without line breaks");
        System.out.println("\n");
        
        // 3. Using printf() - formatted output
        System.out.println("3. Using printf():");
        String name = "Student";
        int age = 20;
        double height = 5.9;
        System.out.printf("Name: %s, Age: %d, Height: %.1f feet%n", name, age, height);
        System.out.println();
        
        // 4. Demonstrating escape sequences
        System.out.println("4. Using Escape Sequences:");
        System.out.println("Using tab:\tAfter tab");
        System.out.println("Using new line:\nAfter new line");
        System.out.println("Using single quote: \'Hello\'");
        System.out.println("Using double quote: \"World\"");
        System.out.println("Using backslash: \\");
    }
}

// Practical02.java - Find maximum of three numbers using conditional operator

import java.util.Scanner;

public class Practical02 {
    // Method to find maximum using conditional operator
    public static int findMax(int a, int b, int c) {
        return (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c);
    }
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("Program to Find Maximum of Three Numbers:\n");
        
        // 1. Using hardcoded values
        System.out.println("1. Testing with hardcoded values:");
        int x = 25, y = 45, z = 15;
        System.out.printf("Numbers are: %d, %d, %d%n", x, y, z);
        System.out.println("Maximum number is: " + findMax(x, y, z));
        System.out.println();
        
        // 2. Taking user input
        System.out.println("2. Testing with user input:");
        System.out.print("Enter first number: ");
        int num1 = scanner.nextInt();
        
        System.out.print("Enter second number: ");
        int num2 = scanner.nextInt();
        
        System.out.print("Enter third number: ");
        int num3 = scanner.nextInt();
        
        int max = findMax(num1, num2, num3);
        System.out.printf("Maximum number among %d, %d and %d is: %d%n", 
                         num1, num2, num3, max);
        
        // 3. Additional test cases
        System.out.println("\n3. Testing with special cases:");
        
        // When all numbers are same
        System.out.println("When all numbers are same:");
        System.out.println("Max of (5, 5, 5): " + findMax(5, 5, 5));
        
        // When two numbers are same
        System.out.println("When two numbers are same:");
        System.out.println("Max of (7, 7, 3): " + findMax(7, 7, 3));
        
        // With negative numbers
        System.out.println("With negative numbers:");
        System.out.println("Max of (-5, -2, -8): " + findMax(-5, -2, -8));
        
        scanner.close();
    }
}

// Practical03.java - Reverse digits of a number using while loop

import java.util.Scanner;

public class Practical03 {
    // Method to reverse digits of a number
    public static int reverseNumber(int num) {
        int reversed = 0;
        boolean isNegative = num < 0;
        num = Math.abs(num);
        
        while (num > 0) {
            int digit = num % 10;
            reversed = reversed * 10 + digit;
            num /= 10;
        }
        
        return isNegative ? -reversed : reversed;
    }
    
    // Method to display the reversal process
    public static void showReversalProcess(int num) {
        System.out.println("\nReversal Process:");
        int temp = Math.abs(num);
        System.out.print("Digits extracted: ");
        
        // Store digits in array for proper display order
        int[] digits = new int[10];  // Assuming number won't exceed 10 digits
        int count = 0;
        
        while (temp > 0) {
            digits[count++] = temp % 10;
            temp /= 10;
        }
        
        // Display digits in order of extraction
        for (int i = 0; i < count; i++) {
            System.out.print(digits[i]);
            if (i < count - 1) {
                System.out.print(", ");
            }
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("Program to Reverse Digits of a Number:\n");
        
        // 1. Using hardcoded values
        System.out.println("1. Testing with hardcoded values:");
        int[] testNumbers = {12345, -9876, 1000, 7};
        
        for (int num : testNumbers) {
            System.out.println("\nOriginal number: " + num);
            showReversalProcess(num);
            System.out.println("Reversed number: " + reverseNumber(num));
        }
        
        // 2. Taking user input
        System.out.println("\n2. Testing with user input:");
        System.out.print("Enter a number to reverse: ");
        int userNum = scanner.nextInt();
        
        System.out.println("Original number: " + userNum);
        showReversalProcess(userNum);
        System.out.println("Reversed number: " + reverseNumber(userNum));
        
        // 3. Special cases demonstration
        System.out.println("\n3. Special cases:");
        
        // Number ending with zeros
        int numWithZeros = 12000;
        System.out.println("\nNumber ending with zeros: " + numWithZeros);
        showReversalProcess(numWithZeros);
        System.out.println("Reversed number: " + reverseNumber(numWithZeros));
        
        // Single digit number
        int singleDigit = 5;
        System.out.println("\nSingle digit number: " + singleDigit);
        showReversalProcess(singleDigit);
        System.out.println("Reversed number: " + reverseNumber(singleDigit));
        
        scanner.close();
    }
}

// Practical04.java - Add two 3x3 matrices

import java.util.Scanner;

public class Practical04 {
    // Method to input matrix elements
    public static void inputMatrix(int[][] matrix, Scanner scanner, String matrixName) {
        System.out.println("Enter elements for " + matrixName + " (3x3):");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.printf("Enter element [%d][%d]: ", i, j);
                matrix[i][j] = scanner.nextInt();
            }
        }
        System.out.println();
    }
    
    // Method to display matrix
    public static void displayMatrix(int[][] matrix, String matrixName) {
        System.out.println(matrixName + ":");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.printf("%4d ", matrix[i][j]);
            }
            System.out.println();
        }
        System.out.println();
    }
    
    // Method to add two matrices
    public static int[][] addMatrices(int[][] matrix1, int[][] matrix2) {
        int[][] result = new int[3][3];
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                result[i][j] = matrix1[i][j] + matrix2[i][j];
            }
        }
        return result;
    }
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("Program to Add Two 3x3 Matrices:\n");
        
        // 1. Using hardcoded matrices
        System.out.println("1. Testing with hardcoded matrices:");
        int[][] matrix1 = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        int[][] matrix2 = {
            {9, 8, 7},
            {6, 5, 4},
            {3, 2, 1}
        };
        
        displayMatrix(matrix1, "First Matrix");
        displayMatrix(matrix2, "Second Matrix");
        
        int[][] result1 = addMatrices(matrix1, matrix2);
        displayMatrix(result1, "Result Matrix (Hardcoded)");
        
        // 2. Taking user input
        System.out.println("2. Testing with user input:");
        int[][] userMatrix1 = new int[3][3];
        int[][] userMatrix2 = new int[3][3];
        
        inputMatrix(userMatrix1, scanner, "First Matrix");
        inputMatrix(userMatrix2, scanner, "Second Matrix");
        
        System.out.println("Entered matrices:");
        displayMatrix(userMatrix1, "First Matrix");
        displayMatrix(userMatrix2, "Second Matrix");
        
        int[][] result2 = addMatrices(userMatrix1, userMatrix2);
        displayMatrix(result2, "Result Matrix (User Input)");
        
        // 3. Special case demonstration
        System.out.println("3. Special case - Adding zero matrix:");
        int[][] zeroMatrix = new int[3][3];  // All elements are 0 by default
        
        displayMatrix(matrix1, "Original Matrix");
        displayMatrix(zeroMatrix, "Zero Matrix");
        
        int[][] result3 = addMatrices(matrix1, zeroMatrix);
        displayMatrix(result3, "Result Matrix (Adding Zero Matrix)");
        
        scanner.close();
    }
}

// Practical05.java - Generate first n prime numbers

import java.util.Scanner;

public class Practical05 {
    // Method to check if a number is prime
    public static boolean isPrime(int number) {
        if (number < 2) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(number); i++) {
            if (number % i == 0) {
                return false;
            }
        }
        return true;
    }
    
    // Method to generate first n prime numbers
    public static void generatePrimes(int n) {
        if (n <= 0) {
            System.out.println("Please enter a positive number.");
            return;
        }
        
        System.out.println("First " + n + " prime numbers are:");
        int count = 0;
        int number = 2;
        
        while (count < n) {
            if (isPrime(number)) {
                System.out.print(number);
                count++;
                
                // Add formatting
                if (count < n) {
                    System.out.print(", ");
                }
                if (count % 10 == 0) {
                    System.out.println();
                }
            }
            number++;
        }
        System.out.println();
    }
    
    // Method to show prime checking process
    public static void demonstratePrimeCheck(int number) {
        System.out.printf("\nChecking if %d is prime:%n", number);
        if (number < 2) {
            System.out.println(number + " is not prime (less than 2)");
            return;
        }
        
        for (int i = 2; i <= Math.sqrt(number); i++) {
            System.out.printf("Checking divisibility by %d: ", i);
            if (number % i == 0) {
                System.out.printf("%d is divisible by %d, so it's not prime%n", number, i);
                return;
            }
            System.out.println("Not divisible");
        }
        System.out.println(number + " is prime");
    }
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("Program to Generate First N Prime Numbers:\n");
        
        // 1. Using hardcoded value
        System.out.println("1. Testing with hardcoded value (n=10):");
        generatePrimes(10);
        
        // 2. Demonstrate prime checking process
        System.out.println("\n2. Demonstrating prime checking process:");
        int[] testNumbers = {7, 12, 23, 35};
        for (int num : testNumbers) {
            demonstratePrimeCheck(num);
        }
        
        // 3. Taking user input
        System.out.println("\n3. Testing with user input:");
        System.out.print("Enter how many prime numbers you want to generate: ");
        int n = scanner.nextInt();
        generatePrimes(n);
        
        // 4. Handle special cases
        System.out.println("\n4. Testing special cases:");
        System.out.println("Generating 0 prime numbers:");
        generatePrimes(0);
        
        System.out.println("\nGenerating 1 prime number:");
        generatePrimes(1);
        
        scanner.close();
    }
}

// Practical06.java - Create Student class and demonstrate object creation

class Student {
    private String enrollmentNo;
    private String name;
    
    // Constructor
    public Student(String enrollmentNo, String name) {
        this.enrollmentNo = enrollmentNo;
        this.name = name;
    }
    
    // Getter methods
    public String getEnrollmentNo() {
        return enrollmentNo;
    }
    
    public String getName() {
        return name;
    }
    
    // Setter methods
    public void setEnrollmentNo(String enrollmentNo) {
        this.enrollmentNo = enrollmentNo;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    // Method to display student details
    public void displayDetails() {
        System.out.println("Student Details:");
        System.out.println("Enrollment No: " + enrollmentNo);
        System.out.println("Name: " + name);
        System.out.println();
    }
}

public class Practical06 {
    public static void main(String[] args) {
        System.out.println("Demonstrating Student Class and Objects:\n");
        
        // 1. Creating three student objects
        System.out.println("1. Creating and displaying three students:");
        Student student1 = new Student("A101", "John Smith");
        Student student2 = new Student("A102", "Emma Watson");
        Student student3 = new Student("A103", "Michael Johnson");
        
        // Display student information
        student1.displayDetails();
        student2.displayDetails();
        student3.displayDetails();
        
        // 2. Demonstrating getter methods
        System.out.println("2. Using getter methods:");
        System.out.println("Student 1:");
        System.out.println("Enrollment No: " + student1.getEnrollmentNo());
        System.out.println("Name: " + student1.getName());
        System.out.println();
        
        // 3. Demonstrating setter methods
        System.out.println("3. Using setter methods to update student details:");
        System.out.println("Updating student2's information:");
        student2.setName("Emma Thompson");
        System.out.println("After update:");
        student2.displayDetails();
        
        // 4. Creating array of students
        System.out.println("4. Working with array of students:");
        Student[] students = {
            new Student("B101", "Alice Brown"),
            new Student("B102", "Bob Wilson"),
            new Student("B103", "Carol White")
        };
        
        System.out.println("Displaying all students in array:");
        for (Student student : students) {
            student.displayDetails();
        }
    }
}

// Practical07.java - Rectangle class with constructor initialization

class Rectangle {
    private double height;
    private double width;
    
    // Default constructor
    public Rectangle() {
        this.height = 0.0;
        this.width = 0.0;
    }
    
    // Parameterized constructor
    public Rectangle(double height, double width) {
        this.height = height;
        this.width = width;
    }
    
    // Copy constructor
    public Rectangle(Rectangle other) {
        this.height = other.height;
        this.width = other.width;
    }
    
    // Getter methods
    public double getHeight() {
        return height;
    }
    
    public double getWidth() {
        return width;
    }
    
    // Setter methods
    public void setHeight(double height) {
        this.height = height;
    }
    
    public void setWidth(double width) {
        this.width = width;
    }
    
    // Method to calculate area
    public double calculateArea() {
        return height * width;
    }
    
    // Method to calculate perimeter
    public double calculatePerimeter() {
        return 2 * (height + width);
    }
    
    // Method to display rectangle details
    public void displayDetails() {
        System.out.println("Rectangle Details:");
        System.out.printf("Height: %.2f units%n", height);
        System.out.printf("Width: %.2f units%n", width);
        System.out.printf("Area: %.2f square units%n", calculateArea());
        System.out.printf("Perimeter: %.2f units%n", calculatePerimeter());
        System.out.println();
    }
}

public class Practical07 {
    public static void main(String[] args) {
        System.out.println("Demonstrating Rectangle Class with Constructors:\n");
        
        // 1. Using default constructor
        System.out.println("1. Creating rectangle using default constructor:");
        Rectangle rect1 = new Rectangle();
        rect1.displayDetails();
        
        // 2. Using parameterized constructor
        System.out.println("2. Creating rectangle using parameterized constructor:");
        Rectangle rect2 = new Rectangle(5.0, 3.0);
        rect2.displayDetails();
        
        // 3. Using copy constructor
        System.out.println("3. Creating rectangle using copy constructor:");
        Rectangle rect3 = new Rectangle(rect2);
        System.out.println("Copied rectangle details:");
        rect3.displayDetails();
        
        // 4. Demonstrating setter methods
        System.out.println("4. Using setter methods:");
        rect1.setHeight(4.0);
        rect1.setWidth(6.0);
        System.out.println("After setting new dimensions:");
        rect1.displayDetails();
        
        // 5. Demonstrating getter methods
        System.out.println("5. Using getter methods:");
        System.out.printf("Rectangle 2 height: %.2f units%n", rect2.getHeight());
        System.out.printf("Rectangle 2 width: %.2f units%n", rect2.getWidth());
        System.out.println();
        
        // 6. Array of rectangles
        System.out.println("6. Working with array of rectangles:");
        Rectangle[] rectangles = {
            new Rectangle(2.0, 3.0),
            new Rectangle(4.0, 4.0),
            new Rectangle(3.0, 5.0)
        };
        
        System.out.println("Details of all rectangles:");
        for (Rectangle rect : rectangles) {
            rect.displayDetails();
        }
        
        // 7. Find rectangle with largest area
        System.out.println("7. Finding rectangle with largest area:");
        Rectangle maxAreaRect = rectangles[0];
        for (Rectangle rect : rectangles) {
            if (rect.calculateArea() > maxAreaRect.calculateArea()) {
                maxAreaRect = rect;
            }
        }
        System.out.println("Rectangle with largest area:");
        maxAreaRect.displayDetails();
    }
}

// Practical08.java - Demonstrate use of 'this' keyword

public class Practical08 {
    private int number;
    private String text;
    
    // Constructor using 'this' to distinguish parameters from instance variables
    public Practical08(int number, String text) {
        this.number = number;
        this.text = text;
    }
    
    // Method using 'this' to call another method of current object
    public void display() {
        System.out.println("Number: " + this.number);
        System.out.println("Text: " + this.text);
        this.showMore();  // Using 'this' to call another method
    }
    
    // Method using 'this' to pass current object as parameter
    public void showMore() {
        System.out.println("Demonstrating method call using 'this'");
        this.processObject(this);  // Passing current object as parameter
    }
    
    // Method accepting object of same class as parameter
    public void processObject(Practical08 obj) {
        System.out.println("Processing object with number: " + obj.number);
    }
    
    // Method returning current object using 'this'
    public Practical08 updateNumber(int number) {
        this.number = number;
        return this;  // Method chaining by returning current object
    }
    
    public static void main(String[] args) {
        System.out.println("Demonstrating the use of 'this' keyword:\n");
        
        // Creating object and demonstrating various uses of 'this'
        Practical08 obj = new Practical08(42, "Hello");
        
        System.out.println("Initial object state:");
        obj.display();
        
        System.out.println("\nDemonstrating method chaining using 'this':");
        obj.updateNumber(100).display();
        
        // Creating another object to show constructor usage of 'this'
        System.out.println("\nCreating another object:");
        Practical08 obj2 = new Practical08(99, "World");
        obj2.display();
    }
}

// Practical09.java - Demonstrate use of 'static' keyword

public class Practical09 {
    // Static variable
    private static int instanceCount = 0;
    
    // Non-static variables
    private int id;
    private String name;
    
    // Static constant
    private static final String COLLEGE_NAME = "My College";
    
    // Static block - executed when class is loaded
    static {
        System.out.println("Static block executed - Class loading...");
        System.out.println("College Name: " + COLLEGE_NAME);
    }
    
    // Constructor
    public Practical09(String name) {
        this.id = ++instanceCount;
        this.name = name;
    }
    
    // Static method
    public static int getInstanceCount() {
        return instanceCount;
    }
    
    // Static method to display college info
    public static void displayCollegeInfo() {
        System.out.println("College Name: " + COLLEGE_NAME);
        System.out.println("Total Students: " + getInstanceCount());
    }
    
    // Non-static method
    public void displayStudentInfo() {
        System.out.println("Student ID: " + this.id);
        System.out.println("Student Name: " + this.name);
        System.out.println("College: " + COLLEGE_NAME);  // Static variable accessed in non-static method
    }
    
    public static void main(String[] args) {
        System.out.println("Demonstrating static keyword usage:\n");
        
        // Accessing static method before creating any object
        System.out.println("Initial instance count: " + Practical09.getInstanceCount());
        
        // Creating objects and demonstrating static variable
        System.out.println("\nCreating student objects:");
        Practical09 student1 = new Practical09("John");
        Practical09 student2 = new Practical09("Emma");
        Practical09 student3 = new Practical09("Michael");
        
        // Displaying individual student information
        System.out.println("\nStudent Information:");
        student1.displayStudentInfo();
        System.out.println();
        student2.displayStudentInfo();
        System.out.println();
        student3.displayStudentInfo();
        
        // Displaying college information using static method
        System.out.println("\nCollege Information:");
        Practical09.displayCollegeInfo();
        
        // Demonstrating that static variable is shared
        System.out.println("\nFinal instance count: " + Practical09.getInstanceCount());
    }
}

// Practical10.java - Demonstrate use of 'final' keyword

// Final class - cannot be inherited
final class FinalClass {
    public void display() {
        System.out.println("This class cannot be inherited");
    }
}

class Parent {
    // Final method - cannot be overridden
    final void showMessage() {
        System.out.println("This method cannot be overridden");
    }
}

class Child extends Parent {
    // This would cause error if uncommented:
    // void showMessage() { } // Cannot override final method
    
    void displayChild() {
        System.out.println("Child class calling parent's final method:");
        showMessage();
    }
}

public class Practical10 {
    // Final variable - must be initialized and cannot be changed
    private final int MAX_VALUE = 100;
    
    // Final reference variable
    private final StringBuilder builder = new StringBuilder();
    
    // Final static constant
    private static final double PI = 3.14159;
    
    // Blank final variable - must be initialized in constructor
    private final String message;
    
    // Constructor to initialize final variable
    public Practical10(String msg) {
        this.message = msg;  // Initializing blank final variable
    }
    
    public void demonstrateFinal() {
        // This would cause error:
        // MAX_VALUE = 200; // Cannot modify final variable
        
        // Can modify object state even though reference is final
        builder.append("Hello ");
        builder.append("World");
        
        System.out.println("Final variable MAX_VALUE: " + MAX_VALUE);
        System.out.println("Final StringBuilder content: " + builder.toString());
        System.out.println("Final static PI: " + PI);
        System.out.println("Final message: " + message);
    }
    
    public static void main(String[] args) {
        System.out.println("Demonstrating final keyword usage:\n");
        
        // Demonstrating final variables
        Practical10 obj = new Practical10("This is a final message");
        obj.demonstrateFinal();
        
        // Demonstrating final class
        System.out.println("\nDemonstrating final class:");
        FinalClass finalObj = new FinalClass();
        finalObj.display();
        
        // Demonstrating final method
        System.out.println("\nDemonstrating final method:");
        Child child = new Child();
        child.displayChild();
        
        // Demonstrating final parameter in lambda expression
        System.out.println("\nDemonstrating final parameter in lambda:");
        Runnable run = () -> {
            final String param = "Hello";
            System.out.println("Parameter cannot be modified: " + param);
        };
        run.run();
        
        // Demonstrating final local variable
        final int number = 100;
        System.out.println("\nFinal local variable: " + number);
        // This would cause error:
        // number = 200; // Cannot modify final variable
    }
}

// Practical11.java - Demonstrate method overloading with Shape class

public class Practical11 {
    // Class to demonstrate method overloading
    public class Shape {
        // Method to calculate area of circle
        public float area(float radius) {
            return (float) (Math.PI * radius * radius);
        }
        
        // Overloaded method to calculate area of rectangle
        public float area(float length, float width) {
            return length * width;
        }
        
        // Additional overloaded methods to show more variations
        public float area(int radius) {
            // Overloaded method with different parameter type
            return (float) (Math.PI * radius * radius);
        }
        
        public double area(double radius) {
            // Overloaded method with different return type
            return Math.PI * radius * radius;
        }
        
        public float area(float base, float height, String shape) {
            // Overloaded method for triangle if shape is "triangle"
            if (shape.equalsIgnoreCase("triangle")) {
                return 0.5f * base * height;
            }
            return 0; // Return 0 for invalid shape
        }
    }
    
    public static void main(String[] args) {
        Practical11 practical = new Practical11();
        Shape shape = practical.new Shape();
        
        // Test values
        float radius = 5.0f;
        float length = 6.0f;
        float width = 4.0f;
        float base = 8.0f;
        float height = 3.0f;
        
        System.out.println("Demonstrating Method Overloading:\n");
        
        // Calculate and display area of circle using float parameter
        System.out.println("Area of Circle (float radius = " + radius + "):");
        System.out.printf("%.2f square units\n\n", shape.area(radius));
        
        // Calculate and display area of rectangle
        System.out.println("Area of Rectangle (length = " + length + ", width = " + width + "):");
        System.out.printf("%.2f square units\n\n", shape.area(length, width));
        
        // Calculate and display area of circle using int parameter
        System.out.println("Area of Circle (int radius = 5):");
        System.out.printf("%.2f square units\n\n", shape.area(5));
        
        // Calculate and display area of circle using double parameter
        System.out.println("Area of Circle (double radius = 5.0):");
        System.out.printf("%.2f square units\n\n", shape.area(5.0));
        
        // Calculate and display area of triangle
        System.out.println("Area of Triangle (base = " + base + ", height = " + height + "):");
        System.out.printf("%.2f square units\n\n", shape.area(base, height, "triangle"));
        
        // Demonstrate method selection based on parameter type
        System.out.println("Demonstrating automatic method selection based on parameter type:");
        System.out.println("Calling area(5.0f) - selects float version: " + shape.area(5.0f));
        System.out.println("Calling area(5) - selects int version: " + shape.area(5));
        System.out.println("Calling area(5.0) - selects double version: " + shape.area(5.0));
    }
}