જાવા પ્રોગ્રામિંગ (4343203) - વિન્ટર 2024 સોલ્યુશન

// 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;
        
        // સરવાળો
        int sum = a + b;
        
        // ગુણાકાર
        int product = a * b;
        
        // મોડ્યુલસ
        int remainder = a % b;
        
        // પરિણામો દર્શાવો
        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:");
        
        // 1 થી 10 સુધીની દરેક સંખ્યા તપાસો
        for (int num = 1; num <= 10; num++) {
            boolean isPrime = true;
            
            // num આ 2 થી num-1 સુધીની કોઈપણ સંખ્યાથી વિભાજ્ય છે કે નહીં તપાસો
            if (num > 1) {
                for (int i = 2; i < num; i++) {
                    if (num % i == 0) {
                        isPrime = false;
                        break;
                    }
                }
                
                // પ્રાઇમ હોય તો પ્રિન્ટ કરો
                if (isPrime) {
                    System.out.print(num + " ");
                }
            }
        }
    }
}

public class Counter {
    // બધા ઓબ્જેક્ટ્સ દ્વારા શેર કરેલ Static variable
    static int count = 0;
    
    // દરેક ઓબ્જેક્ટ માટે અનન્ય Instance variable
    int instanceCount = 0;
    
    // Constructor
    Counter() {
        count++;         // શેર કરેલ કાઉન્ટને વધારે છે
        instanceCount++; // આ ઓબ્જેક્ટના કાઉન્ટને વધારે છે
    }
    
    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;
    }
    
    // વિદ્યાર્થીની વિગતો દર્શાવવા માટેની મેથડ
    public void displayDetails() {
        System.out.println("Student Details:");
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Course: " + course);
    }
    
    // ડેમોન્સ્ટ્રેશન માટે main મેથડ
    public static void main(String[] args) {
        // Parameterized constructor નો ઉપયોગ કરીને ઓબ્જેક્ટ બનાવવું
        Student student1 = new Student("John", 20, "Computer Science");
        student1.displayDetails();
        
        // બીજો વિદ્યાર્થી
        Student student2 = new Student("Lisa", 22, "Engineering");
        student2.displayDetails();
    }
}

public class Person {
    // Private data - બહારથી છુપાયેલ
    private String name;
    private int age;
    
    // Public methods - ડેટા ઍક્સેસ કરવા માટેનો ઇન્ટરફેસ
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void setAge(int age) {
        // માન્યતા ડેટા અખંડિતતા સુનિશ્ચિત કરે છે
        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 ઓવરરાઇડ કરી શકાતી નથી
    final void showLimit() {
        System.out.println("Speed limit: " + MAX_SPEED);
    }
    
    public static void main(String[] args) {
        FinalDemo car = new FinalDemo();
        car.showLimit();
        
        // આ કમ્પાઇલ એરર કરશે:
        // car.MAX_SPEED = 150;
    }
}

// Final class વિસ્તૃત કરી શકાતો નથી
final class MathUtil {
    public int square(int num) {
        return num * num;
    }
}

// આ કમ્પાઇલ એરર કરશે:
// class AdvancedMath extends MathUtil { }

// ફાઇલ: PublicDemo.java
package com.example;

// Public class બધે ઍક્સેસિબલ છે
public class PublicDemo {
    // Public variable બધે ઍક્સેસિબલ છે
    public String message = "Hello, World!";
    
    // Public method બધે ઍક્સેસિબલ છે
    public void displayMessage() {
        System.out.println(message);
    }
}

// ફાઇલ: Main.java
package com.test;

// અલગ પેકેજમાંથી import કરવું
import com.example.PublicDemo;

public class Main {
    public static void main(String[] args) {
        // અલગ પેકેજના ક્લાસનો ઓબ્જેક્ટ બનાવવો
        PublicDemo demo = new PublicDemo();
        
        // અલગ પેકેજમાંથી public variable ઍક્સેસ કરવો
        System.out.println("Message: " + demo.message);
        
        // અલગ પેકેજમાંથી public method કૉલ કરવી
        demo.displayMessage();
        
        // અલગ પેકેજમાંથી public variable સુધારવો
        demo.message = "Modified message";
        demo.displayMessage();
    }
}

// પેરેન્ટ ક્લાસ
class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + " is eating");
    }
}

// Animal માંથી વારસો મેળવતો ચાઇલ્ડ ક્લાસ
class Dog extends Animal {
    private String breed;
    
    public Dog(String name, String breed) {
        super(name);  // પેરેન્ટ કન્સ્ટ્રક્ટર કૉલ કરો
        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);
    }
}

// મુખ્ય ક્લાસ
public class InheritanceDemo {
    public static void main(String[] args) {
        Dog dog = new Dog("Max", "Labrador");
        dog.displayInfo();
        dog.eat();     // વારસામાં મળેલી મેથડ
        dog.bark();    // પોતાની મેથડ
    }
}

public class StringBufferMethodsDemo {
    public static void main(String[] args) {
        // StringBuffer બનાવો
        StringBuffer sb = new StringBuffer("Hello");
        System.out.println("Original: " + sb);
        
        // append() મેથડ - અંતે ટેક્સ્ટ ઉમેરે છે
        sb.append(" World");
        System.out.println("After append(): " + sb);
        
        // વિવિધ ડેટા પ્રકારો append કરી શકે છે
        sb.append('!');
        sb.append(2024);
        System.out.println("After appending more: " + sb);
        
        // ડેમોન્સ્ટ્રેશન માટે રીસેટ
        sb = new StringBuffer("Java");
        System.out.println("\nNew Original: " + sb);
        
        // insert() મેથડ - નિર્દિષ્ટ સ્થાને ટેક્સ્ટ ઉમેરે છે
        sb.insert(0, "Learn ");
        System.out.println("After insert() at beginning: " + sb);
        
        sb.insert(10, " Programming");
        System.out.println("After insert() in middle: " + sb);
    }
}

// પ્રથમ ઇન્ટરફેસ
interface Printable {
    void print();
}

// બીજું ઇન્ટરફેસ
interface Scannable {
    void scan();
}

// બંને ઇન્ટરફેસને અમલ કરતો ક્લાસ
class Device implements Printable, Scannable {
    private String model;
    
    public Device(String model) {
        this.model = model;
    }
    
    // Printable માંથી print() મેથડનું અમલીકરણ
    @Override
    public void print() {
        System.out.println(model + " is printing a document");
    }
    
    // Scannable માંથી scan() મેથડનું અમલીકરણ
    @Override
    public void scan() {
        System.out.println(model + " is scanning a document");
    }
    
    // ક્લાસની પોતાની મેથડ
    public void getModel() {
        System.out.println("Device Model: " + model);
    }
}

// મુખ્ય ક્લાસ
public class MultipleInheritanceDemo {
    public static void main(String[] args) {
        Device device = new Device("HP LaserJet");
        
        // મોડેલ દર્શાવો
        device.getModel();
        
        // ઘણા ઇન્ટરફેસની મેથડ્સનો ઉપયોગ
        device.print();
        device.scan();
        
        // ડિવાઇસ ઇન્ટરફેસનો ઇન્સ્ટન્સ છે કે નહીં તપાસો
        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() મેથડ
        // "Java" ને કાઢો (ઇન્ડેક્સ 0 થી 3)
        String sub1 = message.substring(0, 4);
        System.out.println("substring(0, 4): " + sub1);
        
        // "Programming" ને કાઢો (ઇન્ડેક્સ 5 થી અંત)
        String sub2 = message.substring(5);
        System.out.println("substring(5): " + sub2);
        
        // equals() મેથડ
        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
    }
}

// પગલું 1: ટોચે package ઘોષિત કરો (Calculator.java તરીકે સેવ કરો)
package com.example.math;

// Calculator ક્લાસ
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;
    }
}

// પગલું 1: package ઘોષિત કરો (CalculatorApp.java તરીકે સેવ કરો)
package com.example.app;

// પેકેજ import કરો
import com.example.math.Calculator;

public class CalculatorApp {
    public static void main(String[] args) {
        // package માંથી Calculator ક્લાસનો ઉપયોગ
        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 {
            // એરે બાઉન્ડ્સની બહાર એલિમેન્ટને ઍક્સેસ કરવાનો પ્રયાસ
            System.out.println("Trying to access element 5: " + numbers[4]);
            
            // જો exception થાય તો આ કોડ એક્ઝિક્યુટ નહીં થાય
            System.out.println("This won't be printed");
        } 
        catch (ArrayIndexOutOfBoundsException e) {
            // ચોક્કસ exception ને હેન્ડલ કરો
            System.out.println("Exception caught: " + e.getMessage());
            System.out.println("Array index out of bounds");
        }
        catch (Exception e) {
            // અન્ય exceptions ને હેન્ડલ કરો
            System.out.println("General exception caught: " + e.getMessage());
        }
        finally {
            // આ બ્લોક હંમેશા એક્ઝિક્યુટ થાય છે
            System.out.println("Finally block executed");
        }
        
        // પ્રોગ્રામ એક્ઝિક્યુશન ચાલુ રાખે છે
        System.out.println("Program continues after exception handling");
    }
}

// પેરન્ટ ક્લાસ
class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
    
    public void eat() {
        System.out.println("Animal eats food");
    }
}

// મેથડ્સ ઓવરરાઇડ કરતો ચાઇલ્ડ ક્લાસ
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");
    }
}

// બીજો ચાઇલ્ડ ક્લાસ અલગ ઓવરરાઇડ્સ સાથે
class Cat extends Animal {
    // Method overriding
    @Override
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

// Method overriding ડેમોન્સ્ટ્રેટ કરવા માટેનો મુખ્ય ક્લાસ
public class MethodOverridingDemo {
    public static void main(String[] args) {
        // પેરન્ટ ક્લાસ રેફરન્સ અને ઓબ્જેક્ટ
        Animal animal = new Animal();
        
        // ચાઇલ્ડ ક્લાસ રેફરન્સ અને ઓબ્જેક્ટ્સ
        Animal dog = new Dog();
        Animal cat = new Cat();
        
        // Method overriding વર્તન ડેમોન્સ્ટ્રેટ કરવું
        System.out.println("Animal behavior:");
        animal.makeSound();
        animal.eat();
        
        System.out.println("\nDog behavior:");
        dog.makeSound();  // ઓવરરાઇડ મેથડ કૉલ કરે છે
        dog.eat();        // ઓવરરાઇડ મેથડ કૉલ કરે છે
        
        System.out.println("\nCat behavior:");
        cat.makeSound();  // ઓવરરાઇડ મેથડ કૉલ કરે છે
        cat.eat();        // પેરન્ટ મેથડ કૉલ કરે છે (ઓવરરાઇડ નથી કરી)
    }
}

public class ThrowDemo {
    // exception જનરેટ કરવા માટે throw નો ઉપયોગ કરતી મેથડ
    public static void validateAge(int age) {
        // અમાન્ય ઉંમર માટે તપાસ
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative");
        }
        
        // ઉંમર પ્રતિબંધ માટે તપાસ
        if (age < 18) {
            throw new ArithmeticException("Not eligible to vote");
        } else {
            System.out.println("Eligible to vote");
        }
    }
    
    public static void main(String[] args) {
        try {
            // માન્ય ઉંમર
            System.out.println("Validating age 20:");
            validateAge(20);
            
            // અપૂરતી ઉંમર
            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 {
            // નેગેટિવ ઉંમર
            System.out.println("\nValidating age -5:");
            validateAge(-5);
        } catch (Exception e) {
            System.out.println("Exception: " + e.getMessage());
        }
    }
}

// પેરન્ટ ક્લાસ
class Vehicle {
    // પેરન્ટ ક્લાસ વેરિએબલ્સ
    protected String brand = "Ford";
    protected String color = "Red";
    
    // પેરન્ટ ક્લાસ કન્સ્ટ્રક્ટર
    Vehicle() {
        System.out.println("Vehicle constructor called");
    }
    
    // પેરન્ટ ક્લાસ મેથડ
    void displayInfo() {
        System.out.println("Brand: " + brand);
        System.out.println("Color: " + color);
    }
}

// ચાઇલ્ડ ક્લાસ
class Car extends Vehicle {
    // ચાઇલ્ડ ક્લાસ વેરિએબલ્સ (પેરન્ટ સાથે સમાન નામ)
    private String brand = "Toyota";
    private String color = "Blue";
    
    // ચાઇલ્ડ ક્લાસ કન્સ્ટ્રક્ટર
    Car() {
        super(); // પેરન્ટ કન્સ્ટ્રક્ટર કૉલ કરો
        System.out.println("Car constructor called");
    }
    
    // વેરિએબલ્સ સાથે super નો ઉપયોગ કરતી મેથડ
    void printDetails() {
        // this નો ઉપયોગ કરી ચાઇલ્ડ ક્લાસ વેરિએબલ્સ ઍક્સેસ કરો
        System.out.println("Car brand (this): " + this.brand);
        System.out.println("Car color (this): " + this.color);
        
        // super નો ઉપયોગ કરી પેરન્ટ ક્લાસ વેરિએબલ્સ ઍક્સેસ કરો
        System.out.println("Vehicle brand (super): " + super.brand);
        System.out.println("Vehicle color (super): " + super.color);
    }
    
    // મેથડ્સ સાથે super નો ઉપયોગ કરતી મેથડ
    @Override
    void displayInfo() {
        System.out.println("Car information:");
        // પેરન્ટ મેથડ કૉલ કરો
        super.displayInfo();
        System.out.println("Model: Corolla");
    }
}

// મુખ્ય ક્લાસ
public class SuperKeywordDemo {
    public static void main(String[] args) {
        // Car ઓબ્જેક્ટ બનાવો
        Car myCar = new Car();
        
        System.out.println("\nVariable access with this and super:");
        myCar.printDetails();
        
        System.out.println("\nMethod call with super:");
        myCar.displayInfo();
    }
}

// ડિવાઇડ બાય ઝીરો માટે કસ્ટમ exception
class DivideByZeroException extends Exception {
    // પેરામીટર્સ વગરનો કન્સ્ટ્રક્ટર
    public DivideByZeroException() {
        super("Cannot divide by zero");
    }
    
    // કસ્ટમ મેસેજ સાથેનો કન્સ્ટ્રક્ટર
    public DivideByZeroException(String message) {
        super(message);
    }
}

// કસ્ટમ exception ડેમોન્સ્ટ્રેટ કરતો મુખ્ય ક્લાસ
public class CustomExceptionDemo {
    // આપણી કસ્ટમ 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 {
            // માન્ય ઇનપુટ સાથે ટેસ્ટ
            System.out.println("10 / 2 = " + divide(10, 2));
            
            // ડિનોમિનેટર તરીકે ઝીરો સાથે ટેસ્ટ
            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) {
        // સોર્સ અને ડેસ્ટિનેશન ફાઇલ પાથ્સ વ્યાખ્યાયિત કરો
        String sourceFile = "source.txt";
        String destinationFile = "destination.txt";
        
        // ફાઇલ સ્ટ્રીમ્સ માટે વેરિએબલ્સ
        FileInputStream inputStream = null;
        FileOutputStream outputStream = null;
        
        try {
            // ઇનપુટ અને આઉટપુટ સ્ટ્રીમ્સ ઇનિશિયલાઇઝ કરો
            inputStream = new FileInputStream(sourceFile);
            outputStream = new FileOutputStream(destinationFile);
            
            System.out.println("Copying file " + sourceFile + " to " + destinationFile);
            
            // કોપી પ્રોસેસ ટ્રેક કરવા માટે વેરિએબલ્સ
            int byteData;
            int byteCount = 0;
            
            // ફાઇલનો અંત (-1) આવે ત્યાં સુધી બાઇટ બાય બાઇટ ફાઇલ વાંચો
            while ((byteData = inputStream.read()) != -1) {
                // બાઇટને ડેસ્ટિનેશન ફાઇલમાં લખો
                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 {
            // finally બ્લોકમાં રિસોર્સિસ બંધ કરો
            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) {
        // ઉદાહરણ 1: કોઈ exception વગર finally
        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");
        }
        
        // ઉદાહરણ 2: catch થયેલા exception સાથે finally
        System.out.println("\nExample 2: Exception caught");
        try {
            int result = 10 / 0; // આ 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");
        }
        
        // ઉદાહરણ 3: રિસોર્સ મેનેજમેન્ટ સાથે finally
        System.out.println("\nExample 3: Resource management");
        FileInputStream file = null;
        try {
            file = new FileInputStream("nonexistent.txt"); // આ exception ફેંકશે
            System.out.println("File opened successfully");
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        } finally {
            // exception થાય તોપણ રિસોર્સિસ બંધ કરો
            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...");
    }
}