Freshers Interview Questions & Answers

class Dog { // Class: blueprint for objects
    String name; // Attribute
    void bark() { // Method
        System.out.println(name + " barks!");
    }
}

age = 30           # age is an integer variable
name = "Alice"     # name is a string variable
is_student = True  # is_student is a boolean variable
height = 1.75      # height is a float variable

def find_max(numbers):
    if not numbers:
        return None
    max_num = numbers[0] # Step 1
    for num in numbers[1:]: # Steps 2-3
        if num > max_num: # Step 4
            max_num = num
    return max_num # Step 5

my_list = [3, 1, 4, 1, 5, 9, 2]
print(find_max(my_list)) # Output: 9

def factorial(n):
    if n == 0 or n == 1: # Base case
        return 1
    else:
        return n * factorial(n - 1) # Recursive call

print(factorial(5)) # Output: 120 (5 * 4 * 3 * 2 * 1)

CREATE TABLE Departments (
    DepartmentID INT PRIMARY KEY,
    DepartmentName VARCHAR(50)
);

CREATE TABLE Employees (
    EmployeeID INT PRIMARY KEY,
    FirstName VARCHAR(50),
    LastName VARCHAR(50),
    DepartmentID INT,
    FOREIGN KEY (DepartmentID) REFERENCES Departments(DepartmentID)
);

# Initialize a new Git repository
git init

# Add all current files to the staging area
git add .

# Commit the staged changes with a message
git commit -m "Initial project setup"

# Create a new branch
git branch feature/new-login

try:
    numerator = int(input("Enter a numerator: "))
    denominator = int(input("Enter a denominator: "))
    result = numerator / denominator
    print(f"Result: {result}")
except ValueError:
    print("Error: Invalid input. Please enter integers only.")
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

# Array (Python list behaves like a dynamic array)
my_array = [10, 20, 30, 40]
print(my_array[1]) # Access by index: 20

# Conceptual Linked List node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class BankAccount {
    private double balance; // Private attribute, encapsulated

    public BankAccount(double initialBalance) {
        if (initialBalance >= 0) {
            this.balance = initialBalance;
        } else {
            this.balance = 0;
        }
    }

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

    // Public method to modify balance (setter-like for deposit)
    public void deposit(double amount) {
        if (amount > 0) {
            this.balance += amount;
        }
    }
}

# This function calculates the factorial of a number recursively.
# It takes a non-negative integer 'n' as input.
def factorial(n):
    if n == 0 or n == 1:
        return 1 # Base case: factorial of 0 or 1 is 1
    else:
        return n * factorial(n - 1) # Recursive step

class Car {
    String make;
    String model;
    int year;

    // Constructor
    public Car(String make, String model, int year) {
        this.make = make; // Initialize instance variables
        this.model = model;
        this.year = year;
        System.out.println("Car object created: " + year + " " + make + " " + model);
    }
}

// Usage:
// Car myCar = new Car("Toyota", "Camry", 2023);

# Stack (using Python list as a stack)
stack = []
stack.append('A') # Push
stack.append('B')
print(stack.pop()) # Pop: B

# Queue (using Python's collections.deque)
from collections import deque
queue = deque()
queue.append('X') # Enqueue
queue.append('Y')
print(queue.popleft()) # Dequeue: X

String s1 = new String("hello");
String s2 = new String("hello");
String s3 = s1;

System.out.println(s1 == s2);        // Output: false (different objects)
System.out.println(s1.equals(s2));   // Output: true (same content)
System.out.println(s1 == s3);        // Output: true (same object reference)

import threading
import os

def task():
    print(f"Thread running in process: {os.getpid()}")

# A process (main program)
print(f"Main process ID: {os.getpid()}")

# A thread within the main process
t = threading.Thread(target=task)
t.start()
t.join()

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

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

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog(); // Polymorphic reference
        Animal myCat = new Cat(); // Polymorphic reference

        myDog.makeSound(); // Output: Dog barks
        myCat.makeSound(); // Output: Cat meows
    }
}

SELECT E.EmployeeName, D.DepartmentName
FROM Employees E
INNER JOIN Departments D ON E.DepartmentID = D.DepartmentID;

// Interface: Defines a contract
interface Drivable {
    void drive(); // implicitly public abstract
}

// Abstract Class: Provides partial implementation
abstract class Vehicle {
    String brand;
    public Vehicle(String brand) { this.brand = brand; }
    abstract void start(); // Abstract method
    void stop() { System.out.println(brand + " stopped."); } // Concrete method
}

package com.example.app;

class MyClass {
    public int publicVar = 1;
    private int privateVar = 2;
    protected int protectedVar = 3;

    public void publicMethod() {
        System.out.println("Public method accessed.");
    }
}

// In another class within the same package:
// MyClass obj = new MyClass();
// obj.publicVar; // Accessible
// obj.privateVar; // Not accessible
// obj.protectedVar; // Accessible

c++
void callByValue(int x) {
    x = x + 10; // Changes copy of x
}

void callByReference(int &y) {
    y = y + 10; // Changes original y
}

int main() {
    int a = 5;
    callByValue(a);
    // a is still 5

    int b = 5;
    callByReference(b);
    // b is now 15
}

# Python dictionary (a common implementation of a hash map)
student_grades = {
    "Alice": 95,
    "Bob": 88,
    "Charlie": 92
}

# Adding a new key-value pair
student_grades["David"] = 79

# Accessing a value by key (fast lookup)
print(student_grades["Alice"]) # Output: 95

# Checking if a key exists
print("Eve" in student_grades) # Output: False