Part 1: Detailed Study Guide

1. Object-Oriented Programming (OOP) Core Concepts

• Object & Class: An object is an identifiable entity with characteristics (state/variables) and behaviour (methods). A class acts as a blueprint or an "Object Factory" from which individual objects are created. A class is a user-defined data type.
• Message Passing: Software objects interact and communicate by sending messages to each other using method calls.
• Data Encapsulation: The wrapping of data and methods into a single unit (the class). This enables data hiding, protecting data from direct access by the outside world.
• Data Abstraction: The act of representing essential features without including background details or complex internal workings. Classes are often called Abstract Data Types (ADT).
• Inheritance: The process where a derived class acquires the properties of a base class, promoting code reusability.
• Polymorphism: The ability of a method to take more than one form, such as method overloading where methods share the same name but take different parameters.

2. Java Basics: Tokens and Data Types

• Tokens: The smallest individual elements of a Java program. Types include Keywords (reserved words like int, class), Identifiers (names given to variables/methods), Constants/Literals (unchanging values), Operators, and Punctuators.
• Primitive Data Types: Java supports 8 primitive types: byte, short, int, long (integers); float, double (floating point); char (16-bit Unicode characters); and boolean (true/false).
• Reference Data Types: Derived from primitive types, they store memory addresses rather than actual values. Examples include arrays, classes, and interfaces.

3. Operators and Input

• Operators: Categorised by operands as unary (one), binary (two), and ternary (three). They include arithmetic, relational, logical, assignment, and increment/decrement operators.
• Scanner Class: Found in the java.util package, it is used to easily parse primitive types and strings from input streams like the keyboard (System.in).

4. Control Structures & Loops

• Conditional Statements: Include if-else constructs to execute code based on boolean conditions. The switch statement is a selective structure matching a variable against integer, character, or string constants. The break statement is vital in a switch block to prevent fall-through.
• Loops: Used for repetitive execution.
  • for loop: Best when the number of iterations is fixed.
  • while loop: An entry-controlled loop that checks the condition before executing the block.
  • do-while loop: An exit-controlled loop that ensures the block runs at least once before checking the condition.
• Jump Statements: break forces an immediate exit from a loop or switch. continue skips the rest of the current loop iteration and proceeds to the update statement/next iteration.

Part 2: Short-Answer Quiz

Answer the following ten questions in 2-3 sentences each.

1. What is the conceptual difference between a class and an object?
2. How does data encapsulation protect data within a Java program?
3. What are the naming rules for an identifier in Java?
4. How do primitive data types differ from reference data types?
5. Why is the Scanner class useful, and which package must be imported to use it?
6. Explain the fundamental difference between a while loop and a do-while loop.
7. What does polymorphism mean in the context of Java?
8. Why is the break statement crucial inside a switch-case construct?
9. What is a token in Java, and what are its main categories?
10. What is an entry-controlled loop? Provide an example.

Part 3: Quiz Answer Key

1. Answer: A class is a blueprint or template that defines common properties and behaviours. An object is a specific, identifiable instance created from that blueprint, possessing its own unique state and behaviour.
2. Answer: Data encapsulation wraps data and member functions into a single unit (the class). This hides the data from the outside world, ensuring it can only be accessed and modified through the class's own methods.
3. Answer: Identifiers can contain alphabets, numbers, underscores, and dollar signs, but they must begin with an alphabet, underscore, or dollar sign. They cannot contain spaces, punctuation marks, or match any predefined Java keywords.
4. Answer: Primitive data types are basic, independent types built into Java (like int and boolean) that hold actual values. Reference data types (like classes and arrays) are constructed from primitive types and store the memory address of the actual data.
5. Answer: The Scanner class simplifies the process of getting input from a user via standard input streams like a keyboard. To use it, a programmer must import the java.util.Scanner package into their program.
6. Answer: A while loop is entry-controlled, meaning it checks its condition before executing; if false initially, it never runs. A do-while loop is exit-controlled, meaning it executes its body first and checks the condition at the end, guaranteeing at least one execution.
7. Answer: Polymorphism is the ability of a method or function to take more than one form. In Java, this is commonly seen as method overloading, where methods share the same name but behave differently based on the parameters passed to them.
8. Answer: The break statement is necessary to terminate the switch block once a matching case is executed. Without it, the program will "fall through" and automatically execute all subsequent case blocks until a break is found or the switch ends.
9. Answer: A token is the smallest individual meaningful element in a Java program. The main categories of tokens include keywords, identifiers, constants/literals, operators, and punctuators.
10. Answer: An entry-controlled loop evaluates its test condition at the very beginning, preventing the loop body from executing if the condition is false. The for loop and while loop are examples of entry-controlled loops.

Part 4: Essay Questions & Detailed Answers

import java.util.Scanner;

public class SimpleCalculator {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter first number:");
        double num1 = sc.nextDouble();
        
        System.out.println("Enter an operator (+, -, *, /):");
        char operator = sc.next().charAt(0);
        
        System.out.println("Enter second number:");
        double num2 = sc.nextDouble();
        
        switch (operator) {
            case '+':
                System.out.println("Result: " + (num1 + num2));
                break;
            case '-':
                System.out.println("Result: " + (num1 - num2));
                break;
            case '*':
                System.out.println("Result: " + (num1 * num2));
                break;
            case '/':
                if (num2 != 0) {
                    System.out.println("Result: " + (num1 / num2));
                } else {
                    System.out.println("Error: Division by zero.");
                }
                break;
            default:
                System.out.println("Invalid operator.");
        }
    }
}

Part 5: Comprehensive Glossary

Abstraction

The act of representing essential features of an object without including background details or inner workings.

Class

A user-defined data type that serves as a blueprint or factory from which individual objects with shared properties and behaviours are created.

Encapsulation

The principle of wrapping up data and member functions into a single unit (the class), ensuring data hiding and security from external access.

Identifier

A sequence of characters used by programmers to name variables, methods, classes, packages, and interfaces in Java.

Inheritance

The process by which an object of one class (derived class) acquires the properties and methods of another class (base class), facilitating code reusability.

Keyword

A predefined, reserved word in Java that holds special meaning to the compiler and cannot be used as an identifier (e.g., class, int, public).

Object

An identifiable entity, modelled from real life, possessing specific characteristics (state) and behaviour (methods). An instance of a class.

Polymorphism

The ability of a single function or method to take on multiple forms and exhibit different behaviours depending on the data passed to it (e.g., method overloading).

Primitive Data Type

The basic data types built into Java that hold actual values rather than memory addresses. The 8 types are byte, short, int, long, float, double, boolean, and char.

Scanner

A class in the java.util package used to parse primitive types and strings, commonly used to collect input from standard input devices like a keyboard.

Switch Statement

A conditional control structure that allows a variable to be tested for equality against a list of literal values or constant cases.

Token

The smallest individual element of a Java program that is meaningful to the compiler.