5. a) List the Various Selection Statements

In Java, selection statements allow the program to make decisions and execute specific blocks of code based on conditions. The primary selection statements are:

• If Statement: Executes a block of code if the condition is true.
• If-Else Statement: Executes one block of code if the condition is true, and another block if it’s false.
• If-Else If-Else Ladder: Evaluates multiple conditions in sequence.
• Switch Statement: Used to select one of many code blocks to be executed based on a value.

Flowchart for If-Else Statement

[Start] --> [Condition]
   |               |
  Yes             No
   |               |
[Execute True]   [Execute False]
   |               |
 [End]           [End]
    

Example Program (If-Else Statement)

public class SelectionExample {
    public static void main(String[] args) {
        int a = 10, b = 20;

        if (a > b) {
            System.out.println("a is greater than b");
        } else {
            System.out.println("b is greater than a");
        }
    }
}
    

5. b) Explain Object-Oriented Principles in Detail

Object-Oriented Programming (OOP) is a paradigm based on the concept of objects, which are instances of classes. The four core principles of OOP are:

• Encapsulation: This principle is about bundling the data (variables) and the methods (functions) that operate on the data into a single unit called a class. It also involves restricting access to certain components, making them private and providing public methods to access or modify them.

  Example: Using getters and setters to access private variables.

• Inheritance: Inheritance allows one class to inherit fields and methods from another class. This promotes code reuse and method overriding.

  Example: A `Dog` class can inherit from an `Animal` class.

• Polymorphism: Polymorphism means “many forms”. It allows objects to be treated as instances of their parent class, while having their own unique methods. Method Overloading and Method Overriding are examples of polymorphism.

  Example: Overloading the `add()` method with different parameters.

• Abstraction: Abstraction hides complex implementation details and shows only the necessary functionality. This helps in focusing on what an object does rather than how it does it.

  Example: A `Car` class might have a `start()` method, but the internal engine starting mechanism is hidden from the user.

UNIT-II

1. a) Demonstrate About Class and Object. Write an Example Program.

In Java, a class is a blueprint for creating objects, and an object is an instance of a class. The class defines properties and behaviors, while the object represents specific data.

class Car {
    String model;
    int year;

    // Constructor
    Car(String model, int year) {
        this.model = model;
        this.year = year;
    }

    // Method to display car info
    void displayInfo() {
        System.out.println("Car model: " + model);
        System.out.println("Car year: " + year);
    }
}

public class Main {
    public static void main(String[] args) {
        Car car1 = new Car("Tesla Model S", 2022);  // Creating an object
        car1.displayInfo();  // Calling method on the object
    }
}
    

1. b) Make Use of Static Keyword in Java

The static keyword in Java is used for memory management. It is applied to variables, methods, and blocks. A static variable or method belongs to the class, rather than instances of the class. Static methods can be called without creating an instance of the class.

class Counter {
    static int count = 0;  // Static variable

    static void increment() {  // Static method
        count++;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter.increment();
        Counter.increment();
        System.out.println("Counter: " + Counter.count);  // Output: 2
    }
}
    

2. a) What Are Various Access Specifiers? Develop a Java Program Using Anyone Access Specifier.

Access specifiers determine the visibility of classes, methods, and variables. The four main access specifiers in Java are:

• public: Accessible from any other class.
• private: Accessible only within the same class.
• protected: Accessible within the same package and subclasses.
• default (no specifier): Accessible only within the same package.

class Person {
    private String name;  // Private variable

    // Getter and Setter for name
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("John");
        System.out.println("Person's name: " + p.getName());
    }
}
    

2. b) Examine Different Types of Constructors with Examples.

In Java, constructors are special methods used to initialize objects. There are two types of constructors:

• Default Constructor: A constructor that takes no parameters and initializes default values.
• Parameterized Constructor: A constructor that allows you to initialize objects with specific values when they are created.

class Student {
    String name;
    int age;

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

    // Parameterized constructor
    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Student s1 = new Student();  // Using default constructor
        System.out.println("Name: " + s1.name + ", Age: " + s1.age);

        Student s2 = new Student("Alice", 22);  // Using parameterized constructor
        System.out.println("Name: " + s2.name + ", Age: " + s2.age);
    }
}