Question 1

Explain the four pillars of Object Oriented Programming (OOP) and provide code examples for each pillar in Java.

Accepted Answer

The four pillars of Object Oriented Programming are Encapsulation, Abstraction, Inheritance, and Polymorphism. Below are detailed explanations with code examples for each:

1. Encapsulation: This is the bundling of data (attributes) and methods (functions) that operate on the data into a single unit or class. Access to this data is restricted to prevent unauthorized access. 
   ```java
   class Account {
       private double balance;
       
       public void deposit(double amount) {
           if (amount > 0) {
               balance += amount;
           }
       }
       
       public double getBalance() {
           return balance;
       }
   }
   ```

2. Abstraction: It is the concept of hiding the complex reality while exposing only the necessary parts. Abstraction can be achieved through abstract classes and interfaces.
   ```java
   abstract class Shape {
       abstract void draw();
   }
   
   class Circle extends Shape {
       void draw() {
           System.out.println("Drawing a Circle");
       }
   }
   ```

3. Inheritance: It is a mechanism where a new class inherits the properties and behavior (methods) of another class. This helps in code reusability.
   ```java
   class Animal {
       void sound() {
           System.out.println("Animal makes a sound");
       }
   }
   
   class Dog extends Animal {
       void sound() {
           System.out.println("Dog barks");
       }
   }
   ```

4. Polymorphism: It allows methods to do different things based on the object it is acting upon. The two types of polymorphism are compile-time (method overloading) and runtime (method overriding).
   ```java
   class Bird {
       void fly() {
           System.out.println("Bird is flying");
       }
   }
   
   class Sparrow extends Bird {
       void fly() {
           System.out.println("Sparrow is flying");
       }
   }
   ```
   By using these four pillars effectively, developers can create robust and maintainable software applications.

Question 2

What is the difference between primary, foreign, and unique keys in Oracle databases?

Accepted Answer

In Oracle databases, keys are crucial for enforcing data integrity and establishing relationships between tables. Here’s a breakdown of primary keys, foreign keys, and unique keys:

1. Primary Key: A primary key uniquely identifies each record in a table. It cannot contain NULL values and must contain unique values.
   ```sql
   CREATE TABLE Employees (
       EmployeeID INT PRIMARY KEY,
       EmployeeName VARCHAR(100)
   );
   ```

2. Foreign Key: A foreign key is a field (or collection of fields) in one table that refers to the primary key in another table. This creates a relationship between the two tables, helping to maintain referential integrity.
   ```sql
   CREATE TABLE Orders (
       OrderID INT PRIMARY KEY,
       EmployeeID INT,
       FOREIGN KEY (EmployeeID) REFERENCES Employees(EmployeeID)
   );
   ```

3. Unique Key: A unique key constraint ensures all values in a column are unique, similar to a primary key, but it can contain NULL values. Each table can have multiple unique keys.
   ```sql
   CREATE TABLE Products (
       ProductID INT PRIMARY KEY,
       ProductCode VARCHAR(50) UNIQUE
   );
   ```

In summary, a primary key uniquely identifies a record and does not allow NULLs, a foreign key establishes a relational link between tables, and a unique key ensures uniqueness but allows NULL values. Proper use of these keys is essential for maintaining data integrity in your Oracle databases.

Question 3

Explain how you would implement a binary tree and perform a depth-first search (DFS) in Python.

Accepted Answer

A binary tree is a hierarchical data structure in which each node has at most two children, referred to as the left child and the right child. A depth-first search (DFS) can be implemented using recursion or a stack. Here’s how you can implement a binary tree and perform DFS:

1. Binary Tree Node Definition:
```python
class TreeNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None
```

2. DFS Implementation (using recursion):
```python
def dfs_recursive(node):
    if node:
        print(node.value)  # Process the current node
        dfs_recursive(node.left)  # Explore left subtree
        dfs_recursive(node.right)  # Explore right subtree
```

3. Example Usage:
```python
if __name__ == '__main__':
    root = TreeNode(1)
    root.left = TreeNode(2)
    root.right = TreeNode(3)
    root.left.left = TreeNode(4)
    root.left.right = TreeNode(5)

print('Depth-First Search (DFS) Traversal:')
    dfs_recursive(root)  # Outputs: 1, 2, 4, 5, 3
```

In this example, we create a simple binary tree and implement a recursive DFS function. The function processes the current node and then recursively traverses the left and right subtrees. This will print the node values in a pre-order fashion.

Question 4

How do you traverse a linked list in Oracle PL/SQL?

Accepted Answer

In Oracle PL/SQL, a linked list can be implemented using a user-defined type and an object type. To traverse a linked list, you would follow the pointers from one node to the next until you reach the end of the list.

### Linked List Implementation
Here’s how you can define and traverse a simple linked list:
```sql
CREATE OR REPLACE TYPE Node AS OBJECT (
    value NUMBER,
    next_node REF Node
);
/

CREATE OR REPLACE TYPE LinkedList AS OBJECT (
    head REF Node
);
/

DECLARE
    current_node REF Node;
    my_list LinkedList := LinkedList(NULL);
    new_node REF Node;
BEGIN
    -- Creating nodes
    new_node := Node(1, NULL);
    my_list.head := new_node;
    new_node.next_node := Node(2, NULL);
    new_node.next_node.next_node := Node(3, NULL);

-- Traversing the linked list
    current_node := my_list.head;
    WHILE current_node IS NOT NULL LOOP
        DBMS_OUTPUT.PUT_LINE(current_node.value);
        current_node := current_node.next_node;
    END LOOP;
END;
/
```
In this example, we create a simple linked list with three nodes. The `WHILE` loop traverses the list by following the `next_node` references until it reaches a `NULL` reference, effectively printing the values of each node. Make sure to handle cases where the list might be empty (i.e., `my_list.head` is NULL).

Question 5

What should I include in my preparation for an Oracle interview?

Accepted Answer

Preparing for an Oracle interview involves several key steps. First, familiarize yourself with common data structures and algorithms as they are frequently tested. Utilize platforms like LeetCode or HackerRank to practice coding problems. Additionally, review system design principles, as Oracle often assesses your ability to architect scalable solutions. For instance, you might be asked to design a URL shortener service. Outlining the components:
- A database to store the mapping of short URLs to long URLs.
- A service to generate unique short URLs.
- A redirection service to handle incoming requests.

Then, be ready to discuss trade-offs between different database choices (SQL vs NoSQL) and scaling strategies. Lastly, prepare for behavioral questions by reflecting on your past experiences and aligning them with Oracle's values.

SarthiQ

Interview Preparation Guide

Oracle
Questions & Answers

Document Details

Need Help?

Top Oracle Interview Questions

Oracle Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Interview Preparation Guide

OracleQuestions & Answers

Document Details

Need Help?

Top Oracle Interview Questions

Oracle Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Oracle
Questions & Answers