CS Free MCQ Bank

[ Option C ]

Inheritance is a fundamental concept in object-oriented programming (OOP) where one class acquires the properties (data fields) and methods of another class. The class inheriting the properties is called the derived class or subclass or child class, while the class from which it inherits is called the base class or superclass or parent class. Inheritance promotes code reusability.

[ Option B ]

Data Abstraction is the separation of the logical view of data from its implementation details. It allows users to interact with data at a high level without needing to understand the complex underlying details of how data is stored or manipulated. For example, in a database, users can query employee names and salaries without knowing the underlying storage structure or file formats.

[ Option A ]

In object-oriented programming, an entity is represented using a class, which contains both data (properties) and functions (behaviors).
Encapsulation is the concept of binding or wrapping data members and member functions together into a single unit. This single unit is called a class. It helps in organizing code and protecting data from unauthorized access.

[ Option D ]

A constructor is a special member method in a class that automatically called when an object of that class is created. Its main purpose is to initialize the newly created object, such as setting initial values for its attributes. The name of constructor method is same as name the class and no return type (not even void).

public class Bike {
    String modelName;
    public Bike(String model) {
        modelName = model;
    }
    public void display() {
        System.out.println("Bike Model Name : " + modelName);
    }
    public static void main(String args[]) {
        Bike obj = new Bike("Rampayari");
        obj.display();
    }
}
OUTPUT
Bike Model Name : Rampayari

An exception is an unwanted or unexpected event that occurs during the execution of a program and disrupts the normal flow. It indicates that an error or unexpected condition has occurred.

• Exceptions are objects derived from the Throwable class in Java.
• They can be caught and handled using try-catch blocks to prevent program termination.

public class ExceptionExample {
    public static void main(String args[]) {
        try {
            int result = 10/0;
        } catch (ArithmeticException e) {
            System.out.println("Exception Occurred.");
            System.out.println("Error: Cannot divide by zero");
        }
    }
}

A bitmap is a type of digital image made of pixels arranged in a grid. Bitmaps are commonly stored in files with extensions like .bmp.

Type casting refers to converting a value from one data type to another. In Java, type casting can be implicit (Widening) or explicit (Narrowing).

• In implicit type casting, the conversion is done from a smaller type to a larger type, such as int → long → float → double, while in explicit type casting, the conversion is done from a larger type to a smaller type, such as double → int.

[ Option B ]

Object-Oriented Programming (OOP) is a programming paradigm based on objects, which contain data and methods (code to manipulate that data).

[ Option D ]

Object-Oriented Programming (OOP) is based on several core principles, often called the pillars of OOP.
Encapsulation: Combining data and functions into a single unit (class) and restricting direct access to some of the object’s components.
Inheritance: Creating a new class from an existing class to reuse code and extend functionality.
Abstraction: Hiding the complex implementation details and showing only the essential features to the user.
Polymorphism: Allowing objects to behave differently based on their data type or class.

[ Option A ]

In procedural programming languages, all function calls are typically resolved at compile-time, because the functions are fixed and there is no concept of dynamic binding or late binding.
In object-oriented programming languages, not all function calls are resolved at compile-time. Functions that are declared as virtual are resolved at run-time using dynamic binding to support polymorphism. Only non-virtual functions are resolved at compile-time.

[ Option B ]

Polymorphism in C++ means "one name, many forms", where the same function or operator can behave differently depending on the context (data types or implementations). C++ primarily supports two main types of polymorphism:

Compile-Time Polymorphism: Also called static or early binding, this is resolved during compilation and includes function overloading (same function name with different parameter lists) and operator overloading (redefining operators for user-defined data types).

class Demo
{
    public:
        void show(int a) { cout <<"Value: " << a; }
        void show(double b) { cout <<"Value: " << b; }
};

Run-Time Polymorphism: Also called dynamic or late binding, this is resolved during program execution and is achieved through inheritance and the use of virtual functions (function overriding).

class Base
{
    public:
        virtual void display() { cout <<"Base Class Version."; }
};
class Derived : public Base
{
    public:
        void display() { cout << "Derived Class Version."; }
};

[ Option A ]

In object-oriented programming, if an entity behave in more than one form is called polymorphism. The same function, object, or operator can behave differently in different situations.

[ Option A ]

In object-oriented programming, abstraction means showing only the essential features of an object while hiding unnecessary background details.

• It focuses on what an object does, not how it does it.
• Abstraction helps reduce complexity and makes programs easier to understand and use.

[ Option C ]

In object-oriented programming, encapsulation refers to the wrapping of data (variables) and functions (methods) into a single unit, usually a class. This concept ensures that the internal representation of an object is hidden from the outside, and access to the data is only allowed through public methods. 

[ Option B ]

The first Object-Oriented Programming (OOP) language was Simula, introducing key concepts like classes, objects, and inheritance. It was developed in the 1960s by Ole-Johan Dahl and Kristen Nygaard.

• Smalltalk is a fully object-oriented programming language, where everything is treated as an object. However, it was developed after Simula.
• C++ is an extension of the C programming language that adds object-oriented features such as classes, inheritance, and polymorphism. Since it was developed much later than Simula.
• Pascal is primarily a procedural programming language. It focuses on structured programming concepts.

[ Option D ]

A pure Object-Oriented Programming (OOP) language is one that fully supports the key principles of object-oriented programming called PIE (Polymorphism Inheritance Encapsulation) principle. 
Encapsulation: Wrapping data and functions together in a single unit (class) and restricting direct access to some of the components.
Inheritance: Ability of a class to acquire properties and behaviors from another class.
Polymorphism: Ability to take multiple forms, functions or objects to take multiple forms, enabling dynamic behavior.

[ Option C ]

Object-Oriented Programming (OOP) is built on PIE principles, Polymorphism, Inheritance and Encapsulation. Among these, inheritance is the key feature that significantly boosts code reusability.

Inheritance allows a new class (subclass or derived or child class) to acquire the properties and behavior (data and methods) of an existing class (superclass or base or parent class). This means that the subclass reuses the code already written in the parent class without needing to rewrite it.

• This code reusability minimizes redundancy, enhances programming efficiency, and makes maintenance easier by keeping common code centralized within the base class.

[ Option C ]

A programming language is called extensible if it allows the programmer to create new data types in addition to the predefined ones. This feature provides flexibility to model real-world entities and improve code reusability. For example, C++ allows users to define classes, structures, and typedef, which are user-defined types.