Q1) Compiler vs Interpreter

Q2) Explain in details Stack- Based storage allocation with

diagram.
Stack-based memory allocation (SBMA) is a storage allocation
technique in computer science that involves using a stack to
store memory for variables that are local to the current
function. The stack is an abstract data type that works on a
last-in, first-out (LIFO) basis, meaning that the last element
added is the first one removed. The stack has two main
operations: push, which adds an element, and pop, which
removes the most recent element.
Here are some details about SBMA:
 Storing variables
Programmers can use the stack to store variables of fixed
length, or they can choose to store local data of variable
length.
  Function call stacks
SBMA is often closely linked to function call stacks, which can
be used to allocate arrays and other data structures. Each
function call occupies a range of memory in the stack called a
stack frame.
 Stack pointer
Most CPUs have a stack pointer register that stores the address
of the next item to be pushed or popped.
 Advantages
SBMA is simple, efficient, and avoids the cost of garbage
collecting space for objects.
 Limitations
SBMA's automated and organized nature can limit its
adaptability.

Q3) Write a note on polymorphism with example in Java/C++

Polymorphism is one of the core concepts of Object-Oriented
Programming (OOP) that allows objects of different classes to
be treated as objects of a common superclass. It enables a
single interface to represent different underlying forms (data
types). Polymorphism can be achieved in two ways: Compile-
time (or Static) Polymorphism and Runtime (or Dynamic)
Polymorphism.
1. Compile-time Polymorphism (Method Overloading)
In compile-time polymorphism, the function to be invoked is
determined at compile time. This is commonly achieved
through method overloading, where multiple methods share
the same name but differ in parameters (number, type, or
both).
Example in Java:
class PolymorphismExample {
// Overloaded method with two integer parameters
public int add(int a, int b) {
return a + b;
}

// Overloaded method with three integer parameters

public int add(int a, int b, int c) {
return a + b + c;
}

public static void main(String[] args) {

PolymorphismExample obj = new PolymorphismExample();
System.out.println("Sum of two numbers: " + obj.add(10,
20));
// Output: 30
System.out.println("Sum of three numbers: " + obj.add(10,
20, 30));
// Output: 60
}
}

In the above example, the add method is overloaded with

different parameters. The correct method is chosen based on
the arguments passed.
2. Runtime Polymorphism (Method Overriding)
In runtime polymorphism, the method to be invoked is
determined at runtime. This is commonly achieved through
method overriding, where a subclass provides a specific
implementation of a method that is already defined in its
superclass.
Summary
Polymorphism enhances the flexibility and maintainability of
code by allowing objects of different types to be treated
uniformly. It is a powerful tool in OOP that enables developers
to write more generic and reusable code.

Q4) Explain this keyword in Java with example

The `this` keyword in Java is a reference variable that refers to
the current object. It is used within an instance method or a
constructor to differentiate between class attributes (fields) and
parameters with the same name, to invoke other constructors,
or to pass the current object as an argument to another
method. Let's explore the different use cases of the `this`
keyword in detail.

Referring to Instance Variables

When local variables (like parameters of a constructor or
method) have the same name as instance variables, the `this`
keyword is used to distinguish between the two.

Example:
class Employee {
// Instance variables
private String name;
private int id;

// Constructor with parameters having the same name as

instance variables
public Employee(String name, int id) {
this.name = name; // 'this.name' refers to the instance
variable
this.id = id; // 'this.id' refers to the instance variable
}

// Method to display employee details

 public void display() {
System.out.println("Name: " + this.name);
System.out.println("ID: " + this.id);
}

public static void main(String[] args) {

Employee emp = new Employee("John Doe", 101);
emp.display();
}
}
```

Output:
Name: John Doe
ID: 101

In this example, `this.name` refers to the instance variable

`name` of the `Employee` class, and `this.id` refers to the
instance variable `id`.

2. Invoking Constructors

The `this` keyword can also be used to call another constructor

in the same class. This is useful when you want to reuse a
constructor with a different set of parameters.

Example:
class Employee {
private String name;
private int id;

// Constructor 1
public Employee(String name) {
this(name, 0); // Calls Constructor 2
}

// Constructor 2
public Employee(String name, int id) {
this.name = name;
 this.id = id;
}

public void display() {

System.out.println("Name: " + this.name);
System.out.println("ID: " + this.id);
}

public static void main(String[] args) {

Employee emp1 = new Employee("Alice");
emp1.display(); // Output: Name: Alice, ID: 0

Employee emp2 = new Employee("Bob", 102);

emp2.display(); // Output: Name: Bob, ID: 102
}
}
```

In this example, `this(name, 0);` in Constructor 1 invokes

Constructor 2, reusing the logic defined there.

3. Returning the Current Class Instance

The `this` keyword can be used to return the current class

instance from a method. This is particularly useful in method
chaining.

Example:
public Employee setName(String name) {
this.name = name;
return this; // Allows method chaining
}

In this example, `this` is returned from the `setName` and

`setId` methods, allowing method chaining to set the
properties of the `Employee` object.

4. Passing the Current Object as an Argument

The `this` keyword can also be used to pass the current object
as an argument to another method.

Example:
this.greet(this); // Passes the current object

In this example, `this.greet(this);` passes the current

`Employee` object to the `greet` method, which then accesses
its properties.

Summary

The `this` keyword in Java is a powerful and versatile tool that

helps manage class instances effectively. It clarifies when
you're referring to the current object, avoiding potential
ambiguity in your code, and enables more concise and readable
object-oriented designs.