Java Programming (4343203) - Winter 2024 Solution

// Documentation comment
/**
 * Simple program to demonstrate Java structure
 * @author GTU Student
 */

// Package declaration
package com.example;

// Import statements
import java.util.Scanner;

// Class declaration
public class HelloWorld {
    // Variable declaration
    private String message;
    
    // Constructor
    public HelloWorld() {
        message = "Hello, World!";
    }
    
    // Method
    public void displayMessage() {
        System.out.println(message);
    }
    
    // Main method
    public static void main(String[] args) {
        HelloWorld obj = new HelloWorld();
        obj.displayMessage();
    }
}

public class ArithmeticDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;
        
        // Addition
        int sum = a + b;
        
        // Multiplication
        int product = a * b;
        
        // Modulus
        int remainder = a % b;
        
        // Display results
        System.out.println("Values: a = " + a + ", b = " + b);
        System.out.println("Addition (a + b): " + sum);
        System.out.println("Multiplication (a * b): " + product);
        System.out.println("Modulus (a % b): " + remainder);
    }
}

public class PrimeNumbers {
    public static void main(String[] args) {
        System.out.println("Prime numbers between 1 and 10:");
        
        // Check each number from 1 to 10
        for (int num = 1; num <= 10; num++) {
            boolean isPrime = true;
            
            // Check if num is divisible by any number from 2 to num-1
            if (num > 1) {
                for (int i = 2; i < num; i++) {
                    if (num % i == 0) {
                        isPrime = false;
                        break;
                    }
                }
                
                // Print if prime
                if (isPrime) {
                    System.out.print(num + " ");
                }
            }
        }
    }
}

public class Counter {
    // Static variable shared by all objects
    static int count = 0;
    
    // Instance variable unique to each object
    int instanceCount = 0;
    
    // Constructor
    Counter() {
        count++;         // Increments the shared count
        instanceCount++; // Increments this object's count
    }
    
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();
        
        System.out.println("Static count: " + Counter.count);
        System.out.println("c1's instance count: " + c1.instanceCount);
        System.out.println("c2's instance count: " + c2.instanceCount);
        System.out.println("c3's instance count: " + c3.instanceCount);
    }
}

public class Student {
    // Instance variables
    private String name;
    private int age;
    private String course;
    
    // Parameterized constructor
    public Student(String name, int age, String course) {
        this.name = name;
        this.age = age;
        this.course = course;
    }
    
    // Method to display student details
    public void displayDetails() {
        System.out.println("Student Details:");
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Course: " + course);
    }
    
    // Main method for demonstration
    public static void main(String[] args) {
        // Creating object using parameterized constructor
        Student student1 = new Student("John", 20, "Computer Science");
        student1.displayDetails();
        
        // Another student
        Student student2 = new Student("Lisa", 22, "Engineering");
        student2.displayDetails();
    }
}

public class Person {
    // Private data - hidden from outside
    private String name;
    private int age;
    
    // Public methods - interface to access data
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void setAge(int age) {
        // Validation ensures data integrity
        if (age > 0 && age < 120) {
            this.age = age;
        } else {
            System.out.println("Invalid age");
        }
    }
    
    public int getAge() {
        return age;
    }
}

public class FinalDemo {
    // Final variable (constant)
    final int MAX_SPEED = 120;
    
    // Final method cannot be overridden
    final void showLimit() {
        System.out.println("Speed limit: " + MAX_SPEED);
    }
    
    public static void main(String[] args) {
        FinalDemo car = new FinalDemo();
        car.showLimit();
        
        // This would cause compile error:
        // car.MAX_SPEED = 150;
    }
}

// Final class cannot be extended
final class MathUtil {
    public int square(int num) {
        return num * num;
    }
}

// This would cause compile error:
// class AdvancedMath extends MathUtil { }

// File: PublicDemo.java
package com.example;

// Public class accessible from anywhere
public class PublicDemo {
    // Public variable accessible from anywhere
    public String message = "Hello, World!";
    
    // Public method accessible from anywhere
    public void displayMessage() {
        System.out.println(message);
    }
}

// File: Main.java
package com.test;

// Importing from different package
import com.example.PublicDemo;

public class Main {
    public static void main(String[] args) {
        // Creating object of class from different package
        PublicDemo demo = new PublicDemo();
        
        // Accessing public variable from different package
        System.out.println("Message: " + demo.message);
        
        // Calling public method from different package
        demo.displayMessage();
        
        // Modifying public variable from different package
        demo.message = "Modified message";
        demo.displayMessage();
    }
}

// Parent class
class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + " is eating");
    }
}

// Child class inheriting from Animal
class Dog extends Animal {
    private String breed;
    
    public Dog(String name, String breed) {
        super(name);  // Call parent constructor
        this.breed = breed;
    }
    
    public void bark() {
        System.out.println(name + " is barking");
    }
    
    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Breed: " + breed);
    }
}

// Main class
public class InheritanceDemo {
    public static void main(String[] args) {
        Dog dog = new Dog("Max", "Labrador");
        dog.displayInfo();
        dog.eat();     // Inherited method
        dog.bark();    // Own method
    }
}

public class StringBufferMethodsDemo {
    public static void main(String[] args) {
        // Create StringBuffer
        StringBuffer sb = new StringBuffer("Hello");
        System.out.println("Original: " + sb);
        
        // append() method - adds text at the end
        sb.append(" World");
        System.out.println("After append(): " + sb);
        
        // Can append different data types
        sb.append('!');
        sb.append(2024);
        System.out.println("After appending more: " + sb);
        
        // Reset for demonstration
        sb = new StringBuffer("Java");
        System.out.println("\nNew Original: " + sb);
        
        // insert() method - adds text at specified position
        sb.insert(0, "Learn ");
        System.out.println("After insert() at beginning: " + sb);
        
        sb.insert(10, " Programming");
        System.out.println("After insert() in middle: " + sb);
    }
}

// First interface
interface Printable {
    void print();
}

// Second interface
interface Scannable {
    void scan();
}

// Class implementing multiple interfaces
class Device implements Printable, Scannable {
    private String model;
    
    public Device(String model) {
        this.model = model;
    }
    
    // Implementation of print() method from Printable
    @Override
    public void print() {
        System.out.println(model + " is printing a document");
    }
    
    // Implementation of scan() method from Scannable
    @Override
    public void scan() {
        System.out.println(model + " is scanning a document");
    }
    
    // Class's own method
    public void getModel() {
        System.out.println("Device Model: " + model);
    }
}

// Main class
public class MultipleInheritanceDemo {
    public static void main(String[] args) {
        Device device = new Device("HP LaserJet");
        
        // Display model
        device.getModel();
        
        // Using methods from multiple interfaces
        device.print();
        device.scan();
        
        // Checking if device is an instance of interfaces
        System.out.println("Is device Printable? " + (device instanceof Printable));
        System.out.println("Is device Scannable? " + (device instanceof Scannable));
    }
}

public class StringMethodsDemo {
    public static void main(String[] args) {
        String message = "Java Programming";
        
        // substring() method
        // Extract "Java" (index 0 to 3)
        String sub1 = message.substring(0, 4);
        System.out.println("substring(0, 4): " + sub1);
        
        // Extract "Programming" (index 5 to end)
        String sub2 = message.substring(5);
        System.out.println("substring(5): " + sub2);
        
        // equals() method
        String str1 = "Hello";
        String str2 = "Hello";
        String str3 = "hello";
        String str4 = new String("Hello");
        
        System.out.println("\nComparing strings with equals():");
        System.out.println("str1.equals(str2): " + str1.equals(str2));  // true
        System.out.println("str1.equals(str3): " + str1.equals(str3));  // false
        System.out.println("str1.equals(str4): " + str1.equals(str4));  // true
        
        System.out.println("\nComparing strings with ==:");
        System.out.println("str1 == str2: " + (str1 == str2));  // true
        System.out.println("str1 == str4: " + (str1 == str4));  // false
    }
}

// Step 1: Declare package at the top (save as Calculator.java)
package com.example.math;

// The Calculator class
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public int subtract(int a, int b) {
        return a - b;
    }
    
    public int multiply(int a, int b) {
        return a * b;
    }
    
    public double divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("Cannot divide by zero");
        }
        return (double) a / b;
    }
}

// Step 1: Declare package (save as CalculatorApp.java)
package com.example.app;

// Import the package
import com.example.math.Calculator;

public class CalculatorApp {
    public static void main(String[] args) {
        // Using the Calculator class from the package
        Calculator calc = new Calculator();
        
        System.out.println("Addition: " + calc.add(10, 5));
        System.out.println("Subtraction: " + calc.subtract(10, 5));
        System.out.println("Multiplication: " + calc.multiply(10, 5));
        System.out.println("Division: " + calc.divide(10, 5));
    }
}

public class TryCatchDemo {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30};
        
        try {
            // Try to access an element outside array bounds
            System.out.println("Trying to access element 5: " + numbers[4]);
            
            // This code will not be executed if exception occurs
            System.out.println("This won't be printed");
        } 
        catch (ArrayIndexOutOfBoundsException e) {
            // Handle the specific exception
            System.out.println("Exception caught: " + e.getMessage());
            System.out.println("Array index out of bounds");
        }
        catch (Exception e) {
            // Handle any other exceptions
            System.out.println("General exception caught: " + e.getMessage());
        }
        finally {
            // This block always executes
            System.out.println("Finally block executed");
        }
        
        // Program continues execution
        System.out.println("Program continues after exception handling");
    }
}

// Parent class
class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
    
    public void eat() {
        System.out.println("Animal eats food");
    }
}

// Child class overriding methods
class Dog extends Animal {
    // Method overriding
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
    
    @Override
    public void eat() {
        System.out.println("Dog eats meat");
    }
}

// Another child class with different overrides
class Cat extends Animal {
    // Method overriding
    @Override
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

// Main class to demonstrate method overriding
public class MethodOverridingDemo {
    public static void main(String[] args) {
        // Parent class reference and object
        Animal animal = new Animal();
        
        // Child class references and objects
        Animal dog = new Dog();
        Animal cat = new Cat();
        
        // Demonstrating method overriding behavior
        System.out.println("Animal behavior:");
        animal.makeSound();
        animal.eat();
        
        System.out.println("\nDog behavior:");
        dog.makeSound();  // Calls overridden method
        dog.eat();        // Calls overridden method
        
        System.out.println("\nCat behavior:");
        cat.makeSound();  // Calls overridden method
        cat.eat();        // Calls parent method (not overridden)
    }
}

public class ThrowDemo {
    // Method that uses throw to generate exception
    public static void validateAge(int age) {
        // Checking for invalid age
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative");
        }
        
        // Checking for age restriction
        if (age < 18) {
            throw new ArithmeticException("Not eligible to vote");
        } else {
            System.out.println("Eligible to vote");
        }
    }
    
    public static void main(String[] args) {
        try {
            // Valid age
            System.out.println("Validating age 20:");
            validateAge(20);
            
            // Underage
            System.out.println("\nValidating age 15:");
            validateAge(15);
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException: " + e.getMessage());
        } catch (IllegalArgumentException e) {
            System.out.println("IllegalArgumentException: " + e.getMessage());
        }
        
        try {
            // Negative age
            System.out.println("\nValidating age -5:");
            validateAge(-5);
        } catch (Exception e) {
            System.out.println("Exception: " + e.getMessage());
        }
    }
}

// Parent class
class Vehicle {
    // Parent class variables
    protected String brand = "Ford";
    protected String color = "Red";
    
    // Parent class constructor
    Vehicle() {
        System.out.println("Vehicle constructor called");
    }
    
    // Parent class method
    void displayInfo() {
        System.out.println("Brand: " + brand);
        System.out.println("Color: " + color);
    }
}

// Child class
class Car extends Vehicle {
    // Child class variables (same names as parent)
    private String brand = "Toyota";
    private String color = "Blue";
    
    // Child class constructor
    Car() {
        super(); // Call parent constructor
        System.out.println("Car constructor called");
    }
    
    // Method using super with variables
    void printDetails() {
        // Access child class variables using this
        System.out.println("Car brand (this): " + this.brand);
        System.out.println("Car color (this): " + this.color);
        
        // Access parent class variables using super
        System.out.println("Vehicle brand (super): " + super.brand);
        System.out.println("Vehicle color (super): " + super.color);
    }
    
    // Method using super with methods
    @Override
    void displayInfo() {
        System.out.println("Car information:");
        // Call parent method
        super.displayInfo();
        System.out.println("Model: Corolla");
    }
}

// Main class
public class SuperKeywordDemo {
    public static void main(String[] args) {
        // Create Car object
        Car myCar = new Car();
        
        System.out.println("\nVariable access with this and super:");
        myCar.printDetails();
        
        System.out.println("\nMethod call with super:");
        myCar.displayInfo();
    }
}

// Custom exception for divide by zero
class DivideByZeroException extends Exception {
    // Constructor without parameters
    public DivideByZeroException() {
        super("Cannot divide by zero");
    }
    
    // Constructor with custom message
    public DivideByZeroException(String message) {
        super(message);
    }
}

// Main class demonstrating custom exception
public class CustomExceptionDemo {
    // Method that might throw our custom exception
    public static double divide(int numerator, int denominator) throws DivideByZeroException {
        if (denominator == 0) {
            throw new DivideByZeroException("Division by zero not allowed");
        }
        return (double) numerator / denominator;
    }
    
    public static void main(String[] args) {
        try {
            // Test with valid input
            System.out.println("10 / 2 = " + divide(10, 2));
            
            // Test with zero as denominator
            System.out.println("10 / 0 = " + divide(10, 0));
        } catch (DivideByZeroException e) {
            System.out.println("Error: " + e.getMessage());
            System.out.println("Custom exception stack trace:");
            e.printStackTrace();
        }
        
        System.out.println("Program continues execution...");
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopyByteByByte {
    public static void main(String[] args) {
        // Define source and destination file paths
        String sourceFile = "source.txt";
        String destinationFile = "destination.txt";
        
        // Variables for file streams
        FileInputStream inputStream = null;
        FileOutputStream outputStream = null;
        
        try {
            // Initialize input and output streams
            inputStream = new FileInputStream(sourceFile);
            outputStream = new FileOutputStream(destinationFile);
            
            System.out.println("Copying file " + sourceFile + " to " + destinationFile);
            
            // Variables to track copy process
            int byteData;
            int byteCount = 0;
            
            // Read file byte by byte until end of file (-1)
            while ((byteData = inputStream.read()) != -1) {
                // Write the byte to destination file
                outputStream.write(byteData);
                byteCount++;
            }
            
            System.out.println("File copied successfully!");
            System.out.println("Total bytes copied: " + byteCount);
            
        } catch (IOException e) {
            System.out.println("Error during file copy: " + e.getMessage());
            e.printStackTrace();
        } finally {
            // Close resources in finally block
            try {
                if (inputStream != null) {
                    inputStream.close();
                }
                if (outputStream != null) {
                    outputStream.close();
                }
                System.out.println("File streams closed successfully");
            } catch (IOException e) {
                System.out.println("Error closing streams: " + e.getMessage());
            }
        }
    }
}

import java.io.FileWriter;
import java.io.IOException;

public class CreateSourceFile {
    public static void main(String[] args) {
        try {
            FileWriter writer = new FileWriter("source.txt");
            writer.write("This is a sample file.\n");
            writer.write("It will be copied byte by byte.\n");
            writer.write("Java I/O operations demo.");
            writer.close();
            System.out.println("Source file created successfully!");
        } catch (IOException e) {
            System.out.println("Error creating source file: " + e.getMessage());
        }
    }
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FinallyBlockDemo {
    public static void main(String[] args) {
        // Example 1: finally with no exception
        System.out.println("Example 1: No exception");
        try {
            int result = 10 / 5;
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Arithmetic exception caught: " + e.getMessage());
        } finally {
            System.out.println("Finally block executed - Example 1");
        }
        
        // Example 2: finally with exception caught
        System.out.println("\nExample 2: Exception caught");
        try {
            int result = 10 / 0; // This will throw exception
            System.out.println("This won't be printed");
        } catch (ArithmeticException e) {
            System.out.println("Arithmetic exception caught: " + e.getMessage());
        } finally {
            System.out.println("Finally block executed - Example 2");
        }
        
        // Example 3: finally with resource management
        System.out.println("\nExample 3: Resource management");
        FileInputStream file = null;
        try {
            file = new FileInputStream("nonexistent.txt"); // This will throw exception
            System.out.println("File opened successfully");
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        } finally {
            // Close resources even if exception occurs
            try {
                if (file != null) {
                    file.close();
                }
                System.out.println("File resource closed in finally block");
            } catch (IOException e) {
                System.out.println("Error closing file: " + e.getMessage());
            }
        }
        
        System.out.println("\nProgram continues execution...");
    }
}