Monash FIT2093 - Introduction to Programming (Java Fundamentals) Flashcards

Question 1

What is the basic structure of a Java program's `main` method?

Accepted Answer

The entry point for any Java application is the `main` method, defined as:
```java
public static void main(String[] args) {
    // Program logic goes here
}
```

Question 2

Differentiate between single-line and multi-line comments in Java.

Accepted Answer

Single-line comments start with `//`. Example: `// This is a comment`
Multi-line comments start with `/*` and end with `*/`. Example: `/* This is a multi-line comment */`

Question 3

List the four main primitive data types in Java for storing whole numbers, decimal numbers, single characters, and boolean values.

Accepted Answer

1. `int`: For whole numbers (e.g., 10, -5).
2. `double`: For floating-point numbers (e.g., 3.14, -0.5).
3. `char`: For single characters (e.g., 'A', 'z').
4. `boolean`: For true/false values.

Question 4

How do you declare and initialize an `int` variable named `age` with the value `30` in Java?

Accepted Answer

`int age = 30;`

Question 5

Explain the purpose of type casting in Java and provide an example of explicit casting.

Accepted Answer

Type casting converts a value from one data type to another.
*   **Implicit (widening)**: Automatic conversion from a smaller to a larger type (e.g., `int` to `double`).
*   **Explicit (narrowing)**: Manual conversion from a larger to a smaller type, which might result in data loss.
Example: `double myDouble = 9.78; int myInt = (int) myDouble; // myInt will be 9`

Question 6

What are the three main categories of operators used for comparison, logic, and arithmetic in Java?

Accepted Answer

* **Relational Operators**: `==` (equal to), `!=` (not equal to), `<` (less than), `>` (greater than), `<=` (less than or equal to), `>=` (greater than or equal to). * **Logical Operators**: `&&` (logical AND), `||` (logical OR), `!` (logical NOT). * **Arithmetic Operators**: `+`, `-`, `*`, `/`, `%` (modulo).

Question 7

Write a simple `if-else` statement that checks if a variable `score` is greater than or equal to `50` and prints "Pass" or "Fail" accordingly.

Accepted Answer

```java
int score = 65;
if (score >= 50) {
    System.out.println("Pass");
} else {
    System.out.println("Fail");
}
```

Question 8

Describe the difference between a `while` loop and a `do-while` loop.

Accepted Answer

A `while` loop checks its condition *before* executing the loop body. If the condition is initially false, the body never executes.
A `do-while` loop executes its body *at least once* before checking its condition. The condition is checked *after* the first iteration.

Question 9

How do you declare and initialize an array of 5 integers named `numbers`?

Accepted Answer

You can declare and initialize an array in two main ways:
1.  `int[] numbers = new int[5];` (creates an array of 5 integers, initialized to 0).
2.  `int[] numbers = {10, 20, 30, 40, 50};` (creates and initializes with specific values).

Question 10

What is a method in Java, and how do you define one that takes two `int` parameters and returns their sum?

Accepted Answer

A method is a block of code that performs a specific task. Here's an example:
```java
public int add(int a, int b) {
    return a + b;
}
```

Question 11

Explain the concept of a "class" and an "object" in Java.

Accepted Answer

A **class** is a blueprint or template for creating objects. It defines the attributes (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, with its own unique state (values for its attributes).

Question 12

How do you create an object of a class named `Car`?

Accepted Answer

`Car myCar = new Car();`

Question 13

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

Accepted Answer

A constructor is a special method used to initialize objects. It has the same name as the class and no return type. It is automatically called when an object is created using the `new` keyword.

Question 14

Define encapsulation in the context of OOP and how it's achieved in Java.

Accepted Answer

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

Question 15

Explain the concept of inheritance in Java using the `extends` 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 establish this relationship. The subclass inherits fields and methods from the superclass, promoting code reusability.

Question 16

What is method overriding, and how does it relate to polymorphism?

Accepted Answer

Method overriding occurs when a subclass provides a specific implementation for a method that is already defined in its superclass. It's a key aspect of **runtime polymorphism**, where the actual method executed depends on the type of the object at runtime, not the type of the reference variable.

Question 17

What is polymorphism in Java? Provide an example.

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 interface to represent different underlying forms.
Example: If `Dog` and `Cat` `extends Animal`, then `Animal myAnimal = new Dog();` and `myAnimal = new Cat();` are valid, and `myAnimal.makeSound()` would call the specific `Dog` or `Cat` sound method.

Question 18

How do you handle potential runtime errors (exceptions) in Java using a `try-catch` block?

Accepted Answer

A `try-catch` block is used to handle exceptions gracefully. Code that might throw an exception is placed inside the `try` block. If an exception occurs, the program jumps to the `catch` block, which specifies the type of exception to handle and the code to execute.
```java
try {
    int result = 10 / 0; // This will throw an ArithmeticException
} catch (ArithmeticException e) {
    System.err.println("Error: Division by zero!");
}
```

Question 19

What is the purpose of the `finally` block in exception handling?

Accepted Answer

The `finally` block contains code that will *always* be executed, regardless of whether an exception occurred in the `try` block or was caught by a `catch` block. It's typically used for cleanup operations like closing files or database connections.

Question 20

Differentiate between primitive types and reference types in Java.

Accepted Answer

*   **Primitive Types** (e.g., `int`, `double`, `boolean`): Store the actual value directly in memory. They are fixed-size and passed by value.
*   **Reference Types** (e.g., `String`, `Object`, arrays): Store a memory address (a reference) to where the actual object data is stored on the heap. They are passed by reference (the reference itself is passed by value).

Question 21

What is the `this` keyword used for in Java?

Accepted Answer

The `this` keyword refers to the current instance of a class. It can be used to:
*   Distinguish between instance variables and local variables (e.g., `this.name = name;`).
*   Call another constructor from within the same class (e.g., `this(param1, param2);`).
*   Pass the current object as an argument to a method.

Question 22

Explain the concept of method overloading.

Accepted Answer

Method overloading allows a class to have multiple methods with the same name but different parameter lists (different number of parameters, different types of parameters, or different order of parameter types). The return type can be different but is not sufficient to differentiate overloaded methods. This is a form of compile-time polymorphism.

Monash FIT2093 - Introduction to Programming (Java Fundamentals)

Card Preview

Related Flashcard Sets

Machine Learning - Deep Learning Architectures (CNNs, RNNs, Transformers)

Pharmacology - Renal & Endocrine Systems

Organic Chemistry - Spectroscopy (NMR, IR, Mass Spec)

EE105 Midterm Formulas