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

What's New in 2026-27?

The ICSE Class 10 Computer Applications syllabus for 2026-27 is entirely Java-based and covers fundamental to intermediate Object-Oriented Programming concepts. CISCE has continued the dual-paper format — Theory (100 marks) and Practical (100 marks) — making this a 200-mark subject. The competency-based approach means more application-oriented programming questions that test logical thinking and problem-solving ability rather than rote code memorisation.

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

Syllabus Overview

Unit	Topics	Key Concepts
OOP Principles	Object-oriented paradigm, abstraction, encapsulation	Classes and objects, data hiding
Objects and Classes	Class definition, member variables, methods, constructors	Default and parameterised constructors
Data Types	Primitive types (byte, short, int, long, float, double, char, boolean)	Type casting, autoboxing
Operators	Arithmetic, relational, logical, assignment, increment/decrement, ternary	Operator precedence
Input (Scanner)	Scanner class, next(), nextInt(), nextLine(), nextDouble()	User input handling
Conditionals	if, if-else, if-else-if, switch-case, ternary operator	Nested conditions
Loops	for, while, do-while, nested loops	Loop control (break, continue)
Methods	User-defined methods, parameters, return types, method overloading	Pure functions, calling methods
Constructors	Default, parameterised, constructor overloading	this keyword
Library Classes	Math class, String class methods	Built-in functions
Encapsulation	Access specifiers (private, public, protected), getters/setters	Data hiding principles
Arrays	1D and 2D arrays, declaration, initialisation, traversal	Searching, sorting, matrix operations
String Handling	String methods, StringBuffer/StringBuilder	String manipulation programs

Chapter-wise Detailed Syllabus

1. Object-Oriented Programming Principles

Introduction to OOP paradigm — advantages over procedural programming. Four pillars: Abstraction, Encapsulation, Inheritance (basic concept), Polymorphism (basic concept). Understanding objects as real-world entities with attributes (data) and behaviours (methods). Class as a blueprint for objects.

2. Objects and Classes

Defining a class — class keyword, member variables (instance variables), methods. Creating objects using the new keyword. Accessing members using dot operator. this keyword — referring to current object. Static members vs. instance members. Class design for real-world problems (Student, Employee, Bank Account).

3. Data Types and Variables

Primitive data types: byte (1 byte), short (2 bytes), int (4 bytes), long (8 bytes), float (4 bytes), double (8 bytes), char (2 bytes — Unicode), boolean. Variable declaration, initialisation, scope (local, instance, class). Type casting — widening (implicit) and narrowing (explicit). Constants using final keyword.

4. Operators

Arithmetic (+, -, *, /, %), relational (==, !=, <, >, <=, >=), logical (&&, ||, !), assignment (=, +=, -=, *=, /=, %=), increment/decrement (++, --), ternary (?:). Operator precedence and associativity. String concatenation using +. Expression evaluation.

5. Input Handling (Scanner Class)

Importing java.util.Scanner. Creating Scanner object: Scanner sc = new Scanner(System.in). Methods: nextInt(), nextDouble(), nextFloat(), next(), nextLine(), nextChar() (using next().charAt(0)). Handling input mismatch exceptions. Reading multiple inputs.

6. Conditional Statements

if statement, if-else, if-else-if ladder, nested if. switch-case statement — syntax, fall-through, break, default. When to use switch vs. if-else. Ternary operator for concise conditions. Programs: grade calculator, menu-driven programs, eligibility checks.

7. Iterative Statements (Loops)

for loop — syntax, counter-controlled iteration. while loop — condition-controlled iteration. do-while loop — guaranteed single execution. Nested loops — patterns, matrix traversal. Loop control: break (exit loop), continue (skip iteration). Infinite loops and how to avoid them. Programs: number patterns, series summation, digit extraction.

8. User-Defined Methods

Method declaration — access modifier, return type, method name, parameters. Calling methods — with and without return values. Passing arguments — pass by value. Method overloading — same name, different parameter lists. void methods vs. return-type methods. Recursive methods (basic understanding). Programs: prime check, factorial, Fibonacci, palindrome.

9. Constructors

Definition and purpose — initialising objects. Default constructor (no parameters). Parameterised constructor. Constructor overloading — multiple constructors with different parameters. Difference between constructor and method. this() — calling one constructor from another. Programs: Student, Employee, Rectangle classes with constructors.

10. Library Classes

Math class: Math.abs(), Math.sqrt(), Math.pow(), Math.min(), Math.max(), Math.ceil(), Math.floor(), Math.round(), Math.random().

String class: length(), charAt(), substring(), indexOf(), lastIndexOf(), equals(), equalsIgnoreCase(), compareTo(), toUpperCase(), toLowerCase(), trim(), replace(), concat(), valueOf().

11. Encapsulation

Access specifiers — private, public, protected, default (package-private). Data hiding using private variables. Getter and setter methods. Benefits of encapsulation — data security, modularity, maintainability. Programs: BankAccount class with private balance and public deposit/withdraw methods.

12. Arrays

1D Arrays: Declaration, creation, initialisation. Traversal using loops. Common operations: input, display, sum, average, max, min, search (linear, binary), sort (bubble, selection). Passing arrays to methods.

2D Arrays: Declaration, creation, initialisation. Row-wise and column-wise traversal. Matrix operations: addition, subtraction, transpose, diagonal sum. Programs: magic square check, search in matrix, row/column sum.

13. String Handling Programs

Character-by-character processing. Programs: word count, vowel/consonant count, frequency of characters, reverse a string, palindrome check, capitalise first letters, extract digits, toggle case, remove duplicates, arrange words alphabetically. String comparison and sorting.

Exam Pattern 2026-27

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

Prescribed Textbooks

• Understanding Computer Applications with BlueJ — APC Publications (Sumita Arora)
• Computer Applications for ICSE Class 10 — Avichal Publishing Company
• Total Computing — ICSE Computer Applications — Morning Star
• CISCE specimen papers and previous years' board papers

Preparation Tips

1. Code daily — there is no substitute — Write at least 2-3 Java programs daily using BlueJ or any IDE. Computer Applications is a skill-based subject that requires consistent practice.
2. Master String and Array programs — These are the most frequently tested topics in both theory and practicals. Build a library of 30+ solved String and Array programs.
3. Practise output tracing — Theory Section A includes code snippets where you must predict the output. Practise tracing through loops, conditionals, and method calls step by step.
4. Understand method overloading — Method overloading is a guaranteed question. Know how Java differentiates methods by parameter type and count, not by return type.
5. Learn constructor patterns — Default constructors, parameterised constructors, and constructor overloading are high-weightage topics. Write constructor-based classes for practice.
6. Memorise String class methods — Know the syntax, return type, and usage of all String methods. Create a reference chart and revise daily.
7. Prepare for the practical exam — The practical carries 100 marks. Practise solving unseen problems within a time limit. Focus on clean code, proper variable names, and correct output formatting.