My OOP Interview Experience - Lessons Learned and Knowledge Gained

Hello fellow developers and job seekers! 👋

I recently had an interview for an entry-level software engineering position. During the interview, I was asked several questions and I struggled with some of them ☹️. But that struggle led me to dive deeper into these topics, and now I’m excited to share what I’ve learned with you all 🤗, especially focusing on some key Object-Oriented Programming (OOP) concepts that came up.

Let’s discuss...

Q1: What’s the difference between C and Java?

At the time, I struggled to give a solid answer, but here’s what I’ve learned since then,

• Language Paradigm - C is primarily a procedural language, while Java is object-oriented. This fundamental difference shapes how we approach problem-solving in each language.
• Level of Abstraction- C is considered a middle-level language, closer to hardware. Java, on the other hand, is a high-level language, provides more abstraction from the underlying system.
• Approach - C follows a top-down approach, dividing the program into functions. Java, being object-oriented, organizes code into objects that contain both data and methods.
• Memory Management - C requires manual memory management, while Java has automatic garbage collection.

Q2: Why do you say C is not an OOP language?

This question made me realize I needed to brush up on my OOP fundamentals 😬!

C lacks built-in support for key OOP concepts such as,

• No native support for classes or objects
• Lacks inheritance mechanisms
• No built-in polymorphism
• Encapsulation is possible but not as straightforward as in OOP languages

While you can implement OOP-like structures in C (using structs and function pointers), it doesn’t have native language constructs to support OOP paradigms.

Q3: What are the 4 OOP concepts?

I knew these, but the interviewer wanted more depth 😮‍💨.

The four main pillars of OOP are,

1. Abstraction: Hiding complex implementation details and showing only the necessary features of an object.
2. Encapsulation: Bundling the data and the methods that operate on that data within one unit (i.e., class).
3. Inheritance: Allowing a class to inherit properties and methods from another class.
4. Polymorphism: The ability of objects to take on multiple forms.

Then the interviewer focused on encapsulation.

Q4: What is encapsulation?

Encapsulation is about wrapping up data and methods into a single unit (a class). It’s like creating a protective shield around the information inside the class.

Q5: How to ensure data privacy using encapsulation?

Encapsulation is key to data privacy. By declaring instance variables as “private”, they cannot be accessed or modified directly from outside the class. Instead, you provide “public” getter and setter methods to control how data is accessed and updated. This not only protects the integrity of the data but also allows you to introduce additional logic when getting or setting values.

Q6: How do you implement encapsulation at the code level?

Based on my post-interview research, here’s a Java example to illustrate encapsulation,

public class BankAccount {
    private double balance;  // Private instance variable

    // Public getter method
    public double getBalance() {
        return balance;
    }

    // Public setter method
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
}

In above example,

• The “balance” variable is private, so it can't be accessed directly from outside the class.
• We provide public methods (getBalance(), anddeposit()) to interact with the balance.
• These methods allow us to add logic (like checking for positive amounts) to control how the balance is modified.

Polymorphism was another area where the interviewer dug deep. 🥵

Q7: What is polymorphism?

Polymorphism refers to the ability of a single function or method to work in different ways depending on the context. This allows for flexibility and the ability to reuse code.

In OOP, this usually manifests in two ways,

1. Compile-time polymorphism (Method Overloading): Multiple methods in the same class have the same name but different parameter signatures (number of parameters, name of parameters, order of parameters).
2. Runtime polymorphism (Method Overriding): A subclass provides a specific implementation for a method that’s already defined in its superclass.

Q8: Can you give an example usage of polymorphism?

Here’s an example using method overloading (compile-time polymorphism)to calculate the area of different shapes.

public class ShapeCalculator {
    // Calculate area of a square
    public double calculateArea(double side) {
        return side * side;
    }

    // Calculate area of a rectangle
    public double calculateArea(double length, double width) {
        return length * width;
    }

    // Calculate area of a circle
    public double calculateArea(double radius) {
            return Math.PI * radius * radius;
    }

    // Calculate area of a triangle
    public double calculateArea(double base, double height) {
            return 0.5 * base * height;
    }
}

Q9: Explain a place you used overriding in your project.

I answered this question, but not as well as the following answer 😒.

In my internship, I was responsible for creating the map report feature for a genealogy application, which displays all family members in a family tree on a map. One of the key requirements was to support multiple map themes, such as vintage, street, and others.

To make this happen, I used the Factory Design Pattern along with method overriding. It allowed me to create a centralized factory class responsible for generating different map themes. Each map theme was represented by a separate class that was inherited from a common base class, let’s call it “MapTheme”.

Here’s where method overriding comes into play. The “MapTheme” class had a method called “generateMap()”, which outlined the basic steps for creating a map. However, since each theme has its own style and characteristics, I overrode the “generateMap()” method in each subclass to customize the map generation process according to the theme. For example,

• The “VintageMapTheme” class overrode the “generateMap()” method to apply vintage colors, fonts, and markers.
• The “StreetMapTheme” class overrode the “generateMap()” method to use modern street map features and styling.

This approach not only allowed for code reuse but also made it easy to add new themes in the future by simply creating a new subclass and overriding the “generateMap()” method with the specific implementation.

Q10: Why use overriding and overloading?

• Overloading allows us to use the same method name for similar operations, improving code readability and reducing the need to remember multiple method names.
• Overriding enables us to provide specific implementations in subclasses, allowing for more flexible and extensible code.

That was a lot to cover, but I hope you found it as enlightening as I did 😍. This experience taught me the importance of not just knowing concepts, but understanding them deeply.

In my next post, I’ll share more questions from the interview, covering other programming concepts.

Have you had similar interview experiences? What OOP concepts do you find most challenging? Let’s discuss in the comments 😃!

Refernces

What Is Encapsulation?

Encapsulation in Java - GeeksforGeeks

What is Procedural Language? - GeeksforGeeks

OOP Concepts for Beginners: What is Polymorphism - Stackify