test2 Flashcards

Question

What constitutes a method signature?

Answer 1

The signature includes the method name and its parameter list (number, type, and order of parameters). The return type is not part of the signature.

Answer 2

Method overloading allows multiple methods with the same name but different parameters within the same class. It increases flexibility and readability.

Answer 3

No. Overloaded methods must differ by parameter list; a difference in return type alone is not enough.

Answer 4

Overriding occurs when a subclass provides a new implementation for a method inherited from its superclass with the same signature. This enables runtime polymorphism, where the method called depends on the actual object type.

Answer 5

A constructor initializes a new instance of a class. It has the same name as the class and no return type.

Answer 6

The compiler automatically provides a default no-argument constructor that initializes the object with default values.

Answer 7

You can define multiple constructors with different parameter lists to allow various ways to initialize an object.

Answer 8

this refers to the current object’s instance, and it is used to differentiate between instance variables and parameters or to call another constructor in the same class using this().

Answer 9

Yes, a private constructor is valid. It’s often used in the Singleton pattern or in utility classes to prevent external instantiation.

Answer 10

Encapsulation is the bundling of data (fields) and methods that operate on the data, while restricting direct access to some of the object's components. It enhances security, maintainability, and modularity.

Answer 11

A package groups related classes and interfaces, helping to avoid naming conflicts and making the code easier to manage and maintain.

Answer 12

The import statement allows you to refer to classes from other packages without using their fully qualified names, simplifying the code.

Answer 13

Java supports single-line (//), multi-line (/* ... */), and documentation (/** ... */) comments. Javadoc comments are used to generate API documentation and include tags such as @param, @return, and @throws.

Answer 14

Compile with javac FileName.java to produce bytecode, then run with java FileName (without the .java extension).

Answer 15

static indicates that a field or method belongs to the class rather than any instance, meaning it is shared among all instances and can be accessed without creating an object.

Answer 16

You call a static method using the class name (e.g., ClassName.methodName()), even within non-static methods.

Answer 17

Garbage collection is the automatic reclamation of memory occupied by objects that are no longer referenced. You can request garbage collection with System.gc(), but it is not guaranteed to run immediately.

Answer 18

Inheritance allows a class (subclass) to inherit fields and methods from another class (superclass), promoting code reuse and establishing a hierarchical relationship.

Answer 19

Polymorphism allows a superclass reference to refer to a subclass object, enabling dynamic method invocation. This is primarily achieved through method overriding.

Answer 20

An interface defines a contract with abstract methods (and, since Java 8, default and static methods) and constant fields (implicitly public, static, and final).

Answer 21

An abstract class cannot be instantiated and may contain abstract methods (without implementation) alongside concrete methods. It’s used when classes share common behavior but should not be instantiated on their own.

Answer 22

A static block runs once when the class is loaded, and is used to initialize static variables or execute startup code that needs to run before any instances are created.

Answer 23

A final field can be assigned only once, ensuring its value remains constant after initialization. A final method cannot be overridden by subclasses.

Answer 24

An immutable class is declared final, all its fields are private and final, and it does not provide any setters. Defensive copies of mutable objects are returned if necessary, ensuring the state cannot change after construction.

Answer 25

Primitive parameters are passed by value, so modifications do not affect the original variable. Object references are also passed by value; however, modifying the object's internal state (via its methods) will affect the same object outside the method.

Answer 26

Checked exceptions are enforced at compile time and must be either caught or declared in the method’s throws clause. Unchecked exceptions (subclasses of RuntimeException) are not required to be caught or declared.

Answer 27

If an exception is not caught, it propagates up the call stack. If it reaches the main method without being handled, the program terminates and prints a stack trace.

Answer 28

Static methods are not overridden; they are hidden if redefined in a subclass. The method invoked is determined by the reference type, not the object type, unlike instance methods which exhibit polymorphic behavior.

Answer 29

The ternary operator is a shorthand for an if-else statement. Syntax: condition ? valueIfTrue : valueIfFalse. It returns one of two values based on the evaluation of the condition.

Answer 30

Bitwise operators (e.g., &,

Answer 31

The entry point is the main method with the signature public static void main(String[] args).

Answer 32

A class is a blueprint for creating objects; it encapsulates data (fields) and behavior (methods) and defines how objects should be structured and interact.

Answer 33

Instance variables are declared in a class but outside any method and belong to an object, while local variables are declared inside methods or blocks and only exist during the execution of that block.

Answer 34

For object references, the default is null; for numeric types (e.g., int, double), it is 0 or 0.0; for boolean, it is false; and for char, it is the null character (\u0000).

Answer 35

Private restricts access to the class itself; protected allows access within the same package and subclasses; public allows access from any class; if no modifier is specified (default), access is restricted to classes in the same package.

Answer 36

final can be used to declare variables whose values cannot change, methods that cannot be overridden, or classes that cannot be subclassed.

Answer 37

A method signature consists of the method name and its parameter list (including types, order, and count). The return type and exceptions are not part of the signature.

Answer 38

Java always passes arguments by value. For objects, the reference is passed by value, meaning the reference copy points to the same object.

Answer 39

Static members belong to the class itself and can be accessed without creating an instance, while instance members belong to individual objects of the class.

Answer 40

A while loop checks its condition before executing the loop body, whereas a do-while loop executes the body first and then checks the condition, guaranteeing at least one execution.

Answer 41

break terminates the loop immediately, while continue skips the current iteration and proceeds with the next iteration of the loop.

Answer 42

Nested loops place one loop inside another. If the outer loop runs n times and the inner loop runs m times per iteration, the total iterations are n × m, often resulting in O(n·m) time complexity.

Answer 43

Pitfalls include increased time complexity leading to performance issues, incorrect loop bounds, and off-by-one errors when iterating through arrays or matrices.

Answer 44

Example: java
for (int i = 1; i <= 10; i++) {
for (int j = 1; j <= 10; j++) {
System.out.printf("%4d", i * j);
}
System.out.println();
}

Answer 45

It returns a double value in the range [0.0, 1.0), meaning it can be 0.0 but will always be less than 1.0.

Answer 46

Math.pow(x, y) calculates x raised to the power of y, returning the result as a double.

Answer 47

Math.floor(x) returns the largest integer less than or equal to x, while Math.ceil(x) returns the smallest integer greater than or equal to x.

Answer 48

substring(int beginIndex) returns a new string starting from the specified index, while substring(int beginIndex, int endIndex) returns a string from the start index up to, but not including, the end index.

Answer 49

equals() compares the actual content (sequence of characters) of two strings, whereas == checks if the two references point to the same object in memory.

Answer 50

Instantiate a Random object and call nextInt(n), which returns a random integer in the range 0 (inclusive) to n (exclusive).

Answer 51

By passing a seed value (long) to the constructor, e.g., new Random(12345L).

Answer 52

Both provide mutable sequences of characters; however, StringBuffer is synchronized (thread-safe) while StringBuilder is not, making the latter faster in single-threaded environments.

Answer 53

Use the toString() method, for example: String s = myStringBuffer.toString();.

Answer 54

String objects are immutable (unchangeable), whereas both StringBuffer and StringBuilder are mutable. StringBuffer is thread-safe due to synchronization; StringBuilder is not, so it is generally faster in non-threaded scenarios.

Answer 55

You can declare and initialize it in one line using: int[] arr = {1, 2, 3, 4, 5}; or separately declare and then allocate memory with int[] arr = new int[5];.

Answer 56

Use the array.length property to obtain the number of elements. This property is final and cannot be modified once the array is created.

Answer 57

Yes, arrays are objects in Java and are created on the heap.

Answer 58

You can declare a 2D array with int[][] matrix = new int[rows][columns]; or initialize it using initializer lists, e.g., int[][] matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };.

Answer 59

A jagged array is an array of arrays where each inner array can have different lengths, unlike a rectangular array where every row has the same number of columns.

Answer 60

Use a nested loop where the outer loop iterates over the rows and the inner loop uses matrix[i].length to determine the number of columns for that specific row.

Answer 61

An ArrayIndexOutOfBoundsException is thrown if you try to access an invalid index (less than 0 or greater than or equal to the array’s length).

Answer 62

Encapsulation is the bundling of data and methods that operate on that data within a class, and restricting direct access to some of the object’s components using private fields and public getters/setters.

Answer 63

Overloading is defining multiple methods with the same name in the same class but with different parameter lists. Overriding occurs when a subclass provides its own implementation of a method already defined in its superclass, using the same signature.

Answer 64

A constructor initializes a new object instance of the class, setting up initial values and states. It can be overloaded, and its access level controls how instances of the class are created.

Answer 65

The this keyword is used to refer to the current object's fields or methods, commonly to distinguish between instance variables and parameters with the same name in a constructor or method.

Answer 66

Yes, a class can have multiple constructors with different parameter lists. This is known as constructor overloading.

Answer 67

A private constructor is used to restrict object creation from outside the class. It is often used in Singleton patterns or in utility classes where instantiation is not required.

Answer 68

Yes, declaring a class as final means it cannot be subclassed. This is used for security and to maintain immutability in certain designs.

Answer 69

A static block is used to initialize static variables or perform setup operations that need to occur once when the class is loaded, before any instances are created.

Answer 70

Implement a Singleton by using a private constructor, a private static instance variable, and a public static method (or static block) that returns the single instance. This ensures that only one instance of the class is ever created.

Answer 71

Override toString() to provide a meaningful string representation of an object, which is useful for debugging and logging. For example, inside your class, define: java
@Override
public String toString() {
return "MyClass details...";
}

Answer 72

Getters and setters provide controlled access to private fields, allowing validation or additional processing when getting or setting a value. They are a key aspect of encapsulation.