ICSE Class 10 Computer Applications - Full Theory Notes

ICSE Class 10 Computer Applications - Complete Theory Notes

---

## 1. Object-Oriented Programming (OOP) Concepts

**Definition:**

OOP is a programming paradigm based on the concept of "objects," which can contain data and

methods.

**Key Principles of OOP:**

1. **Class**: A blueprint or template for creating objects.

- Example: A "Car" class defines properties like color, model, and methods like start() or stop().

```java

class Car {

String color;

void start() {

System.out.println("Car started");

```

2. **Object**: An instance of a class.

- Example: `Car myCar = new Car();`

3. **Encapsulation**: Wrapping data and methods into a single unit and restricting direct access.
4. **Inheritance**: One class acquires the properties of another.

- Example: A "SportsCar" class can inherit from the "Car" class.

5. **Polymorphism**: A single function or method behaves differently based on the input.

- Example: Method overloading or overriding.

**Real-life Analogy:**

- Class: A blueprint of a house.

- Object: The actual house built using the blueprint.

---

## 2. Introduction to Java

**Key Features:**

1. Platform-independent: "Write Once, Run Anywhere" due to JVM.

2. Object-Oriented: Focus on classes and objects.

3. Secure: Built-in security features.

4. Robust: Handles runtime errors and supports garbage collection.

**Basic Java Structure:**

```java

class HelloWorld {

public static void main(String[] args) {

System.out.println("Hello, World!");

```
---

## 3. Values and Data Types

**Primitive Data Types:**

1. Integer: `int age = 10;`

2. Floating-point: `float price = 99.99f;`

3. Character: `char grade = 'A';`

4. Boolean: `boolean passed = true;`

**Non-Primitive Data Types:**

1. String: A sequence of characters.

```java

String name = "ICSE";

```

2. Arrays: Collection of similar data types.

**Type Casting:**

- Widening: Converting smaller to larger type (automatic).

- Narrowing: Converting larger to smaller type (explicit).

Example:

```java

int a = 10;

float b = a; // Widening

int c = (int) b; // Narrowing

---

## 4. Operators in Java

**Types of Operators:**

1. **Arithmetic Operators**: +, -, *, /, %.

2. **Relational Operators**: >, <, ==, !=.

3. **Logical Operators**: &&, ||, !.

**Example:**

```java

int a = 10, b = 20;

System.out.println(a + b); // Output: 30

System.out.println(a > b); // Output: false

```

---

## 5. Control Structures

### If-Else Statement

```java

if (marks > 40) {

System.out.println("Pass");

} else {
 System.out.println("Fail");

```

### Switch-Case

```java

switch (day) {

case 1: System.out.println("Monday"); break;

case 2: System.out.println("Tuesday"); break;

default: System.out.println("Invalid");

```

---

## 6. Loops

**For Loop:**

```java

for (int i = 1; i <= 5; i++) {

System.out.println(i);

```

**While Loop:**

```java

int i = 1;
while (i <= 5) {

System.out.println(i);

i++;

```

**Do-While Loop:**

```java

int i = 1;

do {

System.out.println(i);

i++;

} while (i <= 5);

```

---

## 7. Arrays

**One-Dimensional Array:**

```java

int[] numbers = {10, 20, 30};

for (int i = 0; i < numbers.length; i++) {

System.out.println(numbers[i]);

```
**Key Operations:**

1. Traversal

2. Searching (Linear Search)

---

## 8. String Handling

**Methods:**

1. `length()`: Returns the length of the string.

2. `toUpperCase()`: Converts to uppercase.

3. `substring()`: Extracts a portion of the string.

Example:

```java

String name = "ICSE";

System.out.println(name.length()); // Output: 4

```

---

## 9. User-defined Methods

**Definition:** A reusable block of code.

**Syntax:**

```java

returnType methodName(parameters) {
 // Code

```

**Example:**

```java

public static int add(int a, int b) {

return a + b;

```

---

## 10. File Handling

**Basic Operations:**

1. Writing to a file.

2. Reading from a file.

Example:

```java

FileWriter fw = new FileWriter("output.txt");

fw.write("Hello, World!");

fw.close();

```

---
## 11. Exception Handling

**Definition:** Handling runtime errors gracefully.

**Example:**

```java

try {

int result = 10 / 0;

} catch (ArithmeticException e) {

System.out.println("Cannot divide by zero");

```

---

## Tips for Scoring Full Marks:

1. Write clean, well-structured programs.

2. Always include comments in code.

3. Practice previous years' question papers.

4. Revise definitions, syntax, and sample programs.

---