Question 1

What are the key differences between a Class and an Object in Object-Oriented Programming? Illustrate with examples.

Accepted Answer

In Object-Oriented Programming, a Class is a blueprint for creating Objects. It defines properties and behaviors (methods) that the created Objects will have. An Object is an instance of a Class.

Class: A template that describes the data and behavior of the objects. 
Object: A specific instance of a Class containing actual values.

Example:
```python
class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model

def display_info(self):
        return f'Car Make: {self.make}, Model: {self.model}'

# Creating objects of the class
car1 = Car('Toyota', 'Corolla')
car2 = Car('Honda', 'Civic')

# Accessing properties and methods
print(car1.display_info())  # Output: Car Make: Toyota, Model: Corolla
print(car2.display_info())  # Output: Car Make: Honda, Model: Civic
```
In this example, `Car` is the Class, and `car1` and `car2` are the Objects created from the `Car` Class. Each Object has its own attributes (`make` and `model`), demonstrating the key differences.

Question 2

Explain the different types of SQL JOINs and provide examples of each. How can you use JOINs to retrieve data from multiple tables?

Accepted Answer

SQL JOINs are used to combine rows from two or more tables based on a related column between them. The main types of JOINs are INNER JOIN, LEFT JOIN, RIGHT JOIN, and FULL OUTER JOIN.

1. INNER JOIN: Returns records that have matching values in both tables.

```sql
SELECT customers.name, orders.amount
FROM customers
INNER JOIN orders ON customers.id = orders.customer_id;
```

2. LEFT JOIN: Returns all records from the left table and the matched records from the right table. If there is no match, NULL values are returned.

```sql
SELECT customers.name, orders.amount
FROM customers
LEFT JOIN orders ON customers.id = orders.customer_id;
```

3. RIGHT JOIN: Returns all records from the right table and the matched records from the left table. If there is no match, NULL values are returned.

```sql
SELECT customers.name, orders.amount
FROM customers
RIGHT JOIN orders ON customers.id = orders.customer_id;
```

4. FULL OUTER JOIN: Returns all records when there is a match in either left or right table records. Records without a match will show NULL for the other table’s columns.

```sql
SELECT customers.name, orders.amount
FROM customers
FULL OUTER JOIN orders ON customers.id = orders.customer_id;
```

These JOINs enable you to retrieve comprehensive data across multiple related tables, enhancing the analysis and reporting capabilities of your database queries.

Question 3

Describe the core concepts of React components and props. How do you pass data between components? Provide an example.

Accepted Answer

In React, components are the building blocks of the UI. They are reusable pieces of code that return React elements to render on the screen. Props, short for properties, are a way to pass data from parent components to child components, enabling dynamic rendering. Here's a simple example: ```javascript import React from 'react'; function Greeting({ name }) { return

Hello, {name}!

; } function App() { return ; } export default App; ``` In this example, the `Greeting` component accepts a prop called `name`. The `App` component renders `Greeting` and passes the string 'Alice' as a prop. This demonstrates how props are used to convey data down the component tree, allowing for a more dynamic and interactive user interface. Edge cases such as missing props can be handled using default props or prop types for validation, ensuring that components behave correctly even with varying input.

Question 4

What is polymorphism in Object-Oriented Programming? Provide an example that demonstrates method overriding and method overloading.

Accepted Answer

Polymorphism is a core concept in Object-Oriented Programming that allows objects of different classes to be treated as objects of a common superclass. It supports method overriding and method overloading.

Method Overriding: A subclass provides a specific implementation of a method that is already defined in its superclass.

Example:
```python
class Animal:
    def make_sound(self):
        return 'Some sound'

class Dog(Animal):
    def make_sound(self):
        return 'Bark'

class Cat(Animal):
    def make_sound(self):
        return 'Meow'

# Example Usage
animals = [Dog(), Cat()]
for animal in animals:
    print(animal.make_sound())  # Output: Bark
                        # Output: Meow
```

Method Overloading: Multiple methods with the same name can exist but with different parameters. Python does not support method overloading directly, but we can achieve similar functionality using default arguments.

Example:
```python
class Math:
    def add(self, a, b, c=0):
        return a + b + c

# Example Usage
math = Math()
print(math.add(2, 3))     # Output: 5
print(math.add(2, 3, 4))  # Output: 9
```
Polymorphism allows for flexible and reusable code, enabling developers to invoke methods across different classes seamlessly.

Question 5

Explain the concept of execution context in JavaScript and how closures work. Provide a code example that illustrates the use of closures.

Accepted Answer

In JavaScript, the execution context is an abstract concept that holds information about the environment within which JavaScript code is executed. It consists of the variable scope, the value of 'this', and the code being executed. Every time a function is invoked, a new execution context is created.

Closures are a feature of JavaScript where an inner function has access to the outer function's variables even after the outer function has finished execution. Here's an example:

```javascript
function makeCounter() {
    let count = 0; // This variable is enclosed in the closure
    return function() {
        count++; // The inner function can access 'count'
        return count;
    };
}

const counter = makeCounter();
console.log(counter()); // Output: 1
console.log(counter()); // Output: 2
console.log(counter()); // Output: 3
```
In this example, `makeCounter` creates a private variable `count` which is maintained even after the outer function is executed. Each time `counter` is called, it increments and returns the count. This demonstrates the power of closures in managing state in JavaScript without exposing it to the global scope.

SarthiQ

Interview Preparation Guide

Uber
Questions & Answers

Document Details

Need Help?

Top Uber Interview Questions

Uber Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Frontend Developer

Software Engineer

Interview Preparation Guide

UberQuestions & Answers

Document Details

Need Help?

Top Uber Interview Questions

Uber Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Frontend Developer

Software Engineer

Uber
Questions & Answers