DAY 5 — C++ OOP + Java Basics — Complete Study Material

Phase 1: Technical Theory | Date: 25 July 2026 | Subject: OOP Concepts | Expected Questions: About 3–4

---

📌 Day Overview

Today you will study Object-Oriented Programming, commonly called OOP.

OOP is a programming approach in which a program is designed using objects. An object combines data and the functions that work on that data.

Five-Hour Study Plan

Hour	Topics
1	Class, Object, Encapsulation, Abstraction and Data Hiding
2	Single, Multiple, Multilevel, Hierarchical and Hybrid Inheritance; Diamond Problem
3	Polymorphism, Function Overloading, Function Overriding, Virtual Functions and Pure Virtual Functions
4	Constructors, Destructors, Friend Functions, this Pointer and Exception Handling
5	Java Basics: JDK, JRE, JVM, Bytecode, Interface, Abstract Class and try-catch-finally

What You Will Master

After completing this material, you will be able to:

1. Explain all four OOP pillars with examples.
2. Differentiate a class from an object.
3. Explain encapsulation, abstraction and data hiding.
4. Identify all five inheritance types from diagrams.
5. Explain the diamond problem and its solution.
6. Differentiate function overloading from function overriding.
7. Explain compile-time and runtime polymorphism.
8. Understand virtual and pure virtual functions.
9. Identify default, parameterized and copy constructors.
10. Explain destructors, friend functions and the this pointer.
11. Understand C++ exception handling.
12. Differentiate JDK, JRE and JVM.
13. Explain Java source code, bytecode and platform independence.
14. Differentiate a Java interface from an abstract class.
15. Understand Java try-catch-finally.

---

1. OOP Concepts — Class, Object, Encapsulation, Abstraction and Data Hiding

1.1 What Is Object-Oriented Programming?

Object-Oriented Programming is a programming method in which a program is organized around objects.

An object represents a real or logical entity, such as:

• Student
• Employee
• Bank account
• Car
• Book
• Mobile phone

Each object usually contains:

1. State: Data stored in the object
2. Behaviour: Operations that the object can perform

Example: Car Object

State or Data	Behaviour or Function
Colour	Start
Speed	Stop
Fuel level	Accelerate
Model	Apply brake

The basic idea is:

Object = Data + Functions working on that data

Why Is OOP Used?

OOP helps programmers:

• Divide a large program into smaller units
• Model real-world entities
• Reuse existing code
• Protect important data
• Reduce repeated code
• Maintain programs easily
• Modify one part without changing the entire program
• Develop large and complex software

---

1.2 Procedural Programming vs OOP

Procedural programming organizes a program mainly around functions and steps.

Object-oriented programming organizes a program mainly around classes and objects.

Procedural Programming	Object-Oriented Programming
Main focus is functions	Main focus is objects
Data and functions may be separate	Data and functions are grouped
Usually follows a top-down approach	Usually follows a bottom-up approach
Data protection may be weaker	Access control can protect data
Code reuse is more limited	Inheritance supports code reuse
Example: C	Examples: C++, Java

Important Point

C++ supports more than one programming style. It supports:

• Procedural programming
• Object-oriented programming
• Generic programming

---

1.3 The Four Pillars of OOP

The four main OOP pillars are:

1. Encapsulation
2. Abstraction
3. Inheritance
4. Polymorphism

Mnemonic

EAIP

• Encapsulation
• Abstraction
• Inheritance
• Polymorphism

A memory sentence is:

Every Animal Inherits Properties

---

1.4 Class

A class is a programmer-defined blueprint or template for creating objects.

It describes:

• What data an object will contain
• What functions an object can perform

Basic C++ Class

class Student
{
private:
    int rollNumber;

public:
    void setRollNumber(int r)
    {
        rollNumber = r;
    }

    void showRollNumber()
    {
        cout << rollNumber;
    }
};

Parts of the Class

Part	Meaning
class	Keyword used to define a class
Student	Name of the class
rollNumber	Data member
setRollNumber()	Member function
showRollNumber()	Member function
private	Accessible only through permitted class operations
public	Accessible from outside the class
Semicolon after }	Required after a C++ class definition

Data Member

A data member is a variable declared inside a class.

Examples:

• Name
• Age
• Salary
• Roll number
• Balance

Member Function

A member function is a function declared as a member of a class. It usually works with the data members of that class.

---

1.5 Object

An object is an instance of a class.

The class is the design. The object is the actual entity created from that design.

Example

Student s1;
Student s2;

Here:

• Student is the class.
• s1 and s2 are objects.
• Each object has its own copy of ordinary non-static data members.

Class and Object Analogy

Class                  Object
-----                  ------
House blueprint  --->  Actual house
Car design       --->  Actual car
Student form     --->  One student record

Accessing Public Members

The dot operator . accesses a public member through an object.

s1.setRollNumber(101);
s1.showRollNumber();

Output:

101

---

1.6 Class vs Object

Basis	Class	Object
Meaning	Blueprint or template	Instance of a class
Nature	Logical definition	Actual usable entity
Example	Student	s1
Quantity	One class can define a type	Many objects can be created
Memory	Definition alone does not create separate storage for each ordinary instance member	An object receives storage for its instance data

Exam Point

In C++:

• Members of a class are private by default.
• Members of a struct are public by default.

---

1.7 Access Specifiers

An access specifier controls where a class member can be accessed.

C++ has three main access specifiers:

1. private
2. protected
3. public

Access Specifier	Same Class	Derived Class	Outside Through Object
private	Yes	No direct access	No
protected	Yes	Yes	No
public	Yes	Yes	Yes

Example

class Account
{
private:
    double balance;

protected:
    int accountType;

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

Easy Memory Rule

• Private: Class itself
• Protected: Class and its children
• Public: Available wherever the object is accessible

A derived class is often informally called a child class.

---

1.8 Encapsulation

Encapsulation means combining data and the functions that operate on that data into one unit.

In OOP, that unit is usually a class.

Diagram

┌────────────────────────────┐
│       BankAccount          │
│                            │
│  Data: balance             │
│  Functions:                │
│    deposit()               │
│    withdraw()              │
│    getBalance()            │
└────────────────────────────┘

The data and related functions are enclosed inside the class.

Example

class BankAccount
{
private:
    double balance;

public:
    void deposit(double amount)
    {
        if (amount > 0)
            balance = balance + amount;
    }

    double getBalance() const
    {
        return balance;
    }
};

Benefits of Encapsulation

• Groups related data and functions
• Protects the internal state
• Prevents uncontrolled modification
• Makes a program easier to maintain
• Provides a clear public interface

Real-Life Example

A medicine capsule encloses medicine inside one unit. In programming, a class encloses data and functions inside one unit.

Exam Definition

Encapsulation is the wrapping of data and functions into a single unit.

---

1.9 Data Hiding

Data hiding means restricting direct access to internal data.

It is usually achieved using:

• private members
• protected members
• Public getter and setter functions

Example

class Employee
{
private:
    double salary;

public:
    void setSalary(double s)
    {
        if (s >= 0)
            salary = s;
    }

    double getSalary() const
    {
        return salary;
    }
};

Outside code cannot directly use:

employee.salary = -5000;

because salary is private.

It must use:

employee.setSalary(5000);

The setter can check whether the value is valid.

Benefits of Data Hiding

• Prevents accidental changes
• Protects sensitive data
• Preserves valid object state
• Reduces unwanted dependency on internal details

---

1.10 Encapsulation vs Data Hiding

These terms are related, but they are not exactly the same.

Encapsulation	Data Hiding
Combines data and functions in one unit	Restricts direct access to data
Achieved mainly using classes	Achieved mainly using access specifiers
Focuses on organization	Focuses on protection
A class can encapsulate members	Private members hide data

Memory Rule

• Encapsulation = Wrap
• Data hiding = Restrict

---

1.11 Abstraction

Abstraction means showing only essential features and hiding unnecessary implementation details.

The user knows what an operation does but does not need to know exactly how it does it.

Real-Life Example: ATM

When using an ATM, you:

• Insert a card
• Enter a PIN
• Select an amount
• Receive money

You do not need to understand:

• Internal bank-server communication
• Database operations
• Encryption details
• Cash-counting mechanism

The ATM provides a simple interface while hiding complex internal work.

Programming Example

class Car
{
public:
    void start()
    {
        checkBattery();
        supplyFuel();
        igniteEngine();
    }

private:
    void checkBattery()
    {
        // Internal work
    }

    void supplyFuel()
    {
        // Internal work
    }

    void igniteEngine()
    {
        // Internal work
    }
};

The user calls:

car.start();

The user does not need to call each internal step.

Abstraction Can Be Achieved Using

• Classes
• Public interfaces
• Abstract classes
• Pure virtual functions
• Java interfaces

---

1.12 Encapsulation vs Abstraction

Encapsulation	Abstraction
Wraps data and functions together	Hides unnecessary implementation details
Focuses on how members are grouped	Focuses on what the user needs to see
Often uses a class	Often uses abstract classes or interfaces
Also supports data protection	Reduces visible complexity
Example: data and methods inside BankAccount	Example: user calls withdraw() without knowing internal steps

Easy Memory Rule

• Encapsulation: How is the program packaged?
• Abstraction: What should the user see?

---

1.13 Inheritance

Inheritance allows a new class to receive properties and behaviours from an existing class.

The existing class is called:

• Base class
• Parent class
• Superclass

The new class is called:

• Derived class
• Child class
• Subclass

Example

class Animal
{
public:
    void eat()
    {
        cout << "Eating";
    }
};

class Dog : public Animal
{
public:
    void bark()
    {
        cout << "Barking";
    }
};

A Dog object can use:

• eat() inherited from Animal
• bark() defined in Dog

Main Benefit

Inheritance supports code reuse.

---

1.14 Polymorphism

Polymorphism means “many forms.”

The same function name or interface can behave differently in different situations.

Examples

1. The same function name can accept different parameters.
2. A base-class pointer can call different derived-class implementations.

Main Types

Type	Binding Time	Main Examples
Compile-time polymorphism	During compilation	Function overloading, operator overloading
Runtime polymorphism	During program execution	Function overriding through virtual functions

Polymorphism is explained fully in Section 3.

---

2. Inheritance Types and the Diamond Problem

2.1 Basic Inheritance Syntax

class Derived : public Base
{
    // Members of Derived
};

Here:

• Base is the parent class.
• Derived is the child class.
• public is the inheritance mode.

---

2.2 Inheritance Access Modes

C++ supports:

• Public inheritance
• Protected inheritance
• Private inheritance

Effect on Inherited Members

Base Member	Public Inheritance	Protected Inheritance	Private Inheritance
public	Remains public	Becomes protected	Becomes private
protected	Remains protected	Remains protected	Becomes private
private	Not directly accessible in derived class	Not directly accessible	Not directly accessible

Important Point

Private members still belong to the base-class part of a derived object, but the derived class cannot access them directly. It may use suitable public or protected base-class functions.

---

2.3 Single Inheritance

In single inheritance, one derived class inherits from one base class.

Diagram

┌──────────┐
│  Animal  │
└────┬─────┘
     │
     v
┌──────────┐
│   Dog    │
└──────────┘

Example

class Animal
{
public:
    void eat()
    {
        cout << "Eat";
    }
};

class Dog : public Animal
{
public:
    void bark()
    {
        cout << "Bark";
    }
};

Relationship

Animal → Dog

Real-Life Example

• Vehicle → Car
• Person → Student
• Animal → Dog

---

2.4 Multiple Inheritance

In multiple inheritance, one derived class inherits from two or more base classes.

Diagram

┌──────────┐       ┌──────────┐
│  Writer  │       │  Speaker │
└────┬─────┘       └────┬─────┘
     │                  │
     └────────┬─────────┘
              v
         ┌──────────┐
         │  Person  │
         └──────────┘

Example

class Writer
{
public:
    void write()
    {
        cout << "Writing";
    }
};

class Speaker
{
public:
    void speak()
    {
        cout << "Speaking";
    }
};

class Person : public Writer, public Speaker
{
};

A Person object can use both write() and speak().

Important Java Point

Java does not support multiple inheritance of classes. A Java class cannot extend two classes.

Java supports multiple inheritance of type or behaviour through interfaces.

---

2.5 Multilevel Inheritance

In multilevel inheritance, a derived class becomes the base class of another class.

Diagram

┌──────────┐
│  Animal  │
└────┬─────┘
     │
     v
┌──────────┐
│ Mammal   │
└────┬─────┘
     │
     v
┌──────────┐
│   Dog    │
└──────────┘

Example

class Animal
{
public:
    void eat()
    {
        cout << "Eat";
    }
};

class Mammal : public Animal
{
public:
    void walk()
    {
        cout << "Walk";
    }
};

class Dog : public Mammal
{
public:
    void bark()
    {
        cout << "Bark";
    }
};

A Dog can use:

• eat()
• walk()
• bark()

Relationship

Animal → Mammal → Dog

---

2.6 Hierarchical Inheritance

In hierarchical inheritance, two or more derived classes inherit from the same base class.

Diagram

              ┌──────────┐
              │  Shape   │
              └────┬─────┘
         ┌─────────┼─────────┐
         │         │         │
         v         v         v
    ┌────────┐ ┌────────┐ ┌────────┐
    │ Circle │ │ Square │ │Triangle│
    └────────┘ └────────┘ └────────┘

Example

class Shape
{
public:
    void display()
    {
        cout << "Shape";
    }
};

class Circle : public Shape
{
};

class Square : public Shape
{
};

Both Circle and Square inherit from Shape.

---

2.7 Hybrid Inheritance

Hybrid inheritance is a combination of two or more inheritance types.

For example, it may combine:

• Multiple inheritance
• Hierarchical inheritance
• Multilevel inheritance

Diagram

              ┌──────────┐
              │  Person  │
              └────┬─────┘
          ┌────────┴────────┐
          v                 v
    ┌──────────┐      ┌──────────┐
    │ Student  │      │ Employee │
    └────┬─────┘      └────┬─────┘
         └────────┬─────────┘
                  v
            ┌──────────┐
            │ Assistant│
            └──────────┘

This structure combines hierarchical and multiple inheritance.

---

2.8 Summary of Five Inheritance Types

Type	Meaning	Structure
Single	One parent, one child	A → B
Multiple	Multiple parents, one child	A + B → C
Multilevel	Inheritance chain	A → B → C
Hierarchical	One parent, multiple children	A → B and A → C
Hybrid	Combination of inheritance types	Mixed structure

Mnemonic

SMMHH

• Single
• Multiple
• Multilevel
• Hierarchical
• Hybrid

Memory sentence:

Smart Minds Make Helpful Humans

---

2.9 Constructor and Destructor Order in Inheritance

When a derived object is created:

1. Base-class constructor runs first.
2. Derived-class constructor runs second.

When the object is destroyed:

1. Derived-class destructor runs first.
2. Base-class destructor runs second.

Example

class Base
{
public:
    Base()
    {
        cout << "Base ";
    }

    ~Base()
    {
        cout << "Base destroyed ";
    }
};

class Derived : public Base
{
public:
    Derived()
    {
        cout << "Derived ";
    }

    ~Derived()
    {
        cout << "Derived destroyed ";
    }
};

Creation order:

Base → Derived

Destruction order:

Derived → Base

Memory Rule

Construct from parent to child. Destroy from child to parent.

---

2.10 Ambiguity in Multiple Inheritance

Suppose two base classes contain a function with the same name.

class A
{
public:
    void show()
    {
        cout << "A";
    }
};

class B
{
public:
    void show()
    {
        cout << "B";
    }
};

class C : public A, public B
{
};

Calling this is ambiguous:

C object;
object.show();

The compiler cannot decide whether to call:

• A::show()
• B::show()

Resolving Ambiguity

Use the scope-resolution operator:

object.A::show();
object.B::show();

---

2.11 Diamond Problem

The diamond problem occurs when two classes inherit from the same base class, and another class inherits from both of them.

Diamond Diagram

              ┌──────────┐
              │  Person  │
              └────┬─────┘
          ┌────────┴────────┐
          v                 v
    ┌──────────┐      ┌──────────┐
    │ Student  │      │ Employee │
    └────┬─────┘      └────┬─────┘
         └────────┬─────────┘
                  v
            ┌──────────┐
            │ Assistant│
            └──────────┘

Ordinary Inheritance Example

class Person
{
public:
    int age;
};

class Student : public Person
{
};

class Employee : public Person
{
};

class Assistant : public Student, public Employee
{
};

An Assistant object receives two Person base subobjects:

1. One through Student
2. One through Employee

Therefore, this can be ambiguous:

Assistant a;
a.age = 25;

The compiler cannot decide which Person::age should be used.

---

2.12 Solution: Virtual Inheritance

Use virtual inheritance in the intermediate classes.

class Person
{
public:
    int age;
};

class Student : virtual public Person
{
};

class Employee : virtual public Person
{
};

class Assistant : public Student, public Employee
{
};

Now Assistant contains only one shared Person base-class subobject.

Corrected Diagram

              ┌──────────┐
              │  Person  │
              │ one copy │
              └────┬─────┘
          ┌────────┴────────┐
          v                 v
    ┌──────────┐      ┌──────────┐
    │ Student  │      │ Employee │
    └────┬─────┘      └────┬─────┘
         └────────┬─────────┘
                  v
            ┌──────────┐
            │ Assistant│
            └──────────┘

Exam Point

The diamond problem in C++ is solved using:

Virtual base classes or virtual inheritance

Do not confuse this with a virtual function. Both use the word virtual, but they solve different problems.

Virtual Inheritance	Virtual Function
Solves duplicate-base problem	Supports runtime polymorphism
Used in inheritance declaration	Used in member-function declaration
Example: class B : virtual public A	Example: virtual void show()

---

3. Polymorphism, Overloading, Overriding and Virtual Functions

3.1 What Is Polymorphism?

The word polymorphism comes from:

• Poly: Many
• Morph: Forms

Therefore:

Polymorphism means many forms.

It allows one function name or interface to represent different behaviours.

---

3.2 Types of Polymorphism

1. Compile-Time Polymorphism

The compiler decides which operation to use during compilation.

Examples:

• Function overloading
• Operator overloading
• Templates

It is also called:

• Static polymorphism
• Early binding
• Static binding

2. Runtime Polymorphism

The decision is made while the program is running.

It is achieved using:

• Inheritance
• Function overriding
• Virtual functions
• Base pointer or reference

It is also called:

• Dynamic polymorphism
• Late binding
• Dynamic binding

Comparison

Compile-Time Polymorphism	Runtime Polymorphism
Decision occurs during compilation	Decision occurs during execution
Usually faster	May have small runtime overhead
Uses overloading or templates	Uses overriding and virtual functions
Early or static binding	Late or dynamic binding
Inheritance not required for function overloading	Inheritance is required for overriding

---

3.3 Function Overloading

Function overloading means defining multiple functions with the same name but different parameter lists in the same scope.

The parameter lists may differ by:

• Number of parameters
• Types of parameters
• Order of parameter types

Example: Different Number of Parameters

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

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

Calls:

add(2, 3);       // Calls first function
add(2, 3, 4);    // Calls second function

---

3.4 Overloading by Parameter Type

int area(int side)
{
    return side * side;
}

double area(double radius)
{
    return 3.14159 * radius * radius;
}

The compiler selects the function according to the argument type.

---

3.5 Overloading by Parameter Order

void show(int x, double y)
{
    cout << "First";
}

void show(double x, int y)
{
    cout << "Second";
}

Calls:

show(5, 2.5);    // First
show(2.5, 5);    // Second

---

3.6 Return Type Alone Cannot Overload a Function

Invalid:

int getValue()
{
    return 10;
}

double getValue()
{
    return 10.5;
}

The compiler cannot select a function using only the expected return type.

Exam Rule

Functions cannot be overloaded only by changing the return type.

---

3.7 Operator Overloading

C++ allows many operators to be given special meaning for user-defined types.

Example idea:

Complex c3 = c1 + c2;

The + operator may be overloaded to add two complex-number objects.

Operators That Cannot Be Overloaded

Common examples include:

• :: scope-resolution operator
• . member-access operator
• .* pointer-to-member operator
• ?: conditional operator
• sizeof

For Day 5, remember that operator overloading is a form of compile-time polymorphism.

---

3.8 Function Overriding

Function overriding occurs when a derived class provides a new implementation of a base-class virtual function.

The derived function uses the same basic function signature.

Example

class Animal
{
public:
    virtual void sound()
    {
        cout << "Animal sound";
    }
};

class Dog : public Animal
{
public:
    void sound() override
    {
        cout << "Bark";
    }
};

Here, Dog::sound() overrides Animal::sound().

Requirements for Runtime Overriding

• There must be inheritance.
• The base function should be virtual.
• The derived function must match the required signature.
• Runtime selection normally uses a base pointer or reference.

---

3.9 Overloading vs Overriding

Basis	Overloading	Overriding
Meaning	Same name, different parameter list	Derived class replaces inherited virtual behaviour
Classes	Usually within the same scope or class	Requires base and derived classes
Parameters	Must differ	Must match the overriding signature
Binding	Compile time	Runtime when called virtually
Inheritance	Not required	Required
Return type	Cannot differ alone	Must follow C++ overriding return-type rules
Keyword	No special keyword required	virtual in base; override recommended in derived
Polymorphism	Compile-time	Runtime

Memory Rule

• Overloading: Same name, different inputs
• Overriding: Same virtual operation, new child behaviour

---

3.10 Virtual Function

A virtual function is a base-class member function declared using the virtual keyword.

It allows a derived implementation to be selected at runtime when the function is called through a suitable base pointer or reference.

Example Without Virtual

class Animal
{
public:
    void sound()
    {
        cout << "Animal";
    }
};

class Dog : public Animal
{
public:
    void sound()
    {
        cout << "Dog";
    }
};

Animal *p = new Dog;
p->sound();

Output:

Animal

The pointer type controls selection because the base function is not virtual.

---

3.11 Example With Virtual

class Animal
{
public:
    virtual void sound()
    {
        cout << "Animal";
    }

    virtual ~Animal() = default;
};

class Dog : public Animal
{
public:
    void sound() override
    {
        cout << "Dog";
    }
};

Animal *p = new Dog;
p->sound();
delete p;

Output:

Dog

The actual object is a Dog, so Dog::sound() runs.

Runtime Flow

Base pointer p
      │
      v
Points to Dog object
      │
      v
sound() is virtual
      │
      v
Dog::sound() is selected

---

3.12 The override Specifier

In modern C++, write override in the derived class.

void sound() override
{
    cout << "Dog";
}

Benefits:

• Clearly shows intention
• Compiler checks that a base virtual function is really being overridden
• Helps detect signature mistakes

Example of a Mistake

If the base has:

virtual void show(int);

and the derived class accidentally writes:

void show(double) override;

the compiler reports an error because the signatures do not match.

---

3.13 Pure Virtual Function

A pure virtual function is a virtual function declared using = 0.

Syntax

virtual return_type function_name(parameters) = 0;

Example

class Shape
{
public:
    virtual double area() const = 0;
    virtual ~Shape() = default;
};

A derived class provides the implementation:

class Square : public Shape
{
private:
    double side;

public:
    Square(double s) : side(s)
    {
    }

    double area() const override
    {
        return side * side;
    }
};

---

3.14 Abstract Class

A class containing at least one pure virtual function is an abstract class.

An abstract class is incomplete as a directly creatable type.

Invalid:

Shape s;

Valid:

Square square(5);

Purpose of an Abstract Class

An abstract class:

• Defines a common interface
• Forces derived classes to provide required behaviour
• Supports abstraction
• Supports runtime polymorphism

Important Point

A derived class must override all inherited pure virtual functions to become concrete. Otherwise, that derived class also remains abstract.

---

3.15 Virtual Function vs Pure Virtual Function

Virtual Function	Pure Virtual Function
Declared with virtual	Declared with virtual and = 0
Usually has a usable base implementation	Makes the class abstract
Derived class may override it	Concrete derived class must implement it
Base class can normally be instantiated if no pure virtual function exists	Abstract base class cannot be directly instantiated
Example: virtual void show()	Example: virtual void show() = 0

---

3.16 Why Use a Virtual Destructor?

If objects may be deleted through a base-class pointer, the base class should normally have a virtual destructor.

class Base
{
public:
    virtual ~Base()
    {
    }
};

This allows the derived destructor to run before the base destructor.

Example

Base *p = new Derived;
delete p;

With a suitable virtual base destructor:

Derived destructor runs
Base destructor runs

This prevents incomplete destruction of the derived object.

---

3.17 Object Slicing

Object slicing happens when a derived object is copied into a base object by value. The derived-specific part is lost.

Example:

Dog d;
Animal a = d;

Now a contains only the Animal part.

Runtime polymorphism is normally used through:

• Base pointer
• Base reference

not by copying the derived object into a separate base object.

---

4. C++ Specifics — Constructors, Destructors, Friend Functions, this Pointer and Exceptions

4.1 Constructor

A constructor is a special member function that initializes an object.

Rules

• Constructor name is the same as the class name.
• It has no return type, not even void.
• It runs automatically when an object is created.
• It can be overloaded.
• It is usually declared in the public section.
• A constructor cannot be virtual.

Basic Example

class Student
{
private:
    int roll;

public:
    Student()
    {
        roll = 0;
    }
};

When this object is created:

Student s;

the constructor runs automatically.

---

4.2 Default Constructor

A default constructor is a constructor that can be called without arguments.

Example

class Number
{
private:
    int value;

public:
    Number()
    {
        value = 0;
    }
};

Call:

Number n;

Important Accuracy Point

A constructor with all parameters having default values can also act as a default constructor.

---

4.3 Parameterized Constructor

A parameterized constructor receives arguments.

class Number
{
private:
    int value;

public:
    Number(int v)
    {
        value = v;
    }

    int getValue() const
    {
        return value;
    }
};

Creation:

Number n(25);

Now:

value = 25

---

4.4 Constructor Overloading

A class can have several constructors with different parameter lists.

class Box
{
private:
    int length;
    int width;

public:
    Box()
    {
        length = 0;
        width = 0;
    }

    Box(int side)
    {
        length = side;
        width = side;
    }

    Box(int l, int w)
    {
        length = l;
        width = w;
    }
};

Objects:

Box b1;          // Default constructor
Box b2(5);       // One-parameter constructor
Box b3(4, 6);    // Two-parameter constructor

Constructor overloading is compile-time polymorphism.

---

4.5 Copy Constructor

A copy constructor creates a new object from an existing object of the same class.

Common Form

ClassName(const ClassName &other);

Example

class Number
{
private:
    int value;

public:
    Number(int v)
    {
        value = v;
    }

    Number(const Number &other)
    {
        value = other.value;
    }

    int getValue() const
    {
        return value;
    }
};

Use:

Number n1(10);
Number n2 = n1;

Now n2 is initialized from n1.

Why Use a Reference?

If the parameter were passed by value, creating that parameter would itself require another copy-constructor call. A reference avoids that problem.

Why Use const?

const allows copying from constant objects and prevents accidental modification of the source.

---

4.6 Constructor Summary

Constructor Type	Purpose	Example Call
Default	Creates object without supplied arguments	Box b;
Parameterized	Initializes using arguments	Box b(5);
Copy	Creates object from another object	Box b2 = b1;

Mnemonic

DPC

• Default
• Parameterized
• Copy

---

4.7 Member Initializer List

A member initializer list initializes data members before the constructor body begins.

class Student
{
private:
    int roll;

public:
    Student(int r) : roll(r)
    {
    }
};

This is often better than assigning inside the constructor body.

It is required for some members, such as:

• Reference members
• const data members
• Base classes without an accessible default constructor

---

4.8 Destructor

A destructor is a special member function that runs when an object is destroyed.

Syntax

~ClassName()
{
    // Cleanup
}

Example

class Test
{
public:
    Test()
    {
        cout << "Created ";
    }

    ~Test()
    {
        cout << "Destroyed";
    }
};

Destructor Rules

• Name is the class name preceded by ~.
• It has no return type.
• It takes no parameters.
• A class has only one destructor.
• It cannot be overloaded.
• It runs automatically.
• It can be virtual.
• It is often used to release resources.

Constructor vs Destructor

Constructor	Destructor
Initializes an object	Cleans up an object
Same name as class	Same name with ~
Can take parameters	Takes no parameters
Can be overloaded	Cannot be overloaded
Runs at object creation	Runs at object destruction
Cannot be virtual	Can be virtual

Memory Rule

• Constructor = Start
• Destructor = Stop

---

4.9 Order of Local Object Destruction

Local objects in the same scope are usually destroyed in the reverse order of their completed construction.

If objects are created as:

A first;
A second;
A third;

Their destruction order is:

third
second
first

This follows a stack-like order.

---

4.10 Friend Function

A friend function is not a member of a class, but it is allowed to access that class’s private and protected members.

Declaration

The function is declared using the friend keyword inside the class.

class Box
{
private:
    int length;

public:
    Box(int l) : length(l)
    {
    }

    friend void showLength(const Box &b);
};

void showLength(const Box &b)
{
    cout << b.length;
}

Call:

Box b(10);
showLength(b);

Output:

10

Important Properties

• It is not a member function.
• It is called like an ordinary function.
• It has no this pointer.
• It can access private and protected members.
• It may be declared in any section of the class.
• Friendship is granted by the class.
• Friendship is not automatically inherited.
• Friendship is not automatically transitive.

Not Transitive

If A is a friend of B, and B is a friend of C, A does not automatically become a friend of C.

Not Inherited

If a function is a friend of a base class, it is not automatically a friend of the derived class.

Use Friend Functions Carefully

Friend functions reduce strict data hiding. They should be used only when they provide a clear design benefit.

---

4.11 Friend Class

A complete class can also be declared as a friend.

class A
{
private:
    int value;

    friend class B;
};

Now the member functions of B can access permitted private and protected members of A.

---

4.12 The this Pointer

Inside a non-static member function, this is a pointer to the current object.

Basic Idea

this → current object

If object s1 calls a member function, this points to s1.

If object s2 calls it, this points to s2.

---

4.13 Resolving Name Conflict With this

class Student
{
private:
    int roll;

public:
    void setRoll(int roll)
    {
        this->roll = roll;
    }
};

Here:

• this->roll means the object’s data member.
• roll means the function parameter.

Without this, the statement:

roll = roll;

would assign the parameter to itself.

---

4.14 Returning the Current Object

A member function can return the current object using *this.

class Number
{
private:
    int value;

public:
    Number &setValue(int value)
    {
        this->value = value;
        return *this;
    }
};

This can support method chaining:

n.setValue(10);

With multiple suitable functions, chaining may look like:

object.setA(10).setB(20);

---

4.15 Important Facts About this

• this is available in non-static member functions.
• this points to the object that called the function.
• this->member accesses a member of the current object.
• *this represents the current object.
• Static member functions do not have a this pointer.
• Friend functions do not have a this pointer because they are not members.

---

4.16 Exception

An exception is an unusual condition or error that interrupts the normal flow of a program.

Examples:

• Division by zero
• Invalid input
• File-opening failure
• Memory-allocation failure
• Invalid array-related operation

Exception handling separates normal code from error-handling code.

---

4.17 C++ Exception Keywords

C++ mainly uses:

• try
• throw
• catch

Flow

try block
    │
    v
Error occurs?
   /     \
 No       Yes
 │         │
 v         v
Continue   throw exception
              │
              v
          matching catch
              │
              v
         handle problem

---

4.18 Basic Exception Example

try
{
    int denominator = 0;

    if (denominator == 0)
        throw denominator;

    cout << 10 / denominator;
}
catch (int value)
{
    cout << "Division by zero";
}

Output:

Division by zero

Meaning

• The risky code is placed in try.
• throw reports an exception.
• catch handles a matching exception type.

---

4.19 Multiple Catch Blocks

try
{
    // Risky code
}
catch (int value)
{
    cout << "Integer exception";
}
catch (double value)
{
    cout << "Double exception";
}
catch (const char *message)
{
    cout << message;
}

The matching catch block handles the exception.

---

4.20 Catch-All Handler

catch (...)
{
    cout << "Unknown exception";
}

catch (...) can catch exceptions that were not handled by earlier handlers.

It should normally be written after more specific catch blocks.

---

4.21 Stack Unwinding

When an exception is thrown, control searches for a matching handler.

During this search, local objects in exited scopes are destroyed. This process is called stack unwinding.

This is one reason destructors are important in C++.

---

4.22 Rethrowing an Exception

Inside a catch block, writing:

throw;

throws the current exception again so that another handler can process it.

---

4.23 Standard Exception Classes

C++ provides standard exception types through headers such as <exception> and <stdexcept>.

Common examples:

Exception	General Meaning
std::exception	Common base class for many standard exceptions
std::runtime_error	Error detected during program execution
std::logic_error	Problem related to program logic
std::out_of_range	Value or index is outside an allowed range
std::bad_alloc	Dynamic memory allocation failed

Example

throw std::runtime_error("Invalid operation");

A standard exception object often provides:

what()

which returns an explanatory message.

---

5. Java Basics — JDK, JRE, JVM, Bytecode, Interfaces and Exceptions

5.1 What Is Java?

Java is a:

• High-level programming language
• Class-based language
• Object-oriented language
• Strongly typed language
• Platform-independent language at the bytecode level

Java source files normally use the extension:

.java

Compiled Java bytecode files normally use:

.class

---

5.2 Basic Java Program

class Hello
{
    public static void main(String[] args)
    {
        System.out.println("Hello");
    }
}

Output:

Hello

Main Parts

Part	Meaning
class Hello	Defines a class named Hello
public	Accessible to the Java launcher
static	main can run without creating a Hello object
void	main does not return a value
String[] args	Stores command-line arguments
System.out.println	Displays a line of output

---

5.3 Java Compilation and Execution

Suppose the source file is:

Hello.java

Compile:

javac Hello.java

The compiler creates:

Hello.class

Run:

java Hello

Complete Flow

Java source code
   Hello.java
       │
       │ javac compiler
       v
Java bytecode
   Hello.class
       │
       │ JVM
       v
Native machine instructions
       │
       v
    Program output

---

5.4 Bytecode

Bytecode is the intermediate instruction format produced by the Java compiler.

It is not normally the direct machine code of one particular processor.

The JVM reads or compiles bytecode for the current system.

Why Bytecode Is Important

The same .class file can often run on different systems if a compatible JVM is available.

This leads to the Java principle:

Write Once, Run Anywhere

Important Distinction

Type	Meaning
Source code	Human-readable Java program in a .java file
Bytecode	Intermediate JVM instructions in a .class file
Machine code	Processor-specific instructions executed by the hardware

---

5.5 JVM

JVM stands for Java Virtual Machine.

The JVM is the runtime engine that executes Java bytecode.

Main Responsibilities

• Loads class files
• Verifies bytecode
• Executes bytecode
• Manages memory
• Supports garbage collection
• Provides runtime security checks
• Converts frequently used bytecode to native machine code when appropriate

JIT Compiler

JIT stands for Just-In-Time compiler.

A JIT compiler converts bytecode into native machine code while the program is running. This can improve performance.

JVM and Platform Dependence

• Java bytecode is designed to be platform-independent.
• A JVM implementation is platform-specific.
• Different systems need suitable JVM implementations.

---

5.6 JRE

JRE stands for Java Runtime Environment.

Conceptually, the JRE provides what is needed to run Java applications.

It includes:

• JVM
• Core Java class libraries
• Supporting runtime files

Basic Formula

JRE = JVM + Libraries needed to run Java programs

Important Modern Note

Modern JDK distributions may not provide a separate public JRE package in the old style. However, the JRE concept remains important for examinations.

---

5.7 JDK

JDK stands for Java Development Kit.

The JDK is used to develop, compile and run Java programs.

It includes:

• Java compiler, such as javac
• Java launcher, such as java
• JVM and runtime components
• Java libraries
• Development and debugging tools
• Documentation tools

Basic Formula

JDK = JRE concept + Development tools

and:

JRE = JVM + Runtime libraries

Therefore:

JDK
 ├── Development tools
 │     ├── javac
 │     ├── debugger tools
 │     └── documentation tools
 │
 └── Runtime environment
       ├── JVM
       └── Java libraries

---

5.8 JDK vs JRE vs JVM

Basis	JDK	JRE	JVM
Full Form	Java Development Kit	Java Runtime Environment	Java Virtual Machine
Main Purpose	Develop and run Java programs	Run Java programs	Execute Java bytecode
Contains Compiler	Yes	No	No
Contains JVM	Yes	Yes	It is the JVM itself
Contains Libraries	Yes	Yes	Uses runtime support
Main Users	Developers	End users and runtime systems	Runtime engine
Key Tool	javac	Runtime libraries	Bytecode execution

Memory Diagram

JDK is the largest
    └── JRE or equivalent runtime components
          └── JVM

Mnemonic

• JDK = Develop
• JRE = Run
• JVM = Execute bytecode

Another memory sentence:

Develop with JDK, Run with JRE, Execute inside JVM.

---

5.9 Garbage Collection

Java uses automatic garbage collection.

Garbage collection finds objects that are no longer reachable and makes their memory available for reuse.

The programmer does not normally use delete as in C++.

C++ vs Java Memory Cleanup

C++	Java
Can use destructors and delete for dynamically allocated objects	Uses automatic garbage collection
Supports deterministic destruction for local objects	Garbage-collection timing is generally not guaranteed
Destructor syntax: ~ClassName()	No direct C++-style destructor

---

5.10 Java Class and Object

Class

class Student
{
    int roll;

    void display()
    {
        System.out.println(roll);
    }
}

Object Creation

Student s = new Student();

Here:

• Student is the class.
• s is a reference variable.
• new Student() creates the object.

Access

s.roll = 10;
s.display();

---

5.11 Java Inheritance

Java uses the extends keyword for class inheritance.

class Animal
{
    void eat()
    {
        System.out.println("Eating");
    }
}

class Dog extends Animal
{
    void bark()
    {
        System.out.println("Barking");
    }
}

Important Rule

A Java class can directly extend only one class.

Invalid idea:

class C extends A, B

Java avoids multiple inheritance of classes partly to prevent ambiguity such as the diamond problem involving class state and implementations.

---

5.12 Abstract Class in Java

An abstract class is declared using the abstract keyword.

It may contain:

• Abstract methods
• Concrete methods with bodies
• Instance variables
• Constructors
• Static methods
• Final methods
• Access-controlled members

Example

abstract class Shape
{
    abstract double area();

    void display()
    {
        System.out.println("Shape");
    }
}

A concrete subclass implements the abstract method:

class Square extends Shape
{
    double side;

    Square(double side)
    {
        this.side = side;
    }

    double area()
    {
        return side * side;
    }
}

Important Points

• An abstract class cannot be directly instantiated.
• An abstract class may have zero or more abstract methods.
• A class with an abstract method must itself be abstract.
• A subclass must implement inherited abstract methods or remain abstract.

---

5.13 Java Interface

An interface defines a contract that implementing classes agree to follow.

It is declared using the interface keyword.

Example

interface Printable
{
    void print();
}

class Report implements Printable
{
    public void print()
    {
        System.out.println("Printing report");
    }
}

Important Access Rule

An interface method such as void print(); is public in this basic context. Therefore, the implementing method must be declared public; it cannot reduce access.

---

5.14 Interface Features

A Java interface can contain:

• Abstract method declarations
• Constants
• Default methods
• Static methods
• Private helper methods in modern Java

Interface fields are implicitly:

• public
• static
• final

A class uses:

implements

to implement an interface.

Multiple Interfaces

A class can implement more than one interface.

interface Printable
{
    void print();
}

interface Scannable
{
    void scan();
}

class Machine implements Printable, Scannable
{
    public void print()
    {
        System.out.println("Print");
    }

    public void scan()
    {
        System.out.println("Scan");
    }
}

This gives Java a controlled form of multiple inheritance of type.

---

5.15 Interface vs Abstract Class

Basis	Interface	Abstract Class
Declaration	interface	abstract class
Used By Class	implements	extends
Multiple Use	A class can implement multiple interfaces	A class can directly extend only one class
Constructors	Cannot have constructors	Can have constructors
Instance State	No ordinary instance fields	Can have ordinary instance fields
Methods	Can have abstract, default, static and permitted private methods	Can have abstract and concrete methods
Fields	Constants: public, static and final	Can have instance and static fields
Main Purpose	Define a contract or capability	Share state and partial implementation
Instantiation	Cannot be directly instantiated	Cannot be directly instantiated
Example Meaning	“Can do” relationship	Common base with “is-a” relationship

When to Use an Interface

Use an interface when unrelated classes need to follow the same contract.

Examples:

• Printable
• Comparable
• Runnable
• Serializable

When to Use an Abstract Class

Use an abstract class when related classes need:

• Shared state
• Shared code
• Common constructors
• A partial implementation

Memory Rule

• Interface = Contract
• Abstract class = Partial base class

---

5.16 Java Method Overloading

Java supports method overloading.

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

double add(double a, double b)
{
    return a + b;
}

The compiler chooses the method according to the argument list.

Return type alone cannot create a valid overload in Java.

---

5.17 Java Method Overriding

A subclass may provide a new implementation of an inherited instance method.

class Animal
{
    void sound()
    {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal
{
    @Override
    void sound()
    {
        System.out.println("Bark");
    }
}

The @Override annotation asks the compiler to check that the method truly overrides an inherited method.

---

5.18 Java Exceptions

An exception is an object representing an error or unusual condition.

Java exception handling uses:

• try
• catch
• finally
• throw
• throws

---

5.19 Java try-catch

Example

try
{
    int result = 10 / 0;
    System.out.println(result);
}
catch (ArithmeticException e)
{
    System.out.println("Cannot divide by zero");
}

Output:

Cannot divide by zero

Flow

1. Code in try begins.
2. Division by zero causes ArithmeticException.
3. Remaining statements in the try block are skipped.
4. Matching catch block runs.
5. Program continues after the exception-handling structure if possible.

---

5.20 Java finally

A finally block contains cleanup code.

It normally runs whether an exception occurs or not.

Example

try
{
    System.out.println("Try");
}
catch (Exception e)
{
    System.out.println("Catch");
}
finally
{
    System.out.println("Finally");
}

Output:

Try
Finally

No exception occurs, so catch does not run. finally runs.

---

5.21 Exception Example With Catch and Finally

try
{
    int result = 10 / 0;
    System.out.println(result);
}
catch (ArithmeticException e)
{
    System.out.println("Catch");
}
finally
{
    System.out.println("Finally");
}

Output:

Catch
Finally

Usual Purpose of finally

• Close files
• Close database connections
• Release resources
• Perform final cleanup

Accuracy Point

finally normally runs, but there are exceptional situations where normal execution ends before it can run, such as forced JVM termination.

For exam questions, the usual rule is:

The finally block runs whether an exception occurs or not.

---

5.22 throw vs throws

throw

throw explicitly throws one exception object.

throw new IllegalArgumentException("Invalid age");

throws

throws is written in a method declaration to state that the method may pass certain exceptions to its caller.

void readFile() throws IOException
{
    // File operations
}

Comparison

throw	throws
Throws an exception object	Declares possible exception types
Used inside a method or block	Used in a method declaration
Followed by an exception object	Followed by one or more exception class names
Example: throw new Exception()	Example: void f() throws Exception

---

5.23 Checked and Unchecked Exceptions

Checked Exception

The compiler requires it to be handled or declared.

Example:

• IOException

Unchecked Exception

Usually represents a programming error and is not subject to the same compile-time handling requirement.

Examples:

• ArithmeticException
• NullPointerException
• ArrayIndexOutOfBoundsException

Checked	Unchecked
Checked at compile time for handling or declaration	Not required to be caught or declared
Often external or recoverable conditions	Often programming mistakes
Example: IOException	Example: ArithmeticException

---

5.24 C++ vs Java Quick Comparison

Feature	C++	Java
Compilation	Commonly compiled to native code	Compiled to bytecode, then executed by JVM
Multiple Class Inheritance	Supported	Not supported
Multiple Interfaces	Not Java-style	Supported
Memory Management	Manual tools plus automatic object lifetime mechanisms	Automatic garbage collection
Destructor	Supported	No C++-style destructor
Friend Function	Supported	Not supported
Pointer Arithmetic	Supported	Not exposed like C++ pointer arithmetic
Operator Overloading	Supported for user-defined types	Generally not user-defined
Root Class	No universal required root class	Most classes ultimately derive from Object
Platform Model	Native binary is usually platform-specific	Bytecode runs through a compatible JVM

---

🔑 Quick Revision Sheet

Four OOP Pillars

Pillar	Meaning	Main Tool
Encapsulation	Wrap data and functions together	Class
Abstraction	Show essentials and hide internal details	Abstract class, interface
Inheritance	Create a new class from an existing class	Base and derived classes
Polymorphism	One interface, many behaviours	Overloading and overriding

Mnemonic:

EAIP = Every Animal Inherits Properties

---

Class and Object

Class = Blueprint
Object = Instance of class

Example:

Student = Class
s1 = Object

---

Access Specifiers

Specifier	Same Class	Derived Class	Outside
private	Yes	No direct access	No
protected	Yes	Yes	No
public	Yes	Yes	Yes

---

Encapsulation, Data Hiding and Abstraction

Encapsulation = Wrap data and functions
Data hiding   = Restrict direct access
Abstraction   = Show what; hide how

---

Five Inheritance Types

Type	Pattern
Single	A → B
Multiple	A + B → C
Multilevel	A → B → C
Hierarchical	A → B and A → C
Hybrid	Combination of types

Mnemonic:

SMMHH = Smart Minds Make Helpful Humans

---

Diamond Problem

One base class
   ↓       ↓
Two intermediate classes
   ↓       ↓
  One final class

Problem:

Duplicate base-class subobjects and ambiguity

Solution:

Virtual inheritance

Example:

class B : virtual public A
class C : virtual public A

---

Overloading vs Overriding

Overloading	Overriding
Same name, different parameter list	Derived class changes inherited virtual behaviour
Compile time	Runtime when called virtually
Inheritance not required	Inheritance required
Return type alone is insufficient	Signature must satisfy overriding rules

---

Virtual and Pure Virtual Functions

Virtual function:
virtual void show();

Pure virtual function:
virtual void show() = 0;

A class with a pure virtual function is abstract.

An abstract class cannot be directly instantiated.

---

Constructors

Type	Purpose
Default	Called without arguments
Parameterized	Receives initial values
Copy	Initializes from an existing object

Rules:

• Same name as class
• No return type
• Runs automatically
• Can be overloaded
• Cannot be virtual

---

Destructor

~ClassName();

Rules:

• Runs automatically during destruction
• No return type
• No parameters
• Cannot be overloaded
• Can be virtual

---

Friend Function

• Not a member
• Can access private and protected members
• Called like an ordinary function
• Does not have a this pointer
• Friendship is not automatically inherited or transitive

---

this Pointer

this → current object
this->member → current object's member
*this → current object

Not available in:

• Static member functions
• Friend functions

---

C++ Exception Handling

try
{
    if (error)
        throw value;
}
catch (Type value)
{
    // Handle error
}

Keywords:

try, throw, catch

Catch all:

catch (...)

---

Java Program Flow

Source code (.java)
       │
       │ javac
       v
Bytecode (.class)
       │
       │ JVM
       v
Native machine execution

---

JDK, JRE and JVM

JDK = Development tools + Runtime environment
JRE = JVM + Runtime libraries
JVM = Executes bytecode

Mnemonic:

JDK = Develop
JRE = Run
JVM = Execute bytecode

---

Interface vs Abstract Class

Interface	Abstract Class
Contract	Partial base class
implements	extends
Multiple interfaces allowed	Only one direct class parent
No constructors	Can have constructors
No ordinary instance fields	Can have instance fields
Constants and interface methods	Abstract and concrete methods

---

Java Exception Flow

try → risky code
catch → handles matching exception
finally → normally runs for cleanup

throw  → throws an object
throws → declares possible exception types

---

📝 Practice Questions

Questions 1–5: OOP Fundamentals

Question 1

Which OOP concept combines data and related functions inside one unit?

A. Inheritance
B. Encapsulation
C. Compilation
D. Interpretation

---

Question 2

An object is best described as:

A. A compiler
B. A class declaration keyword
C. An instance of a class
D. A header file

---

Question 3

Which OOP concept shows essential features while hiding unnecessary implementation details?

A. Abstraction
B. Inheritance
C. Recursion
D. Overloading

---

Question 4

Which access specifier permits access inside the class and its derived classes but normally not through outside objects?

A. public
B. protected
C. private only
D. friend

---

Question 5

Which list contains all four main OOP pillars?

A. Class, Object, Function and Pointer
B. Encapsulation, Abstraction, Inheritance and Polymorphism
C. Compilation, Linking, Loading and Execution
D. Array, Stack, Queue and Tree

---

Questions 6–10: Inheritance

Question 6

When one derived class inherits from one base class, it is called:

A. Multiple inheritance
B. Multilevel inheritance
C. Single inheritance
D. Hybrid inheritance

---

Question 7

Which inheritance structure represents multilevel inheritance?

A. A → B → C
B. A + B → C
C. A → B and A → C
D. A only

---

Question 8

When Circle, Square and Triangle all inherit from Shape, the inheritance type is:

A. Multiple
B. Hierarchical
C. Multilevel
D. Single only

---

Question 9

In C++, the diamond problem is commonly solved using:

A. Function overloading
B. Virtual inheritance
C. A friend function
D. A destructor

---

Question 10

What is the construction order when a Derived object is created?

A. Derived constructor, then base constructor
B. Base constructor, then derived constructor
C. Only the base constructor
D. Only the derived constructor

---

Questions 11–15: Polymorphism

Question 11

Function overloading is normally an example of:

A. Runtime polymorphism
B. Compile-time polymorphism
C. Data hiding
D. Garbage collection

---

Question 12

Which change alone cannot create a valid function overload?

A. Changing the number of parameters
B. Changing parameter types
C. Changing the order of parameter types
D. Changing only the return type

---

Question 13

Which combination is required for typical runtime polymorphism in C++?

A. Macro and structure
B. Inheritance, overriding and virtual function call
C. File and pointer only
D. Constructor overloading only

---

Question 14

What does the following declaration represent?

virtual void display() = 0;

A. Constructor
B. Friend function
C. Pure virtual function
D. Static function

---

Question 15

A class containing at least one pure virtual function is called:

A. Friend class
B. Abstract class
C. Final object
D. Static class

---

Questions 16–20: C++ Specifics

Question 16

Which statement about a C++ constructor is correct?

A. It must return int.
B. It has the same name as the class.
C. It begins with ~.
D. It can always be virtual.

---

Question 17

Which constructor creates a new object from an existing object of the same class?

A. Default constructor
B. Parameterized constructor
C. Copy constructor
D. Destructor

---

Question 18

Which statement about a friend function is correct?

A. It must be a member of the class.
B. It cannot access private data.
C. It is not a member but can be granted private access.
D. It automatically becomes a friend of every derived class.

---

Question 19

Inside a non-static C++ member function, this points to:

A. The base class only
B. The current object
C. The compiler
D. The next object in memory

---

Question 20

Which sequence correctly represents basic C++ exception handling?

A. catch → try → throw
B. throw → try → catch only
C. try → throw → matching catch
D. finally → throw → try

---

Questions 21–25: Java Basics

Question 21

Which component contains development tools such as the Java compiler?

A. JVM
B. JRE
C. JDK
D. Bytecode

---

Question 22

Which component directly executes Java bytecode?

A. JDK documentation tool
B. JVM
C. Java source file
D. Text editor

---

Question 23

The Java compiler normally converts a .java file into:

A. A .class bytecode file
B. A .cpp file
C. A database table
D. An HTML document

---

Question 24

Which statement correctly compares a Java interface and an abstract class?

A. An interface can have constructors, but an abstract class cannot.
B. A class can implement multiple interfaces but directly extend only one class.
C. An abstract class cannot contain implemented methods.
D. Interface fields are ordinary private instance variables.

---

Question 25

What is the output?

public class Test
{
    public static void main(String[] args)
    {
        try
        {
            int x = 10 / 0;
            System.out.println("Try");
        }
        catch (ArithmeticException e)
        {
            System.out.println("Catch");
        }
        finally
        {
            System.out.println("Finally");
        }
    }
}

A. Try
B. Catch
C. Catch followed by Finally
D. Try followed by Finally

---

✅ Answer Key + Explanations

Answer Key

Q.	Answer	Q.	Answer	Q.	Answer	Q.	Answer	Q.	Answer
1	B	6	C	11	B	16	B	21	C
2	C	7	A	12	D	17	C	22	B
3	A	8	B	13	B	18	C	23	A
4	B	9	B	14	C	19	B	24	B
5	B	10	B	15	B	20	C	25	C

---

Direct Explanations

1. Answer: B — Encapsulation

Encapsulation wraps data and the functions working on that data inside one unit, usually a class.

---

2. Answer: C — An instance of a class

A class is a blueprint. An object is an actual instance created from that blueprint.

Class: Student
Object: s1

---

3. Answer: A — Abstraction

Abstraction shows essential operations and hides unnecessary internal details.

Example:

User calls car.start()

The user does not need to know every internal engine step.

---

4. Answer: B — protected

A protected member is accessible:

• Inside its own class
• Inside derived classes

It is not normally accessible directly through an outside object.

---

5. Answer: B

The four pillars are:

Encapsulation
Abstraction
Inheritance
Polymorphism

Mnemonic:

EAIP

---

6. Answer: C — Single inheritance

Single inheritance has:

One base class → One derived class

Example:

Animal → Dog

---

7. Answer: A — A → B → C

Multilevel inheritance forms a chain.

Animal → Mammal → Dog

---

8. Answer: B — Hierarchical inheritance

One base class has multiple derived classes:

              Shape
            /   |   \
        Circle Square Triangle

---

9. Answer: B — Virtual inheritance

The diamond problem can create two copies of the same base-class subobject.

Virtual inheritance provides one shared virtual base subobject.

class B : virtual public A
class C : virtual public A

---

10. Answer: B — Base, then derived

Construction order:

Base constructor
Derived constructor

Destruction happens in reverse:

Derived destructor
Base destructor

---

11. Answer: B — Compile-time polymorphism

The compiler selects an overloaded function according to its parameter list.

Example:

add(int, int)
add(double, double)

---

12. Answer: D — Changing only the return type

This is invalid:

int getValue();
double getValue();

The calls have identical argument lists, so the compiler cannot choose using only the return type.

---

13. Answer: B

Typical C++ runtime polymorphism requires:

• Inheritance
• A base virtual function
• A derived override
• A call through a suitable base pointer or reference

---

14. Answer: C — Pure virtual function

The = 0 syntax makes it pure virtual:

virtual void display() = 0;

It helps define an abstract interface.

---

15. Answer: B — Abstract class

A class with at least one pure virtual function is abstract.

An abstract class cannot be directly instantiated.

Invalid:

AbstractClass object;

---

16. Answer: B — Same name as the class

Constructor rules:

• Same name as class
• No return type
• Runs automatically
• Can be overloaded
• Cannot be virtual

---

17. Answer: C — Copy constructor

A copy constructor initializes a new object from an existing object.

Common form:

ClassName(const ClassName &other);

---

18. Answer: C

A friend function:

• Is not a class member
• Can access private and protected members when the class grants friendship
• Is called like an ordinary function
• Does not have a this pointer

Friendship is not automatically inherited or transitive.

---

19. Answer: B — The current object

Inside a non-static member function:

this → address of the current object
this->member → member of the current object
*this → current object

Example:

void setValue(int value)
{
    this->value = value;
}

Here, this->value is the data member, while value is the parameter.

---

20. Answer: C — try → throw → matching catch

The normal C++ exception flow is:

try block
    │
    v
Error detected
    │
    v
throw exception
    │
    v
Matching catch block
    │
    v
Exception handled

Example:

try
{
    throw 10;
}
catch (int value)
{
    cout << value;
}

Output:

10

---

21. Answer: C — JDK

JDK stands for Java Development Kit.

It contains:

• Java compiler
• Java launcher
• Runtime components
• Java libraries
• Development tools

The javac compiler is part of the JDK.

Memory rule:

JDK = Develop
JRE = Run
JVM = Execute bytecode

---

22. Answer: B — JVM

JVM stands for Java Virtual Machine.

It executes Java bytecode.

Program flow:

Java source file
      │
      │ javac
      v
Java bytecode
      │
      │ JVM
      v
Machine execution

---

23. Answer: A — A .class bytecode file

The Java compiler normally changes:

Hello.java

into:

Hello.class

The .class file contains Java bytecode.

The JVM executes this bytecode.

---

24. Answer: B

A Java class can:

• Directly extend only one class
• Implement multiple interfaces

Example:

class Machine implements Printable, Scannable
{
    // Implement required methods
}

An interface cannot have a constructor. An abstract class can have constructors and ordinary instance fields.

---

25. Answer: C — Catch followed by Finally

The statement:

int x = 10 / 0;

causes an ArithmeticException.

Therefore:

• "Try" is not printed because execution leaves the try block at the error.
• The matching catch block prints "Catch".
• The finally block prints "Finally".

Output:

Catch
Finally

---

🎓 Final Concept Tests

Complete these tests without looking at the main notes.

---

Test 1 — Identify the Four OOP Pillars

Fill in the missing terms:

1. Wrapping data and functions together: __________
2. Showing essential features and hiding internal details: __________
3. Creating a new class from an existing class: __________
4. One interface with different forms of behaviour: __________

Direct Answers

1. Encapsulation
2. Abstraction
3. Inheritance
4. Polymorphism

Mnemonic:

EAIP = Every Animal Inherits Properties

---

Test 2 — Class and Object

Consider:

class Car
{
public:
    void start()
    {
        cout << "Started";
    }
};

Car c1;
Car c2;

Identify:

• Class: __________
• Objects: __________
• Member function: __________

Direct Answer

Class = Car
Objects = c1 and c2
Member function = start()

Remember:

Class = Blueprint
Object = Instance

---

Test 3 — Encapsulation, Data Hiding and Abstraction

Match each description:

Description	Concept
Place data and related functions in one class	?
Make a data member private	?
Provide a simple start() function while hiding internal engine steps	?

Direct Answer

Description	Concept
Place data and related functions in one class	Encapsulation
Make a data member private	Data hiding
Hide engine steps behind start()	Abstraction

Memory rule:

Encapsulation = Wrap
Data hiding = Restrict
Abstraction = Hide complexity

---

Test 4 — Identify the Inheritance Type

Structure A

Animal
   │
   v
  Dog

Answer:

Single inheritance

Structure B

Writer       Speaker
   \           /
    \         /
      Person

Answer:

Multiple inheritance

Structure C

Animal
   │
   v
Mammal
   │
   v
  Dog

Answer:

Multilevel inheritance

Structure D

        Shape
      /   |   \
  Circle Square Triangle

Answer:

Hierarchical inheritance

Structure E

        Person
       /      \
  Student    Employee
       \      /
       Assistant

Answer:

Hybrid inheritance

---

Test 5 — Diamond Problem

Study the diagram:

              Person
              /    \
         Student  Employee
              \    /
             Assistant

Questions

1. Why can Assistant receive two copies of Person?
2. What problem may occur?
3. What is the C++ solution?

Direct Answers

1. Student and Employee both inherit from Person, and Assistant inherits from both.
2. Duplicate base-class data and ambiguous member access may occur.
3. Use virtual inheritance.

Example:

class Student : virtual public Person
{
};

class Employee : virtual public Person
{
};

Result:

Assistant has one shared Person base subobject.

---

Test 6 — Overloading or Overriding?

Case 1

int add(int a, int b);
double add(double a, double b);

Answer:

Function overloading

Reason:

Same function name, different parameter types

Binding:

Compile time

---

Case 2

class Animal
{
public:
    virtual void sound()
    {
        cout << "Animal";
    }
};

class Dog : public Animal
{
public:
    void sound() override
    {
        cout << "Bark";
    }
};

Answer:

Function overriding

Reason:

Derived class provides a new implementation of a base virtual function

Binding through a base pointer or reference:

Runtime

---

Test 7 — Virtual Function Output

Predict the output:

class Base
{
public:
    virtual void show()
    {
        cout << "Base";
    }

    virtual ~Base() = default;
};

class Derived : public Base
{
public:
    void show() override
    {
        cout << "Derived";
    }
};

int main()
{
    Base *p = new Derived;
    p->show();
    delete p;
}

Direct Solution

• p is a base-class pointer.
• It points to a Derived object.
• show() is virtual.
• Runtime selection uses the actual object type.

Output:

Derived

---

Test 8 — Pure Virtual Function

Consider:

class Shape
{
public:
    virtual double area() const = 0;
};

Questions

1. What type of function is area()?
2. What type of class is Shape?
3. Can Shape be directly instantiated?

Direct Answers

1. Pure virtual function
2. Abstract class
3. No

Invalid:

Shape s;

A concrete derived class must implement area().

---

Test 9 — Constructor Output

Predict the output:

class Test
{
public:
    Test()
    {
        cout << "Default ";
    }

    Test(int value)
    {
        cout << "Parameterized ";
    }
};

int main()
{
    Test a;
    Test b(10);
}

Direct Solution

Test a;

calls the default constructor.

Test b(10);

calls the parameterized constructor.

Output:

Default Parameterized

---

Test 10 — Constructor and Destructor Order

Predict the order:

class Base
{
public:
    Base()
    {
        cout << "Base constructor ";
    }

    ~Base()
    {
        cout << "Base destructor ";
    }
};

class Derived : public Base
{
public:
    Derived()
    {
        cout << "Derived constructor ";
    }

    ~Derived()
    {
        cout << "Derived destructor ";
    }
};

int main()
{
    Derived object;
}

Direct Solution

Construction:

Base constructor
Derived constructor

Destruction:

Derived destructor
Base destructor

Complete output:

Base constructor Derived constructor Derived destructor Base destructor

Memory rule:

Construct: Parent → Child
Destroy: Child → Parent

---

Test 11 — Friend Function

Consider:

class Number
{
private:
    int value;

public:
    Number(int value) : value(value)
    {
    }

    friend void display(const Number &n);
};

void display(const Number &n)
{
    cout << n.value;
}

int main()
{
    Number n(50);
    display(n);
}

Direct Solution

display() is not a member function, but Number declares it as a friend.

It can access the private member value.

Output:

50

---

Test 12 — The this Pointer

Predict the value:

class Number
{
private:
    int value;

public:
    void setValue(int value)
    {
        this->value = value;
    }

    int getValue() const
    {
        return value;
    }
};

int main()
{
    Number n;
    n.setValue(25);
    cout << n.getValue();
}

Direct Solution

Inside setValue():

this->value

means the object’s data member.

The right-side:

value

means the parameter.

The data member receives 25.

Output:

25

---

Test 13 — C++ Exception Trace

Predict the output:

try
{
    cout << "A ";
    throw 5;
    cout << "B ";
}
catch (int value)
{
    cout << value;
}

Direct Solution

1. "A " is printed.
2. throw 5 transfers control to the matching catch.
3. The statement after throw in the try block is skipped.
4. The catch block prints 5.

Output:

A 5

"B " is not printed.

---

Test 14 — JDK, JRE and JVM

Complete the diagram:

__________
   ├── Development tools such as javac
   └── __________
          ├── Runtime libraries
          └── __________ executes bytecode

Direct Answer

JDK
   ├── Development tools such as javac
   └── JRE
          ├── Runtime libraries
          └── JVM executes bytecode

Exam formula:

JDK = JRE + Development tools
JRE = JVM + Runtime libraries

---

Test 15 — Java Compilation

Complete the flow:

Hello.____
    │
    │ Java compiler: ______
    v
Hello.____
    │
    │ ______
    v
Execution

Direct Answer

Hello.java
    │
    │ Java compiler: javac
    v
Hello.class
    │
    │ JVM
    v
Execution

---

Test 16 — Interface vs Abstract Class

Choose the correct feature.

Feature 1

Can have constructors:

Abstract class

Feature 2

A class can use more than one of these:

Interface

Feature 3

Can contain ordinary instance state:

Abstract class

Feature 4

Mainly defines a capability or contract:

Interface

Feature 5

Can contain both abstract and concrete methods:

Abstract class

Modern Java interfaces can also contain default and static methods, but their main purpose remains defining a contract.

---

Test 17 — Java Exception Output

Predict the output:

try
{
    System.out.println("Start");
    int x = 20 / 5;
    System.out.println(x);
}
catch (ArithmeticException e)
{
    System.out.println("Error");
}
finally
{
    System.out.println("End");
}

Direct Solution

The calculation is valid:

20 / 5 = 4

No exception occurs, so the catch block does not run.

The finally block runs.

Output:

Start
4
End

---

🧠 Active Recall Questions

Answer these aloud without reading the main notes.

1. What is Object-Oriented Programming?
2. What is the difference between a class and an object?
3. What are data members and member functions?
4. What are the four OOP pillars?
5. What is encapsulation?
6. What is data hiding?
7. What is abstraction?
8. How is abstraction different from encapsulation?
9. What is inheritance?
10. What is polymorphism?
11. What are the three main C++ access specifiers?
12. Can a derived class directly access a private base-class member?
13. What is single inheritance?
14. What is multiple inheritance?
15. What is multilevel inheritance?
16. What is hierarchical inheritance?
17. What is hybrid inheritance?
18. What is the diamond problem?
19. How does virtual inheritance solve the diamond problem?
20. What is the constructor order in inheritance?
21. What is the destructor order in inheritance?
22. What is compile-time polymorphism?
23. What is runtime polymorphism?
24. What is function overloading?
25. Can functions be overloaded only by changing the return type?
26. What is function overriding?
27. What is a virtual function?
28. What does the override specifier do?
29. What is a pure virtual function?
30. What is an abstract class?
31. Can an abstract class be directly instantiated?
32. Why should a polymorphic base class normally have a virtual destructor?
33. What is a constructor?
34. What are default, parameterized and copy constructors?
35. Can a constructor have a return type?
36. Can a constructor be overloaded?
37. What is a destructor?
38. Can a destructor be overloaded?
39. What is a friend function?
40. Does a friend function have a this pointer?
41. What does the this pointer represent?
42. Is this available in a static member function?
43. What are the three basic C++ exception keywords?
44. What does catch (...) mean?
45. What is stack unwinding?
46. What does JDK stand for?
47. What does JRE stand for?
48. What does JVM stand for?
49. Which component contains javac?
50. Which component executes bytecode?
51. What file extension stores Java source code?
52. What file extension normally stores Java bytecode?
53. Why is Java called platform-independent at the bytecode level?
54. What is a Java interface?
55. What is a Java abstract class?
56. Can a Java class implement multiple interfaces?
57. Can a Java class directly extend multiple classes?
58. What is the purpose of try?
59. What is the purpose of catch?
60. What is the purpose of finally?
61. What is the difference between throw and throws?
62. What is the difference between checked and unchecked exceptions?

---

📊 Self-Assessment

Use your score from the 25 practice questions.

Correct Answers	Level	Required Action
23–25	Excellent	Revise the quick sheet tomorrow
20–22	Good	Review incorrect answers once
16–19	Developing	Repeat inheritance and polymorphism
10–15	Weak	Restudy all five hourly sections
0–9	Beginning	Read the material again from Section 1

Topic-Based Diagnosis

Questions Missed	Topic to Revise
1–5	OOP pillars, class, object and access specifiers
6–10	Inheritance types and diamond problem
11–15	Polymorphism, overloading, overriding and virtual functions
16–20	Constructors, friends, this and exceptions
21–25	JDK, JRE, JVM, bytecode, interfaces and Java exceptions

---

📅 Suggested Five-Hour Study Method

Hour 1 — OOP Foundations

Study:

• Class
• Object
• Access specifiers
• Encapsulation
• Data hiding
• Abstraction
• Four OOP pillars

Write from memory:

Class = Blueprint
Object = Instance

Encapsulation = Wrap
Data hiding = Restrict
Abstraction = Hide complexity

Practice:

1. Create a mental BankAccount class.
2. Identify its data members.
3. Identify its member functions.
4. Decide which members should be private.
5. Explain all four OOP pillars aloud.

---

Hour 2 — Inheritance

Study:

• Single inheritance
• Multiple inheritance
• Multilevel inheritance
• Hierarchical inheritance
• Hybrid inheritance
• Diamond problem
• Virtual inheritance
• Constructor and destructor order

Draw these diagrams from memory:

Single:
A → B

Multiple:
A + B → C

Multilevel:
A → B → C

Hierarchical:
A → B
A → C

Hybrid:
Combination of types

Memorize:

Construction: Base → Derived
Destruction: Derived → Base

Practice:

• Draw all five inheritance diagrams without looking.
• Explain why the diamond problem creates ambiguity.
• Write virtual public in the correct place.

---

Hour 3 — Polymorphism

Study:

• Compile-time polymorphism
• Runtime polymorphism
• Function overloading
• Function overriding
• Virtual functions
• Pure virtual functions
• Abstract classes
• Virtual destructors

Memorize:

Overloading:
Same name + different parameters

Overriding:
Derived class + inherited virtual function

Pure virtual:
virtual void show() = 0;

Practice:

1. Write two overloaded add() functions.
2. Write a base Animal class with virtual sound().
3. Write a Dog override.
4. Explain why return type alone cannot overload a function.
5. Explain why abstract classes cannot be directly instantiated.

---

Hour 4 — C++ Specific Features

Study:

• Default constructor
• Parameterized constructor
• Copy constructor
• Destructor
• Friend function
• this pointer
• Exception handling

Write from memory:

Default constructor:
ClassName();

Parameterized constructor:
ClassName(int value);

Copy constructor:
ClassName(const ClassName &other);

Destructor:
~ClassName();

Practice:

• Trace constructor and destructor order.
• Explain whether a friend function is a class member.
• Use this->value = value.
• Trace one try-throw-catch example.

---

Hour 5 — Java Basics

Study:

• Java source code
• Bytecode
• JDK
• JRE
• JVM
• JIT compiler
• Interface
• Abstract class
• try-catch-finally
• throw and throws

Draw this flow:

Source (.java)
     │
     │ javac
     v
Bytecode (.class)
     │
     │ JVM
     v
Execution

Memorize:

JDK = Develop
JRE = Run
JVM = Execute bytecode

Practice:

1. Reproduce the JDK–JRE–JVM diagram.
2. Write five interface-vs-abstract-class differences.
3. Trace one Java exception output.
4. Explain when finally runs.
5. Explain why Java supports multiple interfaces but not multiple class inheritance.

---

🗂️ One-Minute Exam Revision

Before answering an OOP question, remember:

Four pillars:
Encapsulation, Abstraction, Inheritance, Polymorphism

Five inheritance types:
Single, Multiple, Multilevel, Hierarchical, Hybrid

Diamond solution:
Virtual inheritance

Overloading:
Compile time, different parameters

Overriding:
Runtime, base and derived classes

Pure virtual:
= 0

Constructor:
Same name, no return type

Destructor:
~ClassName, cannot be overloaded

Friend:
Non-member with granted access

this:
Current object

C++ exceptions:
try, throw, catch

Java:
JDK develops
JRE runs
JVM executes bytecode

Java interface:
Contract, multiple interfaces allowed

Java abstract class:
Partial base class, constructors and instance state allowed

Java exceptions:
try, catch, finally

---

🎯 Day 5 Completion Checklist

• Can explain all 4 OOP pillars with examples
• Know all 5 inheritance types with diagrams
• Overloading vs Overriding comparison clear
• JDK vs JRE vs JVM differences clear