Interview Questions Flashcards
What is git? How do we use it?
Git is distributed version control system that allows multiple developers to collaborate on a project. It tracks the changes in the source code during software development and helps coordinate work among team members.
git add -A, git commit -m “message”, git pull, and git push are some of the commands u can use in the command line interface/terminal to interact with git after installing and configuring it.
git log to view commit history
What is a variable? Can you give an example of an integer expression? A boolean expression?
In programming, a variable is a symbolic name associated with a value or memory location that can be changed during the execution of a program. Variables allow you to store and manipulate data in your programs.
Here are examples of integer and boolean expressions:
Integer Expression Example:
int x = 5; // Declares an integer variable named ‘x’ and assigns the value 5 to it.
int y = 10;
int result = x + y; // Creates an integer expression by adding the values of ‘x’ and ‘y’.
System.out.println(result); // Prints the result, which is 15.
In this example, x and y are integer variables, and result is another integer variable that stores the sum of x and y. The expression x + y is an integer expression.
Boolean Expression Example:
boolean isTrue = true; // Declares a boolean variable named ‘isTrue’ and assigns the value true to it.
boolean isFalse = false;
boolean result = isTrue && isFalse; // Creates a boolean expression using the logical AND operator.
System.out.println(result); // Prints the result, which is false.
In this example, isTrue and isFalse are boolean variables. The expression isTrue && isFalse is a boolean expression that uses the logical AND operator, which evaluates to false because both conditions are not true.
In summary, a variable is a container for storing data, and integer and boolean expressions involve manipulating integer and boolean values, respectively, through various operations and operators.
What controls whether the “if” or “else”portion of an if-else statement should execute?
The if-else statement in programming is used to make decisions based on the evaluation of a condition. The condition, which is a boolean expression, controls whether the if or else portion of the statement should execute.
Here’s how it works:
• The if portion of the statement executes if the condition evaluates to true. If the condition is true, the code within the if block is executed. • The else portion, if present, executes if the condition in the if statement evaluates to false. If the condition is false, the code within the else block is executed.
Here’s a simple example in Java:
int x = 10;
if (x > 5) {
System.out.println(“x is greater than 5”);
} else {
System.out.println(“x is not greater than 5”);
}
In this example, the condition x > 5 is evaluated. If it’s true, the first println statement is executed; otherwise, the second one is executed. The condition controls the flow of execution between the if and else blocks. If you omit the else part, only the if block is executed when the condition is true, and nothing happens when it’s false.
Why should the code for each if or else be enclosed in a scope “{}” ?
In Java, the code for each if or else statement should be enclosed in a scope {} for several reasons:
-
Block Definition:
- Java uses blocks to define the scope of code for
if,else, loops, and other control structures. Using braces{}explicitly defines the block, making it clear where the code associated with theiforelsestarts and ends.
- Java uses blocks to define the scope of code for
-
Multiple Statements:
- When an
iforelsestatement has more than one statement inside, using braces is necessary to group those statements into a single block. Without braces, only the immediately following statement is considered part of theiforelseblock.
- When an
-
Avoiding Ambiguity:
- Using braces eliminates ambiguity and prevents common mistakes. If braces are not used, adding a new statement without updating the indentation might lead to incorrect behavior. Braces provide a clear visual indication of the block structure, reducing the chances of errors.
-
Consistency and Readability:
- Enclosing code in braces promotes consistency and enhances code readability. A consistent coding style helps developers understand the structure of the code. Even if a block contains only one statement, using braces ensures consistency throughout the codebase.
Here’s an example to illustrate the importance of using braces in Java:
```java
int x = 10;
// Incorrect usage without braces
if (x > 5)
System.out.println(“x is greater than 5”);
System.out.println(“This statement is always executed, regardless of the condition”);
// Correct usage with braces
if (x > 5) {
System.out.println(“x is greater than 5”);
System.out.println(“This statement is only executed if the condition is true”);
}
~~~
In the incorrect usage without braces, only the first System.out.println is conditional, while the second one is always executed. Using braces ensures that both statements are part of the if block.
What programming problem does a loop solve? Why would we use a loop?
A loop in programming is a construct that allows a set of instructions to be repeated multiple times. Loops are used to solve problems that involve the repetition of a certain block of code or the iteration over a collection of data. They provide a way to execute the same set of instructions multiple times without having to duplicate code.
Here are common scenarios where loops are used and the problems they solve:
-
Iteration Over Collections:
- Problem: When you have a collection of elements (like an array or list) and you need to perform the same operation on each element.
-
Solution: Use a loop (e.g.,
fororforeachloop) to iterate over the collection, executing the desired code for each element.
java int[] numbers = {1, 2, 3, 4, 5}; for (int number : numbers) { System.out.println(number); } -
Executing Code a Specific Number of Times:
- Problem: When you need to execute a block of code a known number of times.
-
Solution: Use a loop (e.g.,
fororwhileloop) with a defined condition to control the number of iterations.
java for (int i = 0; i < 5; i++) { System.out.println("Iteration " + i); } -
Dynamic Repetition Based on a Condition:
- Problem: When you need to repeat a block of code based on a certain condition that may change during program execution.
-
Solution: Use a
whileordo-whileloop to dynamically repeat the code until the condition is no longer met.
java int x = 0; while (x < 5) { System.out.println("Value of x: " + x); x++; } -
Algorithmic Problems:
- Problem: Many algorithmic problems involve repetitive tasks or operations that need to be performed iteratively.
- Solution: Loops are fundamental for solving algorithmic problems efficiently. They allow you to express repetitive patterns in a concise and readable manner.
java // Example: Finding the sum of elements in an array int[] array = {1, 2, 3, 4, 5}; int sum = 0; for (int element : array) { sum += element; }
In summary, loops are used to address problems that require repeated execution of code, iterating over data, or dynamically handling repetition based on certain conditions. They contribute to more concise, readable, and efficient code by avoiding the need for redundant or duplicated instructions.
How do we display information on the console? How do we take in information from the user in a console program?
In Java, you can display information on the console using the System.out.println method, and you can take input from the user using the Scanner class. Here’s a brief overview:
To print information to the console, you can use the System.out.println method. Here’s an example:
```java
public class ConsoleOutputExample {
public static void main(String[] args) {
// Displaying information on the console
System.out.println(“Hello, World!”);
System.out.println(“This is an example of console output.”);
}
}
~~~
To take input from the user, you can use the Scanner class, which is part of the java.util package. Here’s an example:
```java
import java.util.Scanner;
public class ConsoleInputExample {
public static void main(String[] args) {
// Creating a Scanner object to read user input
Scanner scanner = new Scanner(System.in);
// Taking input from the user
System.out.print("Enter your name: ");
String userName = scanner.nextLine();
// Displaying the user's input
System.out.println("Hello, " + userName + "!");
// Closing the Scanner to release resources
scanner.close();
} } ~~~
In this example, Scanner is used to read input from the user. The nextLine() method reads a line of text entered by the user. You can customize this based on the type of input you want to read (e.g., nextInt() for integers).
Remember to close the Scanner object when you’re done to release system resources.
Compile and run these programs in a console or terminal to see the output and input interaction.
What is an object? What is a class?
In object-oriented programming (OOP), a class and an object are fundamental concepts that allow you to structure and model your code in a more organized and modular way.
Class:
• Definition: A class is a blueprint or a template for creating objects. It defines a set of attributes (fields or properties) and methods (functions or behaviors) that the objects created from the class will have. • Purpose: Classes are used to model and represent entities or concepts in your code. They encapsulate data and behavior related to a specific type of object. • Example in Java:
public class Car {
// Attributes
String brand;
int year;
// Methods
void startEngine() {
System.out.println("Engine started!");
}
void drive() {
System.out.println("Car is moving.");
} }
Object:
• Definition: An object is an instance of a class. It is a concrete entity created based on the blueprint provided by the class. Objects have state (attribute values) and behavior (methods) defined by their class. • Purpose: Objects are used to represent real-world entities or abstract concepts in your program. They encapsulate data and provide a way to interact with and manipulate that data through their methods. • Example in Java:
public class Main {
public static void main(String[] args) {
// Creating objects from the Car class
Car myCar = new Car();
myCar.brand = “Toyota”;
myCar.year = 2022;
// Using object methods
myCar.startEngine();
myCar.drive();
} }
In this example, Car is a class that defines the blueprint for a car. The myCar object is an instance of the Car class, and you can interact with it using its attributes (brand, year) and methods (startEngine(), drive()).
In summary, a class is a blueprint that defines the structure and behavior of objects, while an object is an instance of a class, representing a concrete entity in your program. OOP allows you to model and organize your code based on these principles, promoting modularity and reusability.
How is an array like a an arrayList in Java? How are they different?
In Java, both arrays and ArrayLists are used to store collections of elements. However, arrays have a fixed size, while ArrayLists can dynamically resize. ArrayLists also provide additional methods for easy manipulation, like adding, removing, or searching for elements, which arrays don’t have.
Tell me about a hashmap
A hashmap is a data structure that stores key-value pairs, allowing efficient retrieval of values based on their associated keys. It uses a hash function to map keys to indices in an underlying array, providing fast access times. This makes hashmaps ideal for tasks like searching, insertion, and deletion of data.
What is encapsulation? Why is it important?
Encapsulation is a programming concept that involves bundling data and methods that operate on the data into a single unit, known as a class. It helps hide the internal details of an object and restricts direct access to some of its components, promoting a more modular and maintainable code structure. This improves code organization, reduces dependencies, and enhances security by controlling access to sensitive data.
What is inheritance? Why as a programmer would you choose to use inheritance?
In Java, inheritance is a mechanism where a class (subclass or derived class) inherits properties and behaviors from another class (superclass or base class). It allows you to create a new class that is a modified version of an existing class, promoting code reuse.
Programmers use inheritance to:
- Reuse Code: Inheritance facilitates the reuse of code from existing classes, reducing redundancy and promoting a modular approach.
- Polymorphism: It enables polymorphism, allowing objects of derived classes to be treated as objects of their base class. This supports flexibility and extensibility in your code.
- Structuring Code: Inheritance helps in organizing and structuring code by creating a hierarchy of classes that represent different levels of abstraction.
Keep in mind that while inheritance offers benefits, it should be used judiciously to avoid excessive coupling between classes and potential issues with maintenance and understanding of the code.
What is polymorphism? How is polymorphism like inheritance? How is it different?
Polymorphism is a concept in object-oriented programming that allows objects of different types to be treated as objects of a common type. It enables a single interface to represent various underlying data types. Polymorphism can manifest in two forms: compile-time (method overloading) and runtime (method overriding).
Similarities with Inheritance:
- Both polymorphism and inheritance are fundamental concepts in object-oriented programming.
- Inheritance often complements polymorphism. Polymorphism is frequently achieved through method overriding, which is a feature of inheritance.
Differences:
- Definition:
- Inheritance: It is the mechanism for creating a new class that is a modified version of an existing class.
- Polymorphism: It allows objects of different types to be treated as objects of a common type.
-
Focus:
- Inheritance: Focuses on code reuse and creating a hierarchy of classes.
- Polymorphism: Focuses on providing a unified interface for different types.
-
Implementation:
- Inheritance: Achieved by creating a new class that inherits properties and behaviors from another class.
- Polymorphism: Achieved through method overriding, where a subclass provides a specific implementation of a method defined in its superclass.
In essence, while inheritance is a way to structure and extend code, polymorphism enhances flexibility by allowing objects to be treated uniformly regardless of their specific types. They often work hand-in-hand, with polymorphism being a natural consequence of well-designed inheritance hierarchies.
What is an interface? Why would you use one?
An interface in Java is a collection of abstract methods (methods without a body) and constants that can be implemented by classes. It defines a contract that concrete classes must adhere to, specifying a set of methods that they must implement. Unlike abstract classes, interfaces cannot have instance variables or method implementations.
Programmers use interfaces for several reasons:
- Abstraction: Interfaces allow you to declare a set of methods without providing the implementation details. This promotes abstraction, focusing on what a class should do rather than how it should do it.
- Multiple Inheritance: Java supports multiple interface inheritance, enabling a class to implement multiple interfaces. This is useful when a class needs to inherit behaviors from multiple sources.
- Contractual Obligation: When a class implements an interface, it commits to providing concrete implementations for all the methods declared in that interface. This establishes a contractual obligation, ensuring that certain behaviors are defined in the implementing class.
- Code Decoupling: By relying on interfaces, you can decouple components in your system. This means you can change or extend the implementation of a class without affecting the classes that use its interface.
- API Design: Interfaces are essential in designing clean and maintainable APIs. They define the expected behavior of classes and help in creating a well-structured and modular codebase.
In summary, interfaces provide a way to achieve abstraction, support multiple inheritance, enforce contractual obligations, facilitate code decoupling, and contribute to effective API design in Java.
How are abstract classes and interfaces alike? How are they different?
Abstract classes and interfaces in object-oriented programming (OOP) share some similarities but also have key differences. They are both used to define a contract for classes that inherit from them but do so in different ways and for different purposes.
Similarities:
Contract Definition: Both abstract classes and interfaces are used to define a contract for subclasses or implementing classes. This contract specifies what methods or properties these subclasses should have, without necessarily defining how these methods are implemented.
Cannot Be Instantiated: Neither abstract classes nor interfaces can be instantiated directly. They are meant to be extended or implemented by other classes.
Support for Polymorphism: Both allow for polymorphism, where a class can be treated as its superclass or interface type, allowing for flexible and interchangeable object references.
Differences:
Method Implementation: Abstract classes can have a mix of methods with their implementations (concrete methods) and abstract methods (without implementation), whereas interfaces traditionally could only declare methods without any implementation. However, with newer programming languages like Java (from version 8 onwards), interfaces can now have default and static methods with implementation.
State or Fields: Abstract classes can have fields (state) that can be inherited by subclasses. Interfaces traditionally could not have state but could declare static final fields (constants). With recent updates to languages like Java, interfaces can now have static fields but still don’t support instance fields.
Inheritance vs. Implementation: Classes extend abstract classes, meaning they inherit both behavior and state from the abstract class. Classes implement interfaces, meaning they must only provide implementations for the methods defined by the interface. A class can only extend one abstract class (due to single inheritance in languages like Java and C#) but can implement multiple interfaces, supporting multiple inheritance of types.
Access Modifiers: Abstract classes can have methods with any access modifiers (public, protected, private), allowing for more controlled access. Interface methods were historically public by default, though newer language features allow for more flexibility.
Constructor: Abstract classes can have constructors. Interfaces cannot have constructors because they cannot have instance fields that need to be initialized during object creation.
In summary, while abstract classes and interfaces serve similar purposes in defining contracts for other classes, they do so with different mechanisms and rules, reflecting their intended use cases. Abstract classes are more suitable when shared code among multiple related classes is needed, whereas interfaces are better when defining a common API that multiple unrelated classes can implement.
What is Unit Testing? What tools are used to do automated Unit Testing?
Unit testing is a software testing technique where individual units or components of a software application are tested in isolation to ensure that they work correctly. The main goal of unit testing is to validate that each unit of the software performs as expected. Units are typically functions, methods, or classes.
Unit testing is done by writing test cases for each unit of the code to verify its behavior. These test cases are written by the developers themselves and are usually automated to allow for easy execution and verification.
Some commonly used tools for automated unit testing in Java include:
- JUnit: JUnit is a popular unit testing framework for Java. It provides annotations to define test methods, assertions to verify expected outcomes, and test runners to execute the tests. JUnit is widely used and has good integration with popular Java development environments like IntelliJ IDEA and Eclipse.
- TestNG: TestNG is another unit testing framework for Java that provides similar functionality to JUnit but with some additional features such as support for parallel testing, data-driven testing, and more flexible test configuration.
- Mockito: Mockito is a mocking framework for Java that is often used in conjunction with unit testing frameworks like JUnit or TestNG. Mockito allows developers to create mock objects to simulate the behavior of dependencies in unit tests, making it easier to isolate and test individual units of code.
- PowerMock: PowerMock is an extension to Mockito and other mocking frameworks that provides additional capabilities for testing code that is difficult to test with standard mocking techniques, such as static methods, private methods, and constructors.
These tools help developers automate the process of writing and executing unit tests, allowing for faster and more reliable software development. They also provide features for generating test reports, tracking code coverage, and integrating with continuous integration (CI) systems for automated testing in development pipelines.
