Stanford CS106A - Programming Methodologies (Java) Flashcards

Question 1

What is the basic structure of a simple Java program?

Accepted Answer

A Java program typically consists of at least one `class` definition. The program execution begins in the `main` method, which has the signature `public static void main(String[] args)`.
```java
public class MyProgram {
    public static void main(String[] args) {
        // Program logic goes here
        System.out.println("Hello, CS106A!");
    }
}
```

Question 2

Name four primitive data types in Java and their typical uses.

Accepted Answer

1. `int`: Stores whole numbers (e.g., `int age = 30;`).
2. `double`: Stores floating-point numbers (e.g., `double price = 19.99;`).
3. `boolean`: Stores `true` or `false` values (e.g., `boolean isActive = true;`).
4. `char`: Stores a single character (e.g., `char grade = 'A';`).

Question 3

List the five basic arithmetic operators in Java and their functions.

Accepted Answer

1. `+` (Addition)
2. `-` (Subtraction)
3. `*` (Multiplication)
4. `/` (Division)
5. `%` (Modulo - remainder after division)

Example: `int result = 10 / 3;` (result is 3); `int remainder = 10 % 3;` (remainder is 1).

Question 4

Explain the purpose and basic syntax of an `if/else` statement in Java.

Accepted Answer

An `if/else` statement allows a program to execute different blocks of code based on a boolean condition.
```java
int score = 85;
if (score >= 90) {
    System.out.println("Grade: A");
} else if (score >= 80) {
    System.out.println("Grade: B");
} else {
    System.out.println("Grade: C or lower");
}
```

Question 5

When would you use a `for` loop, and what are its three main components?

Accepted Answer

A `for` loop is used for definite iteration, when you know in advance how many times you want to repeat a block of code. Its components are:
1. **Initialization:** Executed once at the beginning (e.g., `int i = 0;`).
2. **Condition:** Evaluated before each iteration; loop continues as long as it's `true` (e.g., `i < 10;`).
3. **Update:** Executed after each iteration (e.g., `i++`).
```java
for (int i = 0; i < 5; i++) {
    System.out.println("Iteration " + i);
}
```

Question 6

When is a `while` loop more appropriate than a `for` loop? Provide an example.

Accepted Answer

A `while` loop is used for indefinite iteration, when the number of repetitions is not known beforehand and depends on a condition.
```java
import acm.program.*; // Common in CS106A for console input
public class GuessingGame extends ConsoleProgram {
    public void run() {
        int secret = 7;
        int guess = readInt("Guess a number: ");
        while (guess != secret) {
            println("Incorrect. Try again.");
            guess = readInt("Guess a number: ");
        }
        println("Correct!");
    }
}
```

Question 7

What is a method in Java, and what are its key components?

Accepted Answer

A method (or function) is a block of code that performs a specific task. Key components include:
*   **Access Modifier:** (e.g., `public`, `private`)
*   **Static/Instance:** (`static` or not)
*   **Return Type:** The type of value the method returns (`void` if none)
*   **Method Name:** (e.g., `calculateSum`)
*   **Parameters:** Input values the method accepts (e.g., `(int a, int b)`)
```java
public int add(int num1, int num2) {
    return num1 + num2;
}
```

Question 8

Differentiate between a `class` and an `object` in Java.

Accepted Answer

*   A `class` is a blueprint or a template for creating objects. It defines the properties (fields) and behaviors (methods) that objects of that class will have.
*   An `object` is an instance of a class. It's a concrete entity created from the class blueprint, occupying memory and having specific values for its properties.

Example: `Car` is a class, `myCar = new Car();` creates an object `myCar`.

Question 9

What is the purpose of a constructor in Java, and how is it defined?

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 (not even `void`).
```java
public class Dog {
    String name;
    int age;

public Dog(String name, int age) { // Constructor
        this.name = name;
        this.age = age;
    }
}
// Usage: Dog myDog = new Dog("Buddy", 3);
```

Question 10

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

Accepted Answer

Encapsulation is the bundling of data (fields) and methods that operate on the data into a single unit (a class), and restricting direct access to some of an object's components. It's achieved in Java using access modifiers (`private` for fields, `public` for getter/setter methods) to control visibility. This protects data integrity and simplifies maintenance.

Question 11

Describe inheritance in Java, including the `extends` keyword and the `super` keyword.

Accepted Answer

Inheritance is an OOP principle where a new class (subclass/child class) derives properties and behaviors from an existing class (superclass/parent class).
*   The `extends` keyword is used to declare that a class inherits from another (e.g., `class Dog extends Animal`).
*   The `super` keyword is used to refer to the superclass's members, often to call a superclass constructor or method.
```java
class Animal {
    String species;
    public Animal(String s) { species = s; }
}
class Dog extends Animal {
    public Dog(String name) {
        super("Canine"); // Calls Animal's constructor
        // ...
    }
}
```

Question 12

What is polymorphism in Java, and how is it demonstrated through method overriding?

Accepted Answer

Polymorphism (meaning "many forms") allows objects of different classes to be treated as objects of a common superclass. Method overriding is a key aspect: a subclass provides a specific implementation for a method that is already defined in its superclass, maintaining the same method signature.
```java
class Animal {
    public void makeSound() { System.out.println("Animal makes a sound"); }
}
class Dog extends Animal {
    @Override
    public void makeSound() { System.out.println("Woof!"); }
}
// Usage: Animal myPet = new Dog(); myPet.makeSound(); // Outputs "Woof!"
```

Question 13

How do you declare, initialize, and access elements in a fixed-size array in Java?

Accepted Answer

*   **Declaration:** `int[] numbers;` or `int numbers[];`
*   **Initialization:**
    *   `numbers = new int[5];` (creates an array of 5 integers, initialized to 0)
    *   `String[] names = {"Alice", "Bob", "Charlie"};` (initializes with values)
*   **Access:** Elements are accessed using a zero-based index. `numbers[0] = 10;` or `String first = names[0];`
*   **Length:** `numbers.length` gives the size of the array.

Question 14

What is an `ArrayList`, and what are its advantages over a traditional array? List common `ArrayList` methods.

Accepted Answer

An `ArrayList` is a dynamic, resizable array implementation in Java's Collections Framework. * **Advantages:** It can grow or shrink in size dynamically, unlike fixed-size arrays. It's easier to add or remove elements. * **Common Methods:** * `add(element)`: Adds an element. * `get(index)`: Retrieves an element. * `set(index, element)`: Replaces an element. * `remove(index)`: Removes an element. * `size()`: Returns the number of elements. * **Declaration:** `ArrayList names = new ArrayList();`

Question 15

Define recursion and identify its two essential components. Provide a simple example.

Accepted Answer

Recursion is a programming technique where a method calls itself to solve a problem.
*   **Essential Components:**
    1.  **Base Case:** A condition that stops the recursion, preventing an infinite loop.
    2.  **Recursive Step:** The part where the method calls itself with a modified input, moving closer to the base case.
*   **Example (Factorial):**
    ```java
    public int factorial(int n) {
        if (n == 0) { // Base case
            return 1;
        } else { // Recursive step
            return n * factorial(n - 1);
        }
    }
    ```

Question 16

How can `System.out.println()` be used as a basic debugging tool?

Accepted Answer

`System.out.println()` statements can be strategically placed throughout code to display the values of variables, confirm execution flow, or indicate when certain parts of the code are reached. This helps identify where unexpected behavior occurs.
```java
int x = calculateValue();
System.out.println("Value of x after calculation: " + x); // Debug print
// ... further code
```

Question 17

Briefly explain how a debugger (e.g., in Eclipse or IntelliJ) aids in finding and fixing bugs.

Accepted Answer

A debugger allows you to pause program execution at specific points (breakpoints), step through code line by line, inspect the values of variables, and observe the call stack. This provides a much more powerful and detailed view of program state and flow compared to print statements, making it easier to pinpoint the root cause of errors.

Question 18

What is Big O notation, and what does $O(N)$ typically represent?

Accepted Answer

Big O notation is a mathematical notation that describes the limiting behavior of a function when the argument tends towards a particular value or infinity. In computer science, it's used to classify algorithms by how their running time or space requirements grow as the input size ($N$) grows.
*   $O(N)$ (linear time) means the algorithm's execution time grows proportionally to the input size. For example, iterating through an `ArrayList` once.

Question 19

List three common `String` methods in Java and their functions.

Accepted Answer

1. `length()`: Returns the number of characters in the string.
2. `charAt(int index)`: Returns the character at the specified index (0-based).
3. `substring(int beginIndex, int endIndex)`: Returns a new string that is a substring of this string, starting at `beginIndex` and extending to `endIndex - 1`.
4. `equals(Object other)`: Compares two strings for equality (case-sensitive).
5. `indexOf(String str)`: Returns the index of the first occurrence of the specified substring.

Question 20

Explain the difference between `static` and instance members (fields and methods) in a Java class.

Accepted Answer

*   **Instance members:** Belong to a specific object of the class. Each object has its own copy of instance fields, and instance methods operate on that object's data. They are accessed via an object reference (e.g., `myObject.instanceMethod()`).
*   **`static` members (class members):** Belong to the class itself, not to any particular object. There's only one copy of a `static` field shared by all objects, and `static` methods can be called directly on the class (e.g., `ClassName.staticMethod()`) without needing an object instance. They cannot access instance members directly.

Question 21

How does Java pass arguments to methods (pass by value or pass by reference)? Explain the implications for primitive types and objects.

Accepted Answer

Java is strictly "pass by value."
*   **Primitive Types:** When a primitive type (e.g., `int`, `double`) is passed, a copy of its value is made. Changes to the parameter inside the method do not affect the original variable outside the method.
*   **Objects:** When an object is passed, a copy of the *reference* to the object is made. Both the original variable and the parameter now refer to the *same object* in memory. Therefore, changes to the object's state (its fields) inside the method *will* be visible outside, but reassigning the parameter to a *new object* inside the method will not affect the original reference.

Question 22

What is problem decomposition, and why is it a crucial strategy in programming?

Accepted Answer

Problem decomposition is the strategy of breaking down a large, complex problem into smaller, more manageable sub-problems. Each sub-problem can then be solved independently, and their solutions combined to solve the original problem. It's crucial because it simplifies complexity, makes the problem easier to understand, allows for modular development, and facilitates debugging by isolating issues to smaller components.

Stanford CS106A - Programming Methodologies (Java)

Cards in this deck

Related Flashcard Sets

TypeScript - Advanced Type Systems, Generics & Design Patterns

Harvard ECON1011 - Intermediate Microeconomics: Game Theory & Market Structures

MIT 18.03 - Differential Equations: Ordinary Differential Equations, Laplace & Fourier

CPA Exam FAR - Financial Accounting & Reporting: US GAAP & Revenue Recognition