ICSE Class 9 Computer Applications Syllabus 2026-27 — Complete Guide with Java Topics & Tips

What's New in 2026-27?

The ICSE Class 9 Computer Applications syllabus for 2026-27 introduces students to Java programming and Object-Oriented concepts. This year lays the foundation for the more advanced Class 10 syllabus. The course covers the fundamentals — understanding OOP, Java basics, data types, operators, input handling, conditional statements, loops, arrays, and string basics. Like Class 10, this is a 200-mark subject (100 Theory + 100 Practical), so consistent coding practice is essential from the start.

Computer Applications carries 100 marks for Theory and 100 marks for Practical, for a total of 200 marks. Theory: 2 hours. Practical: 3 hours.

Syllabus Overview

Unit	Topics	Key Concepts
OOP Introduction	Object-oriented paradigm, procedural vs. OOP	Objects, classes, abstraction, encapsulation
Java Introduction	JVM, JDK, bytecode, BlueJ IDE	Platform independence, compilation, execution
Objects and Classes	Class definition, objects, instance variables, methods	Creating and using objects
Data Types	Primitive types, variables, constants	int, double, char, boolean, String
Operators	Arithmetic, relational, logical, assignment	Expression evaluation, precedence
Input (Scanner)	Scanner class for keyboard input	nextInt(), nextDouble(), nextLine()
Conditionals	if, if-else, if-else-if, switch-case	Decision-making in programs
Loops	for, while, do-while loops	Iteration, patterns, series
Arrays (1D)	Declaration, initialisation, traversal	Input, search, sort, display
String Basics	String creation, basic methods	length(), charAt(), substring()

Chapter-wise Detailed Syllabus

1. Introduction to Object-Oriented Programming

Procedural programming vs. Object-Oriented Programming — limitations of procedural approach. OOP concepts: Objects (real-world entities with attributes and behaviours), Classes (blueprints for objects), Abstraction (hiding complexity, showing essential features), Encapsulation (wrapping data and methods together, data hiding). Real-world examples of OOP — car (object), car design (class).

2. Introduction to Java

History of Java — James Gosling, Sun Microsystems (1995), now Oracle. Features of Java — platform independent (WORA — Write Once, Run Anywhere), object-oriented, simple, secure, robust. JVM (Java Virtual Machine) — executes bytecode. JDK (Java Development Kit) — compiler, tools. JRE (Java Runtime Environment). Compilation process: source code (.java) → compiler (javac) → bytecode (.class) → JVM → output. BlueJ IDE — writing, compiling, and running programs.

3. Objects and Classes

Defining a class using the class keyword. Instance variables — data stored in objects. Methods — behaviours/actions of objects. Creating objects using new keyword. main() method — entry point of Java programs. Accessing members using dot operator. Basic class examples: Student (name, age, grade), Rectangle (length, breadth, area method).

4. Data Types and Variables

Primitive data types: byte, short, int, long (integers of varying sizes), float, double (decimal numbers), char (single character — Unicode), boolean (true/false). Non-primitive: String (sequence of characters). Variable declaration and initialisation. Constants using final keyword. Type casting — widening (automatic: int → double) and narrowing (explicit: double → int). Naming conventions — camelCase for variables and methods, PascalCase for classes.

5. Operators

Arithmetic: + (addition), - (subtraction), * (multiplication), / (division — integer and decimal), % (modulus). Relational: == (equal to), != (not equal), < (less than), > (greater than), <= (less than or equal), >= (greater than or equal). Logical: && (AND), || (OR), ! (NOT). Assignment: =, +=, -=, *=, /=, %=. Increment/Decrement: ++, -- (prefix and postfix). Ternary: condition ? value1 : value2. Operator precedence and associativity. String concatenation using +.

6. Input Handling (Scanner Class)

Importing: import java.util.Scanner;. Creating Scanner: Scanner sc = new Scanner(System.in);. Input methods: nextInt() (read integer), nextDouble() (read decimal), next() (read word), nextLine() (read entire line), reading a character using next().charAt(0). Common issues: newline character after nextInt(), solving with extra nextLine(). Displaying output: System.out.println(), System.out.print().

7. Conditional Statements

if — single condition check. if-else — two-way decision. if-else-if ladder — multiple conditions. Nested if — conditions within conditions. switch-case — multi-way branching based on a value, break to prevent fall-through, default for unmatched cases. Ternary operator as shorthand for simple if-else. Programs: even/odd check, greatest of three numbers, grade calculator, calculator using switch, vowel/consonant check, day of the week.

8. Iterative Statements (Loops)

for loop — known number of iterations, syntax: for(init; condition; update). while loop — condition checked before execution, used when iterations unknown. do-while loop — condition checked after execution, guarantees at least one iteration. Nested loops — loops within loops, used for patterns and tables. Loop control: break (exit loop entirely), continue (skip current iteration). Programs: multiplication tables, factorial, sum of series, number patterns (triangles, diamonds), digit extraction (sum of digits, reverse a number), prime number check, Fibonacci series.

9. Arrays (1D)

What is an array — collection of similar data types. Declaration: int[] arr = new int[5];. Initialisation: int[] arr = {10, 20, 30, 40, 50};. Accessing elements using index (0-based). Traversal using for loop. arr.length property. Common operations: input elements, display elements, find sum/average, find maximum/minimum, linear search, count occurrences, reverse an array, sort (bubble sort — basic). Common errors: ArrayIndexOutOfBoundsException.

10. String Basics

String as a sequence of characters. Creating strings: String s = "Hello";. String is immutable in Java. Basic methods: length() — returns number of characters, charAt(index) — returns character at given position, substring(start, end) — extracts part of string, equals() — compares strings, toUpperCase(), toLowerCase() — case conversion. Concatenation using + operator and concat() method. Comparing strings — equals() vs. ==. Programs: count vowels, reverse a string, check palindrome, extract initials.

Exam Pattern 2026-27

Component	Details	Marks
Theory — Section A	Compulsory — MCQs, output tracing, short answers	40 marks
Theory — Section B	Answer 4 out of 6 programming/theory questions	60 marks
Practical Exam	Solve 2-3 programs on computer	100 marks
Total		200 marks

Prescribed Textbooks

• Understanding Computer Applications with BlueJ — APC Publications (Sumita Arora)
• Computer Applications for ICSE Class 9 — Avichal Publishing Company
• Total Computing — Morning Star

Preparation Tips

1. Start coding from Day 1 — Computer Applications is a practical subject. Install BlueJ and start writing simple programs immediately. Theory without practice is ineffective.
2. Type every program yourself — Do not just read programs from the textbook. Type them into BlueJ, compile, run, and understand the output. Debugging is where real learning happens.
3. Master loops and patterns — Loops are the most challenging topic for beginners. Practise 20+ pattern programs (triangle, pyramid, diamond, number patterns). Start simple and increase complexity.
4. Understand data types thoroughly — Know the size, range, and default values of each primitive type. Understand when to use int vs. double vs. char. Type casting errors are common in exams.
5. Practise output tracing on paper — Theory Section A includes code snippets where you predict the output. Practise by tracing through code line by line on paper, tracking variable values.
6. Build an array program library — Write and save programs for all common array operations (sum, average, max, min, search, sort, reverse). These form the basis for Class 10 programs.
7. Prepare for the practical exam early — The practical carries 100 marks. Practise solving unseen problems within 30-40 minutes each. Focus on clean code with proper variable names and comments.