Java Basics and OOP Concepts — ICSE Class 10 Computer Applications

Let us begin with the honest truth about this unit. Almost every ICSE Class 10 student opens the Computer Applications book, sees the words abstraction, encapsulation, inheritance, polymorphism sitting in a row, and quietly decides that this is the boring theory part to be crammed the night before the paper. That decision costs marks every single year, because these four words are not decoration. They are the reason Java is built the way it is, and once you actually understand them, class design questions in Section B stop feeling like guesswork.

So we are going to do this properly. No definitions dropped on you from a height. Every idea here starts from something you already do in ordinary life, and only then do we put the technical word on it. By the end of this page you will be able to explain what an object is without reciting a line, you will know exactly what happens between pressing compile and seeing output, and you will have written and traced real programs that run.

One promise before we start: every program on this page has been compiled and executed on JDK 11 before it was printed here. The output you see below each program is the output the machine actually produced, not what it should have produced. Type them yourself and you will get the same thing.

Your Game Plan

Follow these five steps in order and this unit is finished in one focused sitting. Skipping straight to the four principles is the usual mistake.

1. Get the object idea first. Read the objects and classes section until you can describe your own school bag as an object with state and behaviour. Everything else rests on this.
2. Learn the four principles with your own examples — not the ones printed here. An example you invented is one you cannot forget in the exam hall.
3. Type all four programs in BlueJ or any editor on JDK 11 or higher. Reading Java does not teach Java.
4. Do the dry run section with a pen. Write the value of every variable after every line. This is exactly how Section A output questions are earned.
5. Finish with the worksheet, answers hidden. Write first, reveal second. That gap is where your marks live.

Where This Unit Sits in the ICSE Class 10 Syllabus (and the Paper Pattern)

Open the official CISCE syllabus for Computer Applications (subject code 86) and look at the Class X section. The very first topic is Revision of Class IX Syllabus, and the first item inside it is Introduction to Object Oriented Programming concepts, followed by Elementary Concept of Objects and Classes. That word revision misleads a lot of students into thinking it will not be asked. It is asked, and it is asked in Section A where every mark is compulsory.

Two smaller notes on the syllabus that save arguments later. First, bitwise and shift operators are outside the scope of this course, so do not lose evenings on them. Second, the recommended environment is BlueJ 5.4.2 or higher with JDK 11 or higher, which is exactly what the programs on this page were tested on. Any editor works, but if your school uses BlueJ, use BlueJ — the examiner’s expectations are shaped by it.

↑ Back to top

Procedure-Oriented vs Object-Oriented Programming

Imagine two ways of running a school canteen. In the first, there is one long instruction sheet pinned to the wall: boil water, then add tea leaves, then collect money, then wash the cup, then call the next student. Everything is one sequence of steps, and the sugar jar sits on an open shelf where anybody passing can dip a spoon into it. That is procedure-oriented programming. The program is a list of procedures acting on data that is largely open to all of them.

In the second canteen, there is a tea counter, a cash counter and a washing station. Each one keeps its own things and does its own job, and if the cash counter needs tea it asks the tea counter rather than reaching over and grabbing it. That is object-oriented programming. The program is a set of objects, each holding its own data and offering a set of operations, and work gets done by objects sending messages to each other.

If a question asks for the difference and carries three marks, give three paired differences like the rows above — one side then the other side of the same point. Writing three facts about POP and then three unrelated facts about OOP is the commonest way students lose a mark here.

The Four Principles of OOP, Explained With Real Life

The syllabus asks for all four to be defined and explained using real life examples. That phrase is a gift: it tells you the examiner wants an example, so always give one.

1. Data abstraction. Showing only what is necessary and hiding the complicated detail behind it. When you switch on a ceiling fan you turn a regulator. You do not think about the capacitor, the winding or the phase difference. The regulator is the abstraction: essential controls exposed, mechanism hidden. In Java, when you call Math.sqrt(25) you get 5.0 without knowing the algorithm inside.

2. Encapsulation. Wrapping data and the methods that operate on that data into a single unit, and controlling access to that data. A medicine capsule holds its powder inside a shell; you cannot take out half the powder without breaking it open. In Java, a class that keeps balance as private and only allows changes through a deposit() method is encapsulated — the data cannot be corrupted from outside.

3. Inheritance. One class acquiring the properties and behaviours of another class, so that common features are written once and reused. A child inherits eye colour from a parent and still has features of their own. In programming, a general class Vehicle can hold speed and start(), and Car and Bus inherit those and add their own. The class inherited from is the base or super class; the one that inherits is the derived or sub class. The real benefit is reusability — say that word in your answer.

4. Polymorphism. The same name behaving differently in different situations. The word literally means many forms. Think of the verb run: you run a race, you run a shop, you run a program — one word, meaning fixed by context. In Java you see it when several methods share one name and are told apart by their parameter lists, which is called method overloading. You will meet the third worked program below doing exactly this.

A memory hook that survives exam pressure: A E I P — Abstraction, Encapsulation, Inheritance, Polymorphism. Say it as ay-ee-eye-pee a few times and the four never come out incomplete.

↑ Back to top

Objects and Classes — State, Behaviour and the Object Factory

Pick up your school identity card. It has a name, a class, a section, a roll number. Those are things it knows. It can be shown at the gate, scanned in the library, presented in an exam hall. Those are things it does. Now notice something: every student in your school has a card with the same set of fields but different values written in them.

The blank printed design of the card is the class. Your particular card, with your name on it, is an object. This gives you the three ways CISCE describes a class, and a good answer mentions all three:

• A class is a blueprint or specification from which objects are created.
• A class is an object factory — it can produce any number of similar objects.
• A class is a user-defined data type with its own data and its own functionality.

And the object, correspondingly, is an instance of a class that encapsulates state and behaviour. State is stored in member variables (also called attributes or data members). Behaviour is provided by member methods. Work happens when one object calls a method on another — which is why OOP people describe computation as message passing between objects.

↑ Back to top

From Source Code to Output — Compiler, Bytecode, JVM

This is the topic students answer most vaguely, so let us walk the journey of a single file.

You type your program in an editor and save it as FirstProgram.java. What you typed is source code — instructions in a language a human can read. The machine cannot run it.

You now compile it. The Java compiler, javac, checks your syntax and, if it is satisfied, produces a file called FirstProgram.class. The contents of that file are bytecode — a compact, machine-independent set of instructions meant not for your processor but for an imaginary computer called the Java Virtual Machine. This is the single most important idea in the whole section: Java does not compile straight to the instructions of your particular chip.

You then run the program. The JVM for your operating system reads the bytecode and, line by line, converts it into object code — the actual instructions your processor understands — and executes it. Because the bytecode is the same everywhere and only the JVM differs from platform to platform, the identical .class file runs on Windows, on Linux and on a Mac. That is what the slogan write once, run anywhere means, and it is the reason Java is called platform independent.

↑ Back to top

Features of Java — and How to Write Them in an Answer

Do not write a bare list. Each feature gets its name and one clause of justification, because the justification is what carries the mark.

• Simple — its syntax is close to C and C++, but confusing features such as pointers and explicit memory freeing have been removed.
• Object oriented — apart from the primitive types, everything in Java is written in terms of classes and objects.
• Platform independent — bytecode runs on any machine that has a JVM, so the same .class file works everywhere.
• Robust — strict type checking, automatic garbage collection and exception handling stop a great many crashes before they happen.
• Secure — programs run inside the JVM, which restricts what they may touch on the host machine.
• Portable — the size of each primitive type is fixed by the language, so an int is 32 bits on every machine.
• Multithreaded — a single program can carry out several tasks at the same time.
• Distributed — it has built-in support for working across networks.

Real applications built with Java, useful if a question asks where Java is used: Android and other mobile applications, desktop applications, web-based systems such as banking and e-commerce portals, games, robotics in healthcare, education software such as online quiz and grading systems, chatbots and virtual assistants.

Applications and Applets — the Two Kinds of Java Program

A Java application is a standalone program. It has a main() method, you run it yourself from the command line or from BlueJ, and it needs nothing but a JVM. Every program on this page is an application.

A Java applet is a small program that cannot run on its own. It has no main(), it is embedded in a web page, and it is executed by a browser or an applet viewer. Applets are legacy technology now and are not used in modern web development, but the syllabus expects you to know the distinction, so learn it as: an application is standalone and starts at main; an applet is embedded and is run by a browser.

↑ Back to top

The Standard Structure of a Java Class

The syllabus prints a standard skeleton, and it is worth being precise about one thing that confuses almost everybody. The skeleton is written as void main() and the syllabus notes that public, static and String args[] are default in nature. That is a BlueJ convenience: inside BlueJ you may call a method directly on an object, so a plain main() works there.

The moment you run a program from outside BlueJ, the JVM will only start at a method whose full signature is public static void main(String args[]). So write the full signature. It is correct everywhere, including in BlueJ, and no examiner has ever deducted a mark for it. Put it plainly: the short form works only inside BlueJ, while the full form works everywhere including BlueJ. There is no situation in which writing the full signature can cost you anything, and there are several in which the short one can. Write it in full on your answer sheet, every time. Every program below uses it, which is precisely why every one of them actually ran.

// this is a single line comment  -  non executable
/* this is a
   multi line comment  -  also non executable */

import java.util.*;          // needed only when Scanner is used

class NameOfTheClass
{
    public static void main(String args[])
    {
        // declaration of variables
        // create an object of the Scanner class if input is needed
        // set of statements
    }
}

Three rules that cost marks when forgotten. The file name must match the class name exactly, including capitals, so class Student lives in Student.java. Java is case sensitive, so System and system are different words. And every executable statement ends in a semicolon, while a class or method block ends in a closing brace with no semicolon after it.

↑ Back to top

Four Worked Programs With Verified Output

Each program below was compiled with javac and executed on JDK 11. The output block under each one is copied from the terminal, character for character.

class FirstProgram
{
    public static void main(String args[])
    {
        System.out.print("Principal Saab ");
        System.out.print("Computer Applications");
        System.out.println();
        System.out.println("ICSE Class 10");
        System.out.println("Java is fun");
    }
}

Principal Saab Computer Applications
ICSE Class 10
Java is fun

class Student
{
    // attributes  -> the STATE of the object
    private String name;
    private int marks;

    // method to set the state
    void setDetails(String n, int m)
    {
        name = n;
        marks = m;
    }

    // method that uses the state  -> the BEHAVIOUR of the object
    void display()
    {
        System.out.println("Name  : " + name);
        System.out.println("Marks : " + marks);
    }

    public static void main(String args[])
    {
        Student s1 = new Student();
        Student s2 = new Student();

        s1.setDetails("Aarav", 87);
        s2.setDetails("Diya", 92);

        s1.display();
        s2.display();
    }
}

Name  : Aarav
Marks : 87
Name  : Diya
Marks : 92

class AreaCalculator
{
    // same name, different parameter lists  -> method overloading
    void area(int side)
    {
        System.out.println("Area of square = " + (side * side));
    }

    void area(int length, int breadth)
    {
        System.out.println("Area of rectangle = " + (length * breadth));
    }

    void area(double radius)
    {
        System.out.println("Area of circle = " + (3.14 * radius * radius));
    }

    public static void main(String args[])
    {
        AreaCalculator obj = new AreaCalculator();
        obj.area(5);
        obj.area(4, 6);
        obj.area(7.0);
    }
}

Area of square = 25
Area of rectangle = 24
Area of circle = 153.86

class BankAccount
{
    private double balance;   // hidden from the outside world

    void deposit(double amt)
    {
        if (amt > 0)
            balance = balance + amt;
        else
            System.out.println("Invalid amount rejected");
    }

    double getBalance()
    {
        return balance;
    }

    public static void main(String args[])
    {
        BankAccount a = new BankAccount();
        a.deposit(5000);
        a.deposit(-200);
        a.deposit(1500);
        System.out.println("Balance = " + a.getBalance());
    }
}

Invalid amount rejected
Balance = 6500.0

↑ Back to top

Dry Run and Output Prediction — the ICSE Favourite

Section A almost always contains questions that hand you a fragment of code and ask what it prints. There is a method to these, and the method is not cleverness. It is bookkeeping. Take a sheet, write one column for each variable, and after every single statement write the new value. Never hold two changing values in your head at once.

Work through these three before reading the outputs. All three were executed, and the outputs shown are the machine’s.

int a = 5, b = 2;
System.out.println(a / b);
System.out.println(a % b);
System.out.println((double) a / b);
System.out.println(a + b + "Java");
System.out.println("Java" + a + b);

2
1
2.5
7Java
Java52

class Counter
{
    static int count = 0;   // shared by ALL objects
    int id;                 // separate for each object

    Counter()
    {
        count++;
        id = count;
    }

    void show()
    {
        System.out.println("Object id = " + id + " , total objects = " + count);
    }
}

class Q2
{
    public static void main(String args[])
    {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();
        c1.show();
        c2.show();
        c3.show();
    }
}

Object id = 1 , total objects = 3
Object id = 2 , total objects = 3
Object id = 3 , total objects = 3

int x = 10;
int y = x++;
int z = ++x;
System.out.println(x + " " + y + " " + z);
System.out.println(x++ + ++x);

12 10 12
26

↑ Back to top

Practice Worksheet — 10 Questions With Model Answers

This is the part that moves marks. Keep paper beside you, write your full answer, and only then click to reveal. Comparing your attempt against the model is worth ten times more than reading the model and nodding.

ICSE Class 10
Computer

2
2
11Total
Total83

6 4 6

class Book
{
    private String title;
    private double price;

    void setData(String t, double p)
    {
        title = t;
        price = p;
    }

    void display()
    {
        System.out.println("Title : " + title);
        System.out.println("Price : " + price);
    }

    public static void main(String args[])
    {
        Book b = new Book();
        b.setData("Atlas", 350.0);
        b.display();
    }
}

Title : Atlas
Price : 350.0

Before You Close This Page

Look at what you can now do. You can explain why object-oriented programming exists rather than reciting that it does. You can define a class three different ways and an object one precise way. You can trace a program from source code through bytecode to output and name what does the converting. You have written four programs that ran, and you have traced three fragments where the trap was not the syntax but the order of evaluation.

If one of those still feels shaky, go back to that single section. Do not reread the whole page. And if the shaky one is the four principles, do this instead of rereading: pick any object in the room you are sitting in and describe it in all four terms. A mobile phone works beautifully. That five-minute exercise fixes the topic better than an hour of revision.

↑ Back to top