CS106A - Programming Methodology & Object-Oriented Design (Java) Flashcards

Question 1

What is the basic structure of a Java program that can be executed?

Accepted Answer

A Java program typically starts execution within the `main` method, which has the signature `public static void main(String[] args) { /* code */ }`.

Question 2

How do you declare and initialize a variable for an integer in Java?

Accepted Answer

You declare a variable by specifying its type and name, and initialize it using the assignment operator. For example: `int myNumber = 10;` declares an integer variable named `myNumber` and initializes it with the value `10`.

Question 3

Explain the purpose of `if-else if-else` statements in Java.

Accepted Answer

`if-else if-else` statements are used for conditional execution. The `if` block executes if its condition is true. If false, the `else if` conditions are checked sequentially. If all `if` and `else if` conditions are false, the `else` block executes.

Question 4

What is the primary use of a `for` loop in Java?

Accepted Answer

A `for` loop is primarily used for iterating a fixed number of times, typically when the number of iterations is known beforehand. It consists of an initialization, a termination condition, and an increment/decrement statement.

Question 5

How do you define a simple method in Java that takes two integers and returns their sum?

Accepted Answer

```java
public int addNumbers(int a, int b) {
    return a + b;
}
```

Question 6

Distinguish between a "class" and an "object" in Java.

Accepted Answer

A `class` is a blueprint or template for creating objects, defining their properties (fields) and behaviors (methods). An `object` is an instance of a class, a concrete entity created from that blueprint, existing in memory.

Question 7

What is a constructor in Java and when is it called?

Accepted Answer

A `constructor` is a special method used to initialize new objects of a class. It has the same name as the class and no return type. It's called automatically when an object is created using the `new` keyword (e.g., `MyClass obj = new MyClass();`).

Question 8

Explain the concept of "encapsulation" in OOP and how it's achieved in Java.

Accepted Answer

Encapsulation is the bundling of data (instance variables) and methods that operate on the data within a single unit (a class), and restricting direct access to some of an object's components. It's achieved in Java using access modifiers like `private` for fields and `public` for "getter" and "setter" methods to control access.

Question 9

How does "inheritance" work in Java, and what keyword is used?

Accepted Answer

Inheritance allows a class (subclass or child class) to inherit properties and behaviors (fields and methods) from another class (superclass or parent class). This promotes code reuse and establishes an "is-a" relationship. The `extends` keyword is used, e.g., `class Dog extends Animal { ... }`.

Question 10

What is "method overriding" and when is it used?

Accepted Answer

Method overriding occurs when a subclass provides a specific implementation for a method that is already defined in its superclass. The method signature (name, parameters, return type) must be the same. It's used to achieve runtime polymorphism, allowing a child class to provide its own behavior for an inherited method.

Question 11

Define "polymorphism" in the context of Java OOP.

Accepted Answer

Polymorphism means "many forms." In Java, it allows objects of different classes to be treated as objects of a common type (their superclass or interface). This enables a single method call to behave differently based on the actual object type at runtime, promoting flexibility and extensibility.

Question 12

What is an "interface" in Java and how does it differ from an abstract class?

Accepted Answer

An `interface` is a blueprint of a class that can only contain abstract methods and constants (Java 8+ allows default and static methods). It defines a contract that implementing classes must adhere to. Unlike abstract classes, a class can implement multiple interfaces but can only extend one class. Interfaces define *what* a class can do, while abstract classes can provide partial implementations.

Question 13

How do you declare and initialize a fixed-size array of integers in Java?

Accepted Answer

To declare an array of a specific size: `int[] numbers = new int[5];` (creates an array for 5 integers). To declare and initialize with values: `int[] primes = {2, 3, 5, 7, 11};`.

Question 14

What is an `ArrayList` in Java, and what are its advantages over a traditional array?

Accepted Answer

An `ArrayList` is a dynamic, resizable array implementation from the Java Collections Framework. Its main advantage over traditional arrays is that its size can grow or shrink dynamically as elements are added or removed, and it provides convenient methods for common operations like `add()`, `remove()`, and `get()`.

Question 15

How do you add an element to an `ArrayList` and retrieve an element at a specific index?

Accepted Answer

To add an element: `myArrayList.add(element);`. To retrieve an element: `myArrayList.get(index);`.

Question 16

Describe the basic steps to read data from a text file in Java.

Accepted Answer

1. Create a `File` object for the file path. 2. Create a `Scanner` object, passing the `File` object to its constructor. 3. Use `scanner.hasNextLine()` and `scanner.nextLine()` in a loop to read line by line. 4. Close the `Scanner` (ideally using a try-with-resources statement). This process requires handling `FileNotFoundException`.
```java
try (Scanner scanner = new Scanner(new File("data.txt"))) {
    while (scanner.hasNextLine()) {
        System.out.println(scanner.nextLine());
    }
} catch (FileNotFoundException e) {
    System.err.println("File not found: " + e.getMessage());
}
```

Question 17

How do you write text data to a file in Java?

Accepted Answer

1. Create a `File` object. 2. Create a `PrintWriter` (or `FileWriter`) object, passing the `File` object (and optionally `true` for append mode). 3. Use `writer.println()` or `writer.print()` to write data. 4. Close the `PrintWriter` (ideally using a try-with-resources statement). This process requires handling `IOException`.
```java
try (PrintWriter writer = new PrintWriter(new File("output.txt"))) {
    writer.println("Hello, Notum!");
    writer.println("This is a test.");
} catch (IOException e) {
    System.err.println("Error writing to file: " + e.getMessage());
}
```

Question 18

What is the purpose of a `try-catch` block in Java?

Accepted Answer

A `try-catch` block is used for exception handling. Code that might throw an exception is placed in the `try` block. If an exception occurs, control is transferred to the `catch` block, which handles the error gracefully, preventing program termination and allowing for recovery or informative error messages.

Question 19

List three common debugging strategies in Java.

Accepted Answer

1.  **Print Statements:** Inserting `System.out.println()` statements to trace variable values and execution flow at different points in the program. 
2.  **Using a Debugger:** Setting breakpoints and stepping through code line by line in an Integrated Development Environment (IDE) to inspect variables, the call stack, and program state. 
3.  **Code Review:** Carefully reading through the code, sometimes with a peer, to identify logical errors, typos, or misunderstandings of requirements.

Question 20

Explain "problem decomposition" in software development.

Accepted Answer

Problem decomposition is the process of breaking down a complex problem into smaller, more manageable sub-problems. Each sub-problem can then be solved independently, making the overall solution easier to design, implement, test, and maintain. This approach often leads to modular, reusable, and more robust code.

Question 21

What are some key principles for writing "clean code"?

Accepted Answer

Key principles for writing clean code include:
*   **Readability:** Using meaningful and descriptive names for variables, methods, and classes.
*   **Simplicity:** Keeping methods and classes focused on a single responsibility (Single Responsibility Principle).
*   **Consistency:** Adhering to coding standards and conventions throughout the codebase.
*   **DRY (Don't Repeat Yourself):** Avoiding duplicate code by abstracting common logic into reusable components.
*   **Minimal Comments:** Writing self-documenting code, using comments only to explain *why* something is done, not *what* it does.

CS106A - Programming Methodology & Object-Oriented Design (Java)

Card Preview

Related Flashcard Sets

German B1 - Intermediate Grammar & Conversational Fluency

Algorithms - Graph Theory & Shortest Path Algorithms

Kubernetes - Container Orchestration, Pods & Deployments

Molecular Biology - Central Dogma & Protein Synthesis