100 Java Exam Key Knowledge Points | Generated by AI

Home 2026.01

Question: What are 100 essential knowledge points for the 08553 Introduction to Programming—Java exam in the China National Higher Education Self-study Examination?

Answer: The 08553 Introduction to Programming—Java exam focuses on the fundamentals of the Java language, Object-Oriented Programming (OOP) principles, and basic GUI/IO operations. Below are 100 key knowledge points organized by category to help you prepare.

I. Java Basics & Environment

  1. Java’s Origin: Created by Sun Microsystems (led by James Gosling) in 1995.
  2. Platform Independence: Achieved via the “Write Once, Run Anywhere” (WORA) principle.
  3. JVM (Java Virtual Machine): The engine that interprets and executes Java bytecode.
  4. JRE (Java Runtime Environment): Includes the JVM and core libraries needed to run programs.
  5. JDK (Java Development Kit): Includes JRE plus development tools like javac (compiler).
  6. Bytecode: The .class file generated by the compiler; it is intermediate code between source and machine code.
  7. Compilation Command: javac FileName.java.
  8. Execution Command: java ClassName.
  9. Main Method Signature: public static void main(String[] args).
  10. Source File Rule: A .java file can have only one public class, and the filename must match that class name.
  11. Comments: Single-line (//), multi-line (/* ... */), and documentation (/** ... */).
  12. Case Sensitivity: Java is strictly case-sensitive (e.g., Main and main are different).
  13. Keywords: Reserved words (like class, int, void) cannot be used as identifiers.

II. Data Types, Variables, and Operators

  1. 8 Primitive Types: byte, short, int, long, float, double, char, boolean.
  2. Integer Sizes: byte (8-bit), short (16-bit), int (32-bit), long (64-bit).
  3. Floating Point: float (32-bit), double (64-bit). Default literal is double.
  4. Char Type: Uses 16-bit Unicode; can represent Chinese characters.
  5. Boolean Type: Only two values: true or false (cannot be 0 or 1).
  6. Type Casting (Implicit): Automatic conversion from smaller to larger types (e.g., int to double).
  7. Type Casting (Explicit): Manual conversion (e.g., (int)3.14).
  8. Arithmetic Operators: +, -, *, /, % (modulus).
  9. Relational Operators: ==, !=, >, <, >=, <=.
  10. Logical Operators: && (AND), || (OR), ! (NOT).
  11. Short-circuiting: && and || stop evaluating if the result is determined early.
  12. Assignment Operators: =, +=, -=, etc.
  13. Increment/Decrement: ++i (pre-increment) vs i++ (post-increment).

III. Control Structures

  1. if-else: Basic conditional branching.
  2. switch-case: Works with byte, short, char, int, String (since Java 7), and Enums.
  3. break in switch: Prevents “fall-through” to the next case.
  4. while loop: Condition checked before execution.
  5. do-while loop: Condition checked after execution (runs at least once).
  6. for loop: Best for known iteration counts.
  7. Enhanced for loop: for (Type var : collection) used for arrays and collections.
  8. break: Exits the current loop entirely.
  9. continue: Skips the rest of the current iteration and moves to the next.

IV. Array Handling

  1. Array Definition: Fixed-size container for elements of the same type.
  2. Index: Starts at 0 and ends at length - 1.
  3. Initialization: int[] arr = new int[5]; or int[] arr = {1, 2, 3};.
  4. Length Property: arr.length returns the number of elements.
  5. Exception: Accessing arr[length] triggers ArrayIndexOutOfBoundsException.
  6. Multi-dimensional Arrays: An array of arrays (e.g., int[][] matrix).

V. Object-Oriented Programming (OOP) Core

  1. Class: A blueprint or template for objects.
  2. Object: An instance of a class.
  3. Encapsulation: Bundling data (fields) and methods; using private for data hiding.
  4. Inheritance: Using extends to inherit properties from a parent class.
  5. Polymorphism: The ability of an object to take on many forms (Overloading vs Overriding).
  6. Abstraction: Using abstract classes and interfaces to define “what” rather than “how.”
  7. Constructor: A special method to initialize objects; has no return type and matches the class name.
  8. Default Constructor: Provided by Java automatically if no constructor is defined.
  9. this keyword: Refers to the current object instance.
  10. super keyword: Refers to the parent class instance or constructor.
  11. Method Overloading: Same name, different parameters (same class).
  12. Method Overriding: Same name and parameters in a subclass (using @Override).
  13. Access Modifiers: public, protected, default (no modifier), and private.
  14. private: Visible only within the same class.
  15. public: Visible everywhere.
  16. protected: Visible in the same package and subclasses.
  17. final (variable): Constant value.
  18. final (method): Cannot be overridden.
  19. final (class): Cannot be inherited (e.g., String class).
  20. static (field): Shared by all instances of the class.
  21. static (method): Belongs to the class, not an object; cannot access non-static members.

VI. Interfaces and Abstract Classes

  1. Abstract Class: Cannot be instantiated; can have abstract and concrete methods.
  2. Interface: A contract; only contains constants and abstract methods (pre-Java 8).
  3. Multiple Inheritance: A class can implement multiple interfaces but extend only one class.
  4. implements keyword: Used to use an interface.

VII. String Handling

  1. String: Immutable (value cannot change after creation).
  2. StringBuffer: Mutable, thread-safe (synchronized).
  3. StringBuilder: Mutable, faster, but not thread-safe.
  4. String Comparison: Always use .equals() for content, not == (which compares memory address).
  5. Common Methods: length(), charAt(), substring(), indexOf(), trim().

VIII. Exception Handling

  1. Throwable: The root class of all errors and exceptions.
  2. Error: Serious problems (e.g., OutOfMemoryError) that programs shouldn’t try to catch.
  3. Exception: Divided into Checked and Unchecked.
  4. Checked Exceptions: Checked at compile time (e.g., IOException). Must use try-catch or throws.
  5. Unchecked (Runtime) Exceptions: Occur at runtime (e.g., NullPointerException).
  6. try block: Contains code that might throw an exception.
  7. catch block: Handles the exception.
  8. finally block: Code that always runs, regardless of an exception (used for closing resources).
  9. throw: Used to manually trigger an exception.
  10. throws: Declared in a method signature to indicate it might throw an exception.

IX. Java I/O System

  1. Stream: A sequence of data.
  2. Byte Streams: InputStream, OutputStream (for images, binary files).
  3. Character Streams: Reader, Writer (for text files).
  4. File Class: Used to manipulate file properties and directories.
  5. Buffered Streams: Improve performance by reducing the number of I/O operations.
  6. Serialization: Converting an object into a byte stream using the Serializable interface.

X. GUI & Event Handling (AWT/Swing)

  1. AWT (Abstract Window Toolkit): Heavyweight, platform-dependent components.
  2. Swing: Lightweight, platform-independent components (starts with ‘J’, e.g., JButton).
  3. JFrame: The main window of a GUI application.
  4. Layout Managers: FlowLayout, BorderLayout, GridLayout.
  5. Event Source: The component that generates the event (e.g., a Button).
  6. Event Listener: An interface that handles the event (e.g., ActionListener).
  7. Event Handler: The method inside the listener (e.g., actionPerformed).

XI. Multithreading & Collections

  1. Thread Creation: Extend Thread class or implement Runnable interface.
  2. Thread Start: Call the .start() method, which invokes .run().
  3. Synchronization: Using the synchronized keyword to prevent data races.
  4. Collection Interface: Root of the collection hierarchy (List, Set).
  5. ArrayList: Dynamic array, allows duplicates, maintains order.
  6. HashMap: Stores key-value pairs; no duplicate keys allowed.

Would you like me to provide a practice code snippet for any of these specific topics, such as inheritance or exception handling?

Back

google/gemini-3-flash-preview

Donate