Tech Jargon - Decoded

import java.util.Scanner;

public class ReadOnlyClass {

    private String studentName;
    private int studentId;

    public ReadOnlyClass(String name, int id) {
        this.studentName = name;
        this.studentId = id;
    }

    public String getStudentName() {
        return studentName;
    }

    public int getStudentId() {
        return studentId;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter student name: ");
        String name = scanner.nextLine();

        System.out.print("Enter student ID: ");
        int id = scanner.nextInt();
        scanner.nextLine(); // Consume newline

        ReadOnlyClass student = new ReadOnlyClass(name, id);

        System.out.println("Student Name: " + student.getStudentName());
        System.out.println("Student ID: " + student.getStudentId());

        // You cannot modify the studentName or studentId from outside the class
        // because there are no setter methods.

        scanner.close();
    }
}

Input: John Doe
Input: 12345
Output: Student Name: John Doe
Output: Student ID: 12345

import java.util.Scanner;

public class StudentDetails {

    private String studentName;
    private int studentAge;

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    public int getStudentAge() {
        return studentAge;
    }

    public void setStudentAge(int studentAge) {
        this.studentAge = studentAge;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        StudentDetails student = new StudentDetails();

        System.out.print("Enter student name: ");
        String name = scanner.nextLine();
        student.setStudentName(name);

        System.out.print("Enter student age: ");
        int age = scanner.nextInt();
        student.setStudentAge(age);
        scanner.nextLine(); // Consume newline left-over

        System.out.println("Student Name: " + student.getStudentName());
        System.out.println("Student Age: " + student.getStudentAge());

        scanner.close();
    }
}

Input: John Doe
Input: 20
Output: Enter student name: Enter student age: Student Name: John Doe
Output: Student Age: 20

import java.util.Scanner;

public class BankAccount {

    private String accountNumber;
    private double balance;

    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }

    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        balance += amount;
    }

    public void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
        } else {
            System.out.println("Insufficient balance.");
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter account number: ");
        String accNumber = scanner.nextLine();

        System.out.print("Enter initial balance: ");
        double initBalance = scanner.nextDouble();
        scanner.nextLine();

        BankAccount account = new BankAccount(accNumber, initBalance);

        System.out.println("Current balance: " + account.getBalance());

        System.out.print("Enter deposit amount: ");
        double depositAmount = scanner.nextDouble();
        scanner.nextLine();
        account.deposit(depositAmount);
        System.out.println("Balance after deposit: " + account.getBalance());

        System.out.print("Enter withdrawal amount: ");
        double withdrawAmount = scanner.nextDouble();
        scanner.nextLine();
        account.withdraw(withdrawAmount);
        System.out.println("Balance after withdrawal: " + account.getBalance());

        scanner.close();
    }
}

Input: 1234567890
Input: 1000
Output: Current balance: 1000.0
Input: 500
Output: Balance after deposit: 1500.0
Input: 200
Output: Balance after withdrawal: 1300.0

import java.util.Scanner;

public class InstanceInitializerBlockExample {

    private String name;
    private int age;

    // Instance Initializer Block
    {
        System.out.println("Instance initializer block executed!");
        name = "Unknown";
        age = 0;
    }

    public InstanceInitializerBlockExample() {
        System.out.println("Constructor 1 executed!");
    }

    public InstanceInitializerBlockExample(String name, int age) {
        System.out.println("Constructor 2 executed!");
        this.name = name;
        this.age = age;
    }

    public void displayDetails() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }

    public static void main(String[] args) {

        System.out.println("Creating object using constructor 1:");
        InstanceInitializerBlockExample obj1 = new InstanceInitializerBlockExample();
        obj1.displayDetails();

        System.out.println("nCreating object using constructor 2:");
        InstanceInitializerBlockExample obj2 = new InstanceInitializerBlockExample("Rahul", 30);
        obj2.displayDetails();

    }
}

Creating object using constructor 1:
Instance initializer block executed!
Constructor 1 executed!
Name: Unknown
Age: 0

Creating object using constructor 2:
Instance initializer block executed!
Constructor 2 executed!
Name: Rahul
Age: 30

import java.util.Scanner;

public class FinalMethodsAndClasses {

    public static void main(String[] args) {

        // Example of a final method
        FinalMethodExample finalMethodExample = new FinalMethodExample();
        finalMethodExample.display();

        // Demonstrating final class behaviour (cannot be subclassed)
        // FinalClassExample cannot be extended.
        System.out.println("Demonstrating final class - cannot be subclassed");

        //Using scanner
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int number = scanner.nextInt();
        System.out.println("You entered: " + number);

        scanner.close();
    }
}

class FinalMethodExample {
    // A final method cannot be overridden
    public final void display() {
        System.out.println("This is a final method.");
    }
}

final class FinalClassExample {
    // This class cannot be extended
    public void showMessage() {
        System.out.println("This is a final class.");
    }
}

//This would give a compile time error:
// class SubClassExample extends FinalClassExample {
// }

This is a final method.
Demonstrating final class - cannot be subclassed
Enter a number: 10
You entered: 10

import java.util.Scanner;

interface Shape {
    double area();
}

class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

class Rectangle implements Shape {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double area() {
        return length * width;
    }
}

public class ShapeCalculator {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter radius of circle: ");
        double circleRadius = scanner.nextDouble();
        Shape circle = new Circle(circleRadius);

        System.out.print("Enter length of rectangle: ");
        double rectangleLength = scanner.nextDouble();
        System.out.print("Enter width of rectangle: ");
        double rectangleWidth = scanner.nextDouble();
        Shape rectangle = new Rectangle(rectangleLength, rectangleWidth);

        System.out.println("Area of circle: " + circle.area());
        System.out.println("Area of rectangle: " + rectangle.area());

        scanner.close();
    }
}

Input: 5
Input: 10
Input: 20
Output: Enter radius of circle: Enter length of rectangle: Enter width of rectangle: Area of circle: 78.53981633974483
Output: Area of rectangle: 200.0

import java.util.Scanner;

abstract class Shape {
    abstract double calculateArea();
    abstract void display();
}

class Circle extends Shape {
    double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    double calculateArea() {
        return Math.PI * radius * radius;
    }

    @Override
    void display() {
        System.out.println("Area of Circle: " + calculateArea());
    }
}

class Rectangle extends Shape {
    double length;
    double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    double calculateArea() {
        return length * width;
    }

    @Override
    void display() {
        System.out.println("Area of Rectangle: " + calculateArea());
    }
}

public class AbstractShapeExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter radius of circle: ");
        double circleRadius = scanner.nextDouble();
        Shape circle = new Circle(circleRadius);
        circle.display();

        System.out.print("Enter length of rectangle: ");
        double rectangleLength = scanner.nextDouble();
        System.out.print("Enter width of rectangle: ");
        double rectangleWidth = scanner.nextDouble();
        Shape rectangle = new Rectangle(rectangleLength, rectangleWidth);
        rectangle.display();

        scanner.close();
    }
}

Input: 5
Output: Enter radius of circle: Area of Circle: 78.53981633974483
Input: 10
Input: 20
Output: Enter length of rectangle: Enter width of rectangle: Area of Rectangle: 200.0

// Code not available

Since the code is not available, I cannot provide the output. I need the Java code to generate the expected output.

import java.util.Scanner;

public class BindingExample {

    static class Animal {
        public void makeSound() {
            System.out.println("Generic animal sound");
        }
    }

    static class Dog extends Animal {
        @Override
        public void makeSound() {
            System.out.println("Woof!");
        }
    }

    public static void main(String[] args) {
        Animal animal = new Animal(); // Static Binding - type of object is known at compile time
        animal.makeSound();

        Animal myDog = new Dog(); // Dynamic Binding - type of object is determined at runtime
        myDog.makeSound(); // Calls Dog's makeSound() method

        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter animal type (animal/dog): ");
        String animalType = scanner.nextLine();

        Animal chosenAnimal;
        if (animalType.equalsIgnoreCase("dog")) {
            chosenAnimal = new Dog(); // Dynamic Binding
        } else {
            chosenAnimal = new Animal(); // Static Binding
        }

        chosenAnimal.makeSound();

        scanner.close();
    }
}

Generic animal sound
Woof!
Input: animal
Output: Generic animal sound
Input: dog
Output: Woof!

import java.util.Scanner;

public class CompileTimePolymorphism {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        Calculator calculator = new Calculator();

        System.out.print("Enter the first integer: ");
        int num1 = scanner.nextInt();

        System.out.print("Enter the second integer: ");
        int num2 = scanner.nextInt();

        System.out.println("Sum of two integers: " + calculator.add(num1, num2));

        System.out.print("Enter the first decimal number: ");
        double decimal1 = scanner.nextDouble();

        System.out.print("Enter the second decimal number: ");
        double decimal2 = scanner.nextDouble();

        System.out.println("Sum of two decimal numbers: " + calculator.add(decimal1, decimal2));

        scanner.close();
    }
}

class Calculator {

    // Method to add two integers
    public int add(int a, int b) {
        return a + b;
    }

    // Method to add two doubles
    public double add(double a, double b) {
        return a + b;
    }
}

Input: 10
Input: 20
Output: Sum of two integers: 30
Input: 5.5
Input: 2.5
Output: Sum of two decimal numbers: 8.0

import java.util.Scanner;

public class RuntimePolymorphismExample {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        Animal animal;

        System.out.println("Enter the type of animal (Dog or Cat):");
        String animalType = scanner.nextLine();

        if (animalType.equalsIgnoreCase("Dog")) {
            animal = new Dog();
        } else if (animalType.equalsIgnoreCase("Cat")) {
            animal = new Cat();
        } else {
            animal = new Animal();
            System.out.println("Invalid animal type. Using default Animal.");
        }

        animal.makeSound();

        scanner.close();
    }
}

class Animal {
    public void makeSound() {
        System.out.println("Generic animal sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

Input: Dog
Output: Enter the type of animal (Dog or Cat):
Woof!

Input: Cat
Output: Enter the type of animal (Dog or Cat):
Meow!

Input: bird
Output: Enter the type of animal (Dog or Cat):
Invalid animal type. Using default Animal.
Generic animal sound

import java.util.Scanner;

class Animal {
    public void makeSound() {
        System.out.println("Generic animal sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

public class MethodOverridingExample {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        Cat cat = new Cat();

        animal.makeSound();
        dog.makeSound();
        cat.makeSound();
    }
}

Generic animal sound
Woof!
Meow!

import java.util.Scanner;

public class MethodOverloadingExample {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter two integers to add:");
        int num1 = scanner.nextInt();
        int num2 = scanner.nextInt();
        System.out.println("Sum of two integers: " + add(num1, num2));

        System.out.println("Enter three integers to add:");
        int num3 = scanner.nextInt();
        int num4 = scanner.nextInt();
        int num5 = scanner.nextInt();
        System.out.println("Sum of three integers: " + add(num3, num4, num5));

        System.out.println("Enter two doubles to add:");
        double double1 = scanner.nextDouble();
        double double2 = scanner.nextDouble();
        System.out.println("Sum of two doubles: " + add(double1, double2));

        scanner.close();
    }

    // Method to add two integers
    public static int add(int a, int b) {
        return a + b;
    }

    // Method to add three integers
    public static int add(int a, int b, int c) {
        return a + b + c;
    }

    // Method to add two doubles
    public static double add(double a, double b) {
        return a + b;
    }
}

Input: 5
Input: 10
Output: Enter two integers to add:
Output: Sum of two integers: 15
Input: 2
Input: 3
Input: 4
Output: Enter three integers to add:
Output: Sum of three integers: 9
Input: 2.5
Input: 3.5
Output: Enter two doubles to add:
Output: Sum of two doubles: 6.0

import java.util.Scanner;

public class DynamicMethodDispatchExample {

    static class Animal {
        public void makeSound() {
            System.out.println("Generic animal sound");
        }
    }

    static class Dog extends Animal {
        @Override
        public void makeSound() {
            System.out.println("Woof!");
        }
    }

    static class Cat extends Animal {
        @Override
        public void makeSound() {
            System.out.println("Meow!");
        }
    }

    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        Cat cat = new Cat();

        Animal animalReference; // Creating a reference of Animal type

        animalReference = animal;
        animalReference.makeSound(); // Calls Animal's makeSound()

        animalReference = dog;
        animalReference.makeSound(); // Calls Dog's makeSound()

        animalReference = cat;
        animalReference.makeSound(); // Calls Cat's makeSound()
    }
}

Generic animal sound
Woof!
Meow!

import java.util.Scanner;

class Animal {
    public AnimalFood getFood() {
        return new AnimalFood();
    }
}

class Dog extends Animal {
    @Override
    public DogFood getFood() {
        return new DogFood();
    }
}

class AnimalFood {
    public String getType() {
        return "Generic Animal Food";
    }
}

class DogFood extends AnimalFood {
    @Override
    public String getType() {
        return "Dog Food";
    }
}

public class CovariantReturnTypes {
    public static void main(String[] args) {
        Animal animal = new Animal();
        AnimalFood animalFood = animal.getFood();
        System.out.println("Animal food type: " + animalFood.getType());

        Dog dog = new Dog();
        DogFood dogFood = dog.getFood(); // Covariant return type: DogFood
        System.out.println("Dog food type: " + dogFood.getType());
    }
}

Animal food type: Generic Animal Food
Dog food type: Dog Food

import java.util.Scanner;

public class InstanceofOperatorExample {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter the name of an animal (Dog, Cat, Animal): ");
        String animalType = scanner.nextLine();

        Animal animal = null;

        if (animalType.equalsIgnoreCase("Dog")) {
            animal = new Dog();
        } else if (animalType.equalsIgnoreCase("Cat")) {
            animal = new Cat();
        } else if (animalType.equalsIgnoreCase("Animal")) {
            animal = new Animal();
        } else {
            System.out.println("Invalid animal type. Creating a default Animal.");
            animal = new Animal();
        }

        if (animal instanceof Dog) {
            System.out.println("The animal is an instance of Dog.");
        }

        if (animal instanceof Cat) {
            System.out.println("The animal is an instance of Cat.");
        }

        if (animal instanceof Animal) {
            System.out.println("The animal is an instance of Animal.");
        }

        scanner.close();
    }
}

class Animal {
}

class Dog extends Animal {
}

class Cat extends Animal {
}

Input: Dog
Output: Enter the name of an animal (Dog, Cat, Animal): The animal is an instance of Dog.
The animal is an instance of Animal.

Input: Cat
Output: Enter the name of an animal (Dog, Cat, Animal): The animal is an instance of Cat.
The animal is an instance of Animal.

Input: Animal
Output: Enter the name of an animal (Dog, Cat, Animal): The animal is an instance of Animal.

Input: Bird
Output: Enter the name of an animal (Dog, Cat, Animal): Invalid animal type. Creating a default Animal.
The animal is an instance of Animal.

import java.util.Scanner;

class Animal {
    public void makeSound() {
        System.out.println("Generic animal sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

public class RuntimePolymorphismDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter 'dog' or 'cat':");
        String animalType = scanner.nextLine();

        Animal animal;

        if (animalType.equalsIgnoreCase("dog")) {
            animal = new Dog();
        } else if (animalType.equalsIgnoreCase("cat")) {
            animal = new Cat();
        } else {
            animal = new Animal();
            System.out.println("Invalid input. Using generic animal.");
        }

        animal.makeSound(); // Runtime polymorphism: The appropriate makeSound() method is called based on the object type

        scanner.close();
    }
}

Input: dog
Output: Enter 'dog' or 'cat':
Woof!

Input: cat
Output: Enter 'dog' or 'cat':
Meow!

Input: elephant
Output: Enter 'dog' or 'cat':
Invalid input. Using generic animal.
Generic animal sound

import java.util.Scanner;

interface Printable {
    void print();
}

interface Sortable {
    void sort();
}

class DataProcessor implements Printable, Sortable {
    private String data;

    public DataProcessor(String data) {
        this.data = data;
    }

    @Override
    public void print() {
        System.out.println("Printing data: " + this.data);
    }

    @Override
    public void sort() {
        // In a real scenario, sorting logic would be implemented here.
        System.out.println("Sorting data...");
    }
}

public class MultipleInheritanceExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter some data: ");
        String inputData = scanner.nextLine();

        DataProcessor processor = new DataProcessor(inputData);

        processor.print();
        processor.sort();

        scanner.close();
    }
}

Input: Hello World
Output: Enter some data: Printing data: Hello World
Output: Sorting data...