1
Q
What is Java and what are its main features?
A
- Java is a high-level, general-purpose programming language that was developed by Sun Microsystems (now owned by Oracle Corporation).
- Its main features include:
- platform independence,
- object-oriented programming (OOP) support,
- automatic memory management (garbage collection),
- robustness,
- and a large standard library.
2
Q
Java SE
A
- Java SE (Standard Edition)
- is the core Java platform
- that provides the basic set of APIs and libraries for general-purpose development.
3
Q
Java EE
A
- Java EE (Enterprise Edition)
- is a set of APIs and libraries built on top of Java SE,
- specifically designed for developing enterprise applications, such as web applications and distributed systems.
4
Q
Java ME
A
- Java ME (Micro Edition)
- is a subset of Java SE,
- optimized for resource-constrained devices like mobile phones and embedded systems.
5
Q
Explain the JVM (Java Virtual Machine) and its role in Java programming.
A
- It is responsible for executing Java bytecode, which is the compiled form of Java source code.
- The JVM acts as an abstraction layer between the Java program and the underlying hardware and operating system.
- It provides platform independence by translating bytecode into machine-specific instructions at runtime.
- The JVM also:
- manages memory,
- handles garbage collection,
- and provides various runtime services to Java programs.
6
Q
What are the primitive data types in Java
A
- byte
- short
- int
- long
- float
- double
- char
- boolean
7
Q
What are the reference data types in Java?
A
- classes
- interfaces
- arrays
- enumerations
8
Q
class
A
a class is a blueprint or template that defines the structure and behavior of objects.
It specifies the:
1. properties (fields)
2. and actions (methods) that objects of that class can possess.
9
Q
object
A
- An object, on the other hand, is an instance of a class.
- and can hold its own unique state and behavior.
10
Q
inheritance
A
- allows a class to inherit the 1. properties and 2. methods of another class, known as the superclass or base class.
- The class that inherits from the superclass is called a subclass or derived class.
- The subclass can:
- reuse the code
- and extend the functionality of the superclass.
11
Q
What is the purpose of the “static” keyword in Java?
A
- used to declare members (fields or methods) that belong to the class itself rather than specific instances of the class.
- Static members are:
- shared among all objects of the class
- and can be accessed directly using the class name, without creating an instance of the class.
- Static methods are commonly used for utility functions or operations that don’t require access to instance-specific data.
12
Q
How do you create and use an array in Java?
A
- an array is a fixed-size, ordered collection of elements of the same type.
- To create an array, you specify the element type and the size of the array.
For Example:
int[] numbers = new int[5];
or
int[] numbers = {1, 2, 3, 4, 5};
13
Q
Method Overloading
A
- the ability to have multiple methods in the same class with the same name but different parameters.
- The methods are distinguished by their parameter types, number, or order.
14
Q
Method Overriding
A
- when a subclass provides a specific implementation of a method that is already defined in its superclass.
- The overridden method in the subclass must have the same:
- name,
- return type,
- and parameters as the method in the superclass.
15
Q
How do you handle exceptions in Java?
A
- The try-catch-finally block is used to handle exceptions.
- The code that might throw an exception is placed in the try block, and the corresponding exception handlers are placed in catch blocks.
- If an exception occurs in the try block, the catch block that matches the type of the thrown exception is executed.
- The finally block, if present, is executed regardless of whether an exception occurred or not and is commonly used for cleanup tasks.
16
Q
Checked Exceptions
A
- exceptions that must be declared
- in the method signature using the “throws” keyword
- or caught using a try-catch block.
- They represent expected error conditions that the calling code must handle explicitly.
- checked exceptions are subclasses of Exception (excluding RuntimeException and its subclasses).
17
Q
Unchecked Exceptions
A
- do not require explicit handling or declaration.
- They usually represent unexpected runtime errors or programming mistakes.
- Unchecked exceptions are subclasses of RuntimeException and its subclasses
18
Q
abstract classes
A
- An abstract class can have both:
- method declarations (without implementation)
- and concrete methods,
- and it can be extended by other classes using the “extends” keyword
19
Q
interface
A
- an interface only contains method declarations,
- and a class implements an interface using the “implements” keyword.
20
Q
How many interfaces can a class implement?
A
multiple
21
Q
How many abstract classes can a class extend?
A
one
22
Q
What is a constructor?
A
- A constructor in Java is a special method that is used to initialize objects of a class.
- It has the same name as the class
- it does not have a return type.
- and use the “new” keyword to create an instance of the class.
For Example:
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
}
Person person = new Person("John");
23
Q
What is the purpose of the “final” keyword in Java?
A
- In Java, the “final” keyword is used to restrict certain entities from being modified.
- it makes a variable a constant.
- it prevents the method from being overridden in a subclass.
- It prevents the class from being subclassed.
24
Q
What happens when you use the new keyword to create a string object (i.e. String str = new String(“Hello”))?
A
- a new string object is created on the heap, (i.e. it doesn’t reference the same pointer in memory when you assign the same string value to a new variable).
- and memory is allocated to store the characters “Hello”.
25
What happens when you create a string using string literals (i.e. String str = "Hello")?
- In this case, the Java compiler **checks if a string with the same value already exists in the string pool**, which is a special area in the heap.
- If a matching string exists, the reference to that string is assigned to the variable str.
- If not, a new string object is created in the string pool and assigned to str.
26
StringBuilder
- **not thread-safe**
- but provides **better performance in single-threaded scenarios**.
27
StringBuffer
- **is thread-safe**
- but has **slightly lower performance due to synchronization**.
28
What are the Java access modifiers
1. Public
2. Protected
3. Default
4. Private
29
Public
Accessible from anywhere.
30
Protected
- Accessible within the **same package**
- and **subclasses** (***even if in different packages***).
31
Default (no modifier)
Accessible **within the same package only**.
32
Private
Accessible within the same class only.
33
Explain the concept of encapsulation in Java.
- provides **data abstraction**,
- **hiding the internal implementation** details of an object
- and **allowing access to the object's state only through defined methods**.
34
equals()
- a **method defined in the Object class** (the superclass of all classes in Java)
- is used to **compare the contents or values of two objects for equality**.
- It is typically overridden in custom classes to provide a meaningful comparison.
35
"=="
- It checks if two variables or expressions **refer to the same memory location**.
- **For objects, the "==" operator compares the memory addresses**, not the actual contents.
36
What are the different types of Java operators?
1. **Arithmetic** operators (+,-,*.etc...)
2. **Relational** operators (==, >, <, etc...)
3. **Logical** operators (&&, !!, !)
4. **Assignment** operators (=)
37
Explain the concept of method chaining in Java.
- also known as **cascading**,
- where **multiple methods are called sequentially** on the same object instance in a single statement.
- **Each method call returns the object itself**, allowing subsequent methods to be invoked on the returned object.
-results in **more concise and readable code**.
For Example:
StringBuilder builder = new StringBuilder()
.append("Hello")
.append(" ")
.append("World")
.append("!")
.reverse();
38
break
terminates the execution of a loop
39
continue
skip remaining code in the current iteration of a loop and proceed to the next iteration.
40
How do you sort elements in an array in Java?
you can use the **Arrays class's sort() method**
or
the **Collections class's sort()** method for arrays of objects.
For Example:
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] numbers = {5, 2, 8, 1, 3};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));
}
}
**NOTE**: In this example, we have an array of integers called numbers. We use the Arrays.sort() method to sort the elements in ascending order. The sorted array is then printed using Arrays.toString().
41
stack
- The stack is used to store:
1. local variables
2. and **method call** information.
- **Each thread** in a Java program **has its own stack**, and it operates in a **Last-In-First-Out (LIFO)** manner.
- When a method is called, **a new stack frame is created** to store the method's:
1. parameters,
2. local variables,
3. and return address.
- When the method execution completes, **the stack frame is removed**.
- The stack is generally smaller in size compared to the heap and has a limited memory allocation.
42
heap
- he heap is used to dynamically allocate memory for **objects**.
- All **objects** and **arrays** in Java are allocated on the heap.
- The heap memory is **shared among all threads**
- and **managed by the Java runtime environment's garbage collector**.
- Objects in the heap have a longer lifespan and can be accessed from different parts of the program.
- The heap size is generally larger and can grow as needed.
43
Whats the difference between the stack and the heap?
- The stack is used for efficient memory allocation and deallocation for **method calls**,
- while the heap provides a more flexible and dynamic memory allocation **for objects**.
44
What are different types of variables in Java?
1. Local
2. Instance
3. Class
45
Local Variables
- declared within a:
1. method,
2. constructor,
3. or block of code.
- They are only accessible **within the scope where they are declared**.
- They must be initialized before they are used.
46
Instance Variables
- **declared** within a class (but outside any method, constructor, or block of code).
- They are **associated with an instance of the class** and have different values for each instance.
- Instance variables are **accessible to all methods and blocks within the class**.
47
Class Variables
- declared with the **static keyword** within a class (but outside any method, constructor, or block of code).
- They are **shared among all instances of the class**
- They **have the same value across different instances**.
- **associated with the class itself** and can be accessed using the class name.
48
How do you handle multithreading in Java?
- you can create and manage threads:
1. using the **Thread class**
2. or by **implementing the Runnable interface**.
For Example:
public class MyThread extends Thread {
@Override
public void run() {
// Code to be executed in the thread
}
}
public class Main {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start(); // Start the thread
}
}
**NOTE**: In this example, the MyThread class extends the Thread class and overrides the run() method with the code to be executed in the thread. In the Main class, we create an instance of MyThread and call the start() method to start the thread's execution.
Alternatively, you can implement the Runnable interface and pass it to a Thread object for execution.
49
What does encapsulation help with?
1. achieving **data integrity**,
2. **code maintainability**,
3. and **flexibility in changing the internal implementation** without affecting other parts of the code.
Software Engineer Interview Prep
flashcards
Decks in class (13)
# Cards
