Looking for one-to-one help? See our icse class 10 tuition in gurgaon page.
ICSE Class 10 Computer Applications for 2027 is Java programming in eight official topics, from classes and user-defined methods to arrays and string handling, assessed through a two-hour, 100-mark written paper and 100 marks of internal assessment. To do well, practise writing short, complete programs by hand every week, because the written paper tests whether you can produce correct Java on paper without a compiler to help.
This guide is part of our ICSE Class 10 tuition in Gurgaon series. It sets out the 2027 topics exactly as CISCE lists them, explains the mark scheme, gives eight short BlueJ-style programs covering the program types students meet most, lists the errors that cost the most marks, and shows a method for writing programs in the exam.
Computer Applications is a Group III subject in ICSE, so its marks are split 50% written paper and 50% internal assessment. The ICSE 2027 Computer Applications syllabus, on the official ICSE 2027 regulations and syllabuses page, lists these Class 10 topics.
| # | Topic (as headed in the syllabus) | What it covers |
|---|---|---|
| 1 | Revision of Class IX Syllabus | OOP concepts, objects and classes, data types, operators, input, Math library methods, conditionals, loops, nested for loops |
| 2 | Class as the Basis of all Computation | Objects, member variables and methods, primitive versus composite data types |
| 3 | User-defined Methods | Method definition and calling, static and non-static, pure and impure methods, call by value (with programs), call by reference (definition only), method overloading |
| 4 | Constructors | Default and parameterised constructors, constructor overloading, constructor versus method |
| 5 | Library classes | Wrapper classes, autoboxing and unboxing, methods such as parseInt, isDigit, isLetter, isUpperCase, toUpperCase |
| 6 | Encapsulation | private, protected and public; scope of class, instance, argument and local variables |
| 7 | Arrays | Single and double dimensional arrays; selection sort and bubble sort; linear search and binary search (single dimensional only); row, column and diagonal sums in a 2D array |
| 8 | String handling | String methods such as trim, length, charAt, indexOf, substring, equals, compareTo, replace, startsWith; sorting and searching strings in an array |
Programs in the syllabus are written in Java. The syllabus suggests the BlueJ environment (3.2 or higher, with JDK 5.0 or higher) or any other editor or IDE compatible with the JDK. All eight programs below use only standard Java and run in BlueJ.
| Component | Marks | Details from the 2027 syllabus |
|---|---|---|
| Written paper | 100 | One paper of two hours |
| Internal assessment | 100 | At least 20 laboratory (programming) assignments during the year; subject teacher 50 marks and external examiner 50 marks |
On the paper's section-wise format, be careful. CISCE's circular of 09 October 2026 on 2027 specimen papers lists a Class IX 2027 specimen for Computer Applications, not a Class X one, and says that for subjects without a 2027 specimen "the existing rubrics and assessment structure of Year 2026 Examination cycle shall apply". So, for Class 10, practise from the 2026 pattern and your school's guidance. Our ICSE specimen paper 2027 guide explains the circular in full.
Writing Java on paper is a different skill from typing it in BlueJ. There is no compiler to point out a missing semicolon. Use the same five steps for every program question.
From our tutors: students who code happily in BlueJ are often surprised by how many small errors they make on paper. We ask them to write at least two programs a week by hand, then type them in exactly as written and see what the compiler says. Within a month, most students start catching their own errors before typing, which is exactly what the written paper needs.
These eight programs cover the program types that come up most often across the syllabus topics. They are kept short and in standard Java. We have traced each one by hand for the sample inputs shown.
A class with private data members, a default constructor, and accept, compute and display methods, called from main.
import java.util.Scanner;
public class Student
{
private String name;
private int m1, m2, m3;
private double average;
public Student() // default constructor
{
name = "";
m1 = 0;
m2 = 0;
m3 = 0;
average = 0.0;
}
public void accept()
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter name: ");
name = sc.nextLine();
System.out.print("Enter marks in three subjects: ");
m1 = sc.nextInt();
m2 = sc.nextInt();
m3 = sc.nextInt();
}
public void compute()
{
average = (m1 + m2 + m3) / 3.0; // 3.0 avoids integer division
}
public void display()
{
System.out.println("Name: " + name);
System.out.println("Average: " + average);
}
public static void main(String[] args)
{
Student s = new Student();
s.accept();
s.compute();
s.display();
}
}
With marks 80, 90 and 70, the program prints "Average: 80.0". Dividing by 3 instead of 3.0 would do integer division on the sum first, which loses the decimal part for other inputs.
public class Volume
{
void volume(double side) // cube
{
System.out.println("Cube: " + (side * side * side));
}
void volume(double r, double h) // cylinder
{
System.out.println("Cylinder: " + (Math.PI * r * r * h));
}
void volume(double l, double b, double h) // cuboid
{
System.out.println("Cuboid: " + (l * b * h));
}
public static void main(String[] args)
{
Volume ob = new Volume();
ob.volume(3.0);
ob.volume(2.0, 7.0);
ob.volume(4.0, 5.0, 6.0);
}
}
Output: 27.0 for the cube, about 87.96 for the cylinder, and 120.0 for the cuboid. Java picks the method by the number (and types) of arguments, which is what overloading means.
A special number equals the sum of the factorials of its digits, for example 145 = 1! + 4! + 5! = 1 + 24 + 120.
import java.util.Scanner;
public class SpecialNumber
{
static int factorial(int d)
{
int f = 1;
for (int i = 1; i <= d; i++)
f = f * i;
return f;
}
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter a positive number: ");
int n = sc.nextInt();
int temp = n, sum = 0;
while (temp > 0)
{
int digit = temp % 10; // last digit
sum = sum + factorial(digit);
temp = temp / 10; // remove last digit
}
if (sum == n)
System.out.println(n + " is a Special number");
else
System.out.println(n + " is not a Special number");
}
}
Input 145 prints "145 is a Special number"; input 123 prints "123 is not a Special number". The pattern of % 10 and / 10 is the base of every digit program: palindrome numbers, Armstrong numbers, digit sums.
import java.util.Scanner;
public class BinarySearch
{
public static void main(String[] args)
{
int[] a = {5, 12, 19, 23, 37, 41, 56, 68, 74, 90}; // must be sorted
Scanner sc = new Scanner(System.in);
System.out.print("Enter number to search: ");
int key = sc.nextInt();
int low = 0, high = a.length - 1, pos = -1;
while (low <= high)
{
int mid = (low + high) / 2;
if (a[mid] == key)
{
pos = mid;
break;
}
else if (a[mid] < key)
low = mid + 1;
else
high = mid - 1;
}
if (pos == -1)
System.out.println("Search element not found");
else
System.out.println(key + " found at index " + pos);
}
}
Searching for 41 prints "41 found at index 5" (mid goes 4, then 7, then 5). Searching for 50 prints "Search element not found". Binary search only works on a sorted array; linear search works on any array but checks elements one by one.
public class SortWords
{
public static void main(String[] args)
{
String[] city = {"Sohna", "Delhi", "Agra", "Panipat", "Jaipur"};
int n = city.length;
for (int i = 0; i < n - 1; i++)
{
for (int j = 0; j < n - 1 - i; j++)
{
if (city[j].compareTo(city[j + 1]) > 0)
{
String t = city[j];
city[j] = city[j + 1];
city[j + 1] = t;
}
}
}
for (int i = 0; i < n; i++)
System.out.println(city[i]);
}
}
Output, one per line: Agra, Delhi, Jaipur, Panipat, Sohna. Strings are compared with compareTo(), never with < or >. For selection sort, find the position of the smallest remaining element in each pass and swap it into place once.
public class MatrixSums
{
public static void main(String[] args)
{
int[][] m = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int n = m.length;
int left = 0, right = 0;
for (int i = 0; i < n; i++)
{
int rowSum = 0;
for (int j = 0; j < n; j++)
{
System.out.print(m[i][j] + "\t");
rowSum = rowSum + m[i][j];
}
System.out.println("Row sum = " + rowSum);
left = left + m[i][i];
right = right + m[i][n - 1 - i];
}
for (int j = 0; j < n; j++)
{
int colSum = 0;
for (int i = 0; i < n; i++)
colSum = colSum + m[i][j];
System.out.println("Column " + (j + 1) + " sum = " + colSum);
}
System.out.println("Left diagonal sum = " + left);
System.out.println("Right diagonal sum = " + right);
}
}
The matrix prints in rows with row sums 6, 15 and 24; column sums are 12, 15 and 18; both diagonal sums are 15. The right diagonal uses m[i][n − 1 − i], the step students most often get wrong.
Move the letters before the first vowel to the end of the word and add "AY". The syllabus names Pig Latin among its sample assignments.
import java.util.Scanner;
public class PigLatin
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter a word: ");
String word = sc.next().toUpperCase();
int pos = -1;
for (int i = 0; i < word.length(); i++)
{
char ch = word.charAt(i);
if (ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U')
{
pos = i;
break;
}
}
String result;
if (pos == -1)
result = word + "AY";
else
result = word.substring(pos) + word.substring(0, pos) + "AY";
System.out.println("Pig Latin: " + result);
}
}
"trouble" gives "OUBLETRAY"; "owl" gives "OWLAY". Note that substring(0, pos) stops before index pos, which is exactly the letters before the vowel.
import java.util.Scanner;
public class CharCount
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter a sentence: ");
String s = sc.nextLine();
int upper = 0, lower = 0, digits = 0, spaces = 0, others = 0;
for (int i = 0; i < s.length(); i++)
{
char ch = s.charAt(i);
if (Character.isUpperCase(ch))
upper++;
else if (Character.isLowerCase(ch))
lower++;
else if (Character.isDigit(ch))
digits++;
else if (Character.isWhitespace(ch))
spaces++;
else
others++;
}
System.out.println("Uppercase: " + upper);
System.out.println("Lowercase: " + lower);
System.out.println("Digits: " + digits);
System.out.println("Spaces: " + spaces);
System.out.println("Others: " + others);
}
}
For "ICSE Exam 2027!", it prints 5 uppercase, 3 lowercase, 4 digits, 2 spaces and 1 other character, which add up to the 15 characters in the sentence. A quick total check like this is a good dry-run habit.
Does your child understand Java in class but freeze when writing programs on paper? Book a free demo class in Gurgaon, at home or online, and our tutor will work through a program with them line by line.
Book a Free Demo Class +91 92204 75088| Error | Example | Fix |
|---|---|---|
| Comparing strings with == | if (s == "YES") | Use s.equals("YES") or s.equalsIgnoreCase("yes") |
| = instead of == in a condition | if (n = 5) | Assignment is =, comparison is == |
| Integer division | (a + b + c) / 3 for an average | Divide by 3.0, or cast to double |
| Array index out of bounds | for (i = 0; i <= a.length; i++) | Use i < a.length; the last index is length − 1 |
| Missing break in switch | Cases "fall through" to the next | End each case with break unless fall-through is intended |
| Off-by-one in substring | substring(2, 5) expected to include index 5 | The end index is excluded |
| Forgetting that strings do not change | s.toUpperCase(); then using s | Assign the result: s = s.toUpperCase(); |
| length vs length() | a.length() for an array | Arrays use length; strings use length() |
| Uninitialised accumulator | int sum; sum = sum + x; | Initialise: int sum = 0; |
| Wrong method header | Using a different name from the question | Copy the class and method names exactly as given |
Output questions ("What will this code print?") test the same ideas: integer division, post- and pre-increment, string methods and loop counts. Trace them on paper with a small table of variable values rather than guessing.
The 100 internal marks come from programming work done through the year. According to the 2027 syllabus, students should complete "a minimum of 20 laboratory assignments during the whole year", and the teacher keeps a record of them. The syllabus suggests assignments on user-defined methods, constructors, library classes, encapsulation, arrays (sorting, searching and 2D arrays) and string handling, including palindromes and Pig Latin.
The work is marked by the subject teacher (50 marks) and an external examiner (50 marks). The syllabus gives four criteria: class design (10), variable description (10), coding and documentation (10), and execution or output (20). Practically, that means:
From our tutors: the assignment file is where marks are easiest to protect and easiest to lose. We encourage students to write the variable description table before they write the code, not after. It forces them to plan the program, and the table itself is a marked criterion. Students who work this way usually find the written paper easier too, because they have planned twenty programs properly.
Programming and maths reinforce each other: digit programs, series sums and number checks all rely on clear arithmetic thinking. If maths is also a focus, see the ICSE Class 10 Maths syllabus 2027, our ICSE Class 10 maths formulas page and our guide on how to score 95 in ICSE maths.
Across Gurugram, we work with ICSE students from schools such as The Shri Ram School (Aravali and Moulsari campuses), Scottish High International School and Lt. Atul Katarya Memorial School. We are not affiliated with any school named here. Ajay Vatsyayan Classes has 12+ years in Gurgaon and a network of 500+ verified tutors, teaching one-to-one at home or online.
Eight topics: Revision of Class IX syllabus; Class as the Basis of all Computation; User-defined Methods; Constructors; Library classes; Encapsulation; Arrays; and String handling, all in Java.
200 in total: a two-hour written paper of 100 marks and internal assessment of 100 marks.
No. CISCE's 09 October 2026 circular lists a Class IX 2027 specimen for Computer Applications only. For subjects without a 2027 specimen, it says the 2026 rubrics and assessment structure apply.
The 2027 syllabus asks for a minimum of 20 laboratory assignments during the year, evaluated by the subject teacher and an external examiner.
Programs using classes and constructors, method overloading, digit extraction, linear and binary search, bubble and selection sort, 2D array sums, and string manipulation (palindromes, Pig Latin, counting characters). The eight programs above cover these types.
The syllabus suggests BlueJ (3.2 or higher) or any other editor or IDE compatible with the JDK. Your school will tell you which one it uses for assignments.
Write the skeleton first, dry run with a small input, and check the common errors listed above. Practise writing programs by hand every week, then type them in exactly as written to see what you missed.