ICSE − Q & A

FOR ALL COMPUTER NIGGAS (entertainment station idea cancel as i had to post this)

                                                           Chapter - 1 : Revision of Class-IX Syllabus

Java is an Object-Oriented Language.
As a language that has the Object-Oriented feature, Java supports the following fundamental concepts.
 (i) Polymorphism : Ability of an object to take on many forms.
 (ii) Inheritance : A mechanism in which one object acquires all the properties and behaviours of parent class.
 (iii) Encapsulation : A process of wrapping code and data together into a single unit i.e., class.
 (iv) Abstraction : Process of hiding the implementation details from the user.

Object : Objects have states and behaviours. Example: A dog has states - colour, name, breed as well as behaviours
like – wagging the tail, barking, eating etc. An object is an instance of a class.

Class : A class can be defined as a template/blueprint that describes the behaviour/state that the object of its type
support.

Instance : An object is an instance of a class.

Method : A method is a collection of statements that are grouped together to perform the specified task.

Local variables : Variables defined inside methods, constructors or blocks are called local variables. The variable
will be declared and initialized within the method and the variable will be destroyed when the method has
completed.

Instance variables : Instance variables are variables within a class but outside any method. These variables are
initialized when the class is instantiated. Instance variables can be accessed from inside any method, constructor
or blocks of that particular class.

Class variables : Class variables are variables declared within a class, outside any method, with the static keyword.
Glossary
 AWT : Abstract Window Toolkit
JVM : Java Virtual Machine
JIT : Just In Time
JDT : Java Development Toolkit
 API : Application Programming Interface

                                                          Chapter - 2 : Call as the Basis of all Computation
(Still reading lol)
 There are two data types available in Java :
 (i) Primitive Data Types
 (ii) Reference/Object Data Types

 Primitive Data Types
 There are eight primitive data-types supported by Java. Primitive data-types are predefined by the language and
named by a keyword. Let us now look into the eight primitive data types in detail.

i) byte
 (a) Byte data type is an 8-bit signed two’s complement integer.
 (b) Minimum value is -128 (-2^7).
 (c) Maximum value is 127 (inclusive)(2^7 -1).
 (d) Default value is 0.
 (e) Byte data type is used to save space in large arrays, mainly in place of integers, since a byte is four times
smaller than an integer.
 (f) Example, byte a = 100, byte b = -50.

(ii) short
 (a) Short data type is a 16-bit signed two’s complement integer.
 (b) Minimum value is -32,768 (-2^15).
 (c) Maximum value is 32,767 (inclusive) (2^15 -1).
 (d) Short data type can also be used to save memory as byte data type. A short is 2 times smaller than an
integer.
 (e) Default value is 0.
 (f) Example, short s = 10000, short r = -20000.

(iii) int
 (a) int data type is a 32-bit signed two’s complement integer.
 (b) Minimum value is - 2,147,483,648 (-2^31).
 (c) Maximum value is 2,147,483,647(inclusive) (2^31 -1).
 (d) Integer is generally used as the default data type for integral values unless there is a concern about
memory.
 (e) The default value is 0.
 (f) Example, int a = 100000, int b = -200000.

(iv) long
 (a) Long data type is a 64-bit signed two’s complement integer.
 (b) Minimum value is -9,223,372,036,854,775,808(-2^63).
 (c) Maximum value is 9,223,372,036,854,775,807 (inclusive)(2^63 -1).
 (d) This type is used when a wider range than int is needed.
 (e) Default value is 0L.
 (f) Example, long a = 100000L, long b = -200000L.
 (v) float
 (a) Float data type is a single-precision 32-bit IEEE 754 floating point.
 (b) Float is mainly used to save memory in large arrays of floating point numbers.
 (c) Default value is 0.0f.
 (d) Float data type is never used for precise values such as currency.
 (e) Example, float f1 = 234.5f.
 (vi) double
 (a) double data type is a double-precision 64-bit IEEE 754 floating point.
 (b) This data type is generally used as the default data type for decimal values, generally the default choice.
 (c) Double data type should never be used for precise values such as currency.
 (d) Default value is 0.0d.
 (e) Example, double d1 = 123.4.
 
(vii) boolean
 (a) boolean data type represents one bit of information.
 (b) There are only two possible values: true and false.
 (c) This data type is used for simple flags that track true/false conditions.
 (d) Default value is false.
 (e) Example, boolean one = true.

(viii) char
 (a) char data type is a single 16-bit Unicode character.
 (b) Minimum value is ‘\u0000’ (or 0).
 (c) Maximum value is ‘\uffff’ (or 65,535 inclusive).
 (d) Char data type is used to store any character.
 (e) Example, char letterA = ‘A’.
 Reference Data-types
 (i) Reference variables are created using defined constructors of the classes. They are used to access objects.
These variables are declared to be of a specific type that cannot be changed. For example, Employee, Puppy,
 etc.
 (ii) Class objects and various type of array variables come under reference data-type.
 (iii) Default value of any reference variable is null.
 (iv) A reference variable can be used to refer any object of the declared type or any compatible type.

Access modifiers : Each object has members (members can be data variable and methods) which can be declared to have specific access. Java has 4 access level and 3 access modifiers. Access levels are listed below in the least to most restrictive
order.

 Public : Members (variables, methods, and constructors) declared public (least restrictive) within a public class are
visible to any class in the Java program, whether these classes are in the same package or in another package.

 Protected : The protected fields or methods, cannot be used for classes and Interfaces. Fields, methods and
constructors declared protected in a super-class can be accessed only by subclasses in other packages. Classes
in the same package can also access protected fields, methods and constructors as well, even if they are not a
subclass of the protected member’s class.

 Private : The private (most restrictive) modifiers can be used for members but cannot be used for classes and
Interfaces. Fields, methods or constructors declared private are strictly controlled, which means they cannot be
accessed by anywhere outside the enclosing class.

Byte Code : Java portable code
Applet : Small Java Program
Bean : Java Software
Void : Null Value
Template : Generic Class


Chapter - 3 : Constructors
Quick Review
 Constructor in Java is a special type of method that is used to initialize the object.
 Java constructor is invoked at the time of object creation. It constructs the values i.e. provides data for the object
that is why it is known as constructor.
 Rules for creating Java Constructor :
 There are basically two rules defined for the constructor.
 (i) Constructor name must be same as its class name.
 (ii) Constructor must have no explicit return type.
 Types of Java Constructors :
 There are following types of constructors.
 (i) Default constructor (no-argument constructor)
 (ii) Parameterised constructor
 (iii) Constructor with Arguments
 (iv) Constructor overloading
Know the Terms
 Default Constructor – It is the no argument constructor that is automatically created by compiler in the absence
of explicit constructor.
 Parameterised Constructor – These constructors are required to pass parameters on creation of objects.
 Constructor with Arguments – It is possible to define constructors with argument.
 Constructor Overloading – Constructor overloading is the way of having more than one constructor, which does
a various tasks.
 The number of parameters can be same also but it can have different data types.

Glossary
New : Java Unary Operator
Token : Internal Value Assigned
Separators : Comma and Terminators
Signatures : Function calling parameters

Chapter - 4 : Functions
Quick Review
 Function : A program module used simultaneously at different instances in the program is called method or
function.
 Defining a Function :
  <Return type><method name>(parameter list)
	 	 {• //Body of the function•}
 (i) Access specifier – public or private.
 (ii) Method declared without access specifier is by default treated as public
 (iii) Type- Specifies the data of the value returned from the method
 (iv) Function name – Preferably related to the program
 (v) Parameter list – Variables which receives the value passed from the arguments during method call
 Components of a method : There are two components –
 (i) Header ( also known as method prototype)
 (ii) Body List of parameters is called signature
 Header public int add() Body return(value). The statement which sends back the value from a method is called
program return statement and is used at the end of the program which is a function terminator.
 Types of Functions :
 (i) Pure function, also called accessor.
 (ii) Impure function, also called mutator.
 Pure function or Accessor takes objects as an arguments but does not modify the state of the objects.
 Impure function or mutator takes objects on an argument and charges the state of the objects.
 Different ways of defining a Function :
 (i) Receiving value and returning outcome to the caller.
 (ii) Receiving values but not returning outcome to the caller and vice versa.
 (iii)Neither receiving values nor returning outcome to the caller.
 Formal parameter :
 (i) Parameter is a variable used with method signature that receives a value during function call.
 (ii) When the parameter values are received from the caller then it is called Formal parameter.
 Actual Parameter : If the values are passed to the method during its call from the caller then it is actual parameter
 Pass by value :
 (i) Process of passing a copy of actual arguments to the formal parameters.
 (ii) Any change made in the formal will not reflect on actual argument.
 Formal parameters after function operation Actual arguments before function call X Y A B 7 8 5 6 Actual arguments
after function call A B Copied formal parameters during function call 5 6 X Y 5 6.
 Pass by Reference :
 (i) Process of passing the reference of actual arguments to the formal parameters and any change in the formal
parameters will be reflected in the actual parameters also
 Function overloading :
 (i) Function with the same name but used for different purposes is called as overloaded functions.
Oswaal ICSE Chapterwise Quick Review, COMPUTER APPLICATIONS, Class-X [ 5]
 (ii) It is implemented through polymorphism.
 (iii) Compiler finds the best match of the function arguments and the parameter list during program compilation
called static binding.
 Recursive function :
 (i) A function which calls by itself is called as recursive function.

Chapter - 5 : Class as a user Defined Type
Quick Review
 There are 8 primitive data types defind in Java, they are byte, short, long, float, double, char, boolean.
 Java allows us to create new data type using combination of the primitive data types, such data types are called
composite or user-defined data types.
 Just as variables can be declared of any primitive data type, similarly we can declare variables of the composite
data types.
 Class is an example of composite data type and we can declare objects as variables of the class.
 Following are some of the differences between primitive data types and user-defined data types :
Primitive data types User-defined data types
These are built-in data types. Java provides
these data types.
The size of these data types are fixed.
These data types are available in all parts of a
Java program.
These are created by the users.
The size of these data types are variable as
their size depends upon their constituent
members.
The availability of these data types depend
upon their scope.
 Access modifiers :
 public – methods of the same class and methods of other classes
 private – methods of the same class only
 protected – methods of the same class, methods of subclasses, and methods of classes in the same package
 none – methods in the same package only
 Value-returning methods
 Use a return statement to return the value i.e.,
 return expression;
 (i)Each of Java’s eight primitive data types has a class dedicated to it. These are known as wrapper classes.
 (ii)The most common methods of the Integer wrapper class are summarized in below table. Similar methods for
the other wrapper classes are found in the Java API documentation.
Method Purpose
parseInt(s) returns a signed decimal integer value equivalent to string s
toString(i) returns a new String object representing the integer i
byteValue() returns the value of this Integer as a byte
doubleValue() returns the value of this Integer as a double
floatValue() returns the value of this Integer as a float
intValue() returns the value of this Integer as an int
shortValue() returns the value of this Integer as a short
longValue() returns the value of this Integer as a long
int compareTo(int i) Compares the numerical value of the invoking object with that of i. Returns
0 if the values are equal. Returns a negative value if the invoking object has
a lower value. Returns a positive value if the invoking object has a greater
value.
static int compare(int
num1, int num2)
Compares the values of num1 and num2. Returns 0 if the values are equal.
Returns a negative value if num1 is less than num2. Returns a positive value
if num1 is greater than num2.
[6 ] Oswaal ICSE Chapterwise Quick Review, COMPUTER APPLICATIONS, Class-X
Know the Terms
 Client of a class : A program that instantiates objects and calls methods of the class.
 Fields : A variable that resides within the class, and whose scope is to the entire class.
 Instance variables : data for each object –
 Class Data : static data that all objects shared.
 Class Members : fields and methods, within the class
 Access Modifiers : determines access rights for the class and its members – defines where the class and its
members can be used.

Chapter - 6 : Iterations
Quick Review
 Iteration statements are statements (or compound statements) to be executed zero or more times, subject to some
loop-termination criteria. When these statements are compound statements, they are executed in order, except
when either the break statement or the continue statement is encountered.
 Loops are basically means to do a task multiple times, without actually coding all statements over and over again.
For example, loops can be used for displaying a string many times, for counting numbers and of course for
displaying menus.
 Loops in Java are mainly of three types :
 1. ‘while’ loop : A while statement executes its statements as long as a specified condition evaluates to true.
 Syntax : While (condition)
 statements.
 2. The ‘do-while’ loop : It is very similar to the ‘while’ loop shown above. The only difference being, in a ‘while’
loop is that the condition is checked before the body of loop, but in a ‘do-while’ loop, the condition is checked
after one execution of the loop.
 Syntax : do statements
 while (condition);
 3. The ‘for’ loop :
 This is probably the most useful and the most used loop in Java The syntax is slightly more complicated than
that of ‘while’ or the ‘do-while’ loop.
Syntax : for(<initial value>;<condition>;<increment/decrement>)
 statements.
 The Break Statement :
 Use the break statement to terminate a loop, switch, or in conjunction with a labelled statement.
 (i) When you use break without a label, it terminates the innermost enclosing while, do-while, for, or switch
immediately and transfers control to the following statement.
 (ii) When you use break with a label, it terminates the specified labelled statement.
 The syntax of the break statement looks like this :
 break [Label]
 The Continue Statement :
 The continue statement can be used to restart a while, do-while, for or label statement.
 (i) When you use continue without a label, it terminates the current iteration of the innermost enclosing while,
do-while, or for statement and continues execution of the loop with the next iteration. In contrast to the break
statement, continue does not terminate the execution of the loop entirely. In a while loop, it jumps back to the
condition. In a for loop, it jumps to the increment-expression.
 (ii) When you use continue with a label, it applies to the looping statement identified with that label.
 The syntax of the Continue statement looks like the following :
 continue [Label];

Oswaal ICSE Chapterwise Quick Review, COMPUTER APPLICATIONS, Class-X [ 7]
Chapter - 7 : Using Library Classes
Quick Review
 The Java Development Kit comes with many libraries which contain predefined classes and methods to use.
These are standard Java classes or built-in Java classes, contained in packages.
 These classes provide an effective support to the programmers in developing their program logic.
 Packages : The package contain a set of classes in order to ensure that class names are unique.
Some of these includes :
 a Math library (java.lang.Math).
 String library (java.lang.String).
 Graphics library (java.awt.* and javax.swing.*).
 Networking library (java.net).

Chapter -8 : Encapsulation
Quick Review
 Encapsulation is one of the four fundamental OOP concepts. The other three are inheritance, polymorphism, and
abstraction.
 Encapsulation in Java is a mechanism of wrapping the data (variables) and code acting on the data (methods)
together as a single unit. In encapsulation, the variables of a class will be hidden from other classes, and can be
accessed only through the methods of their current class. Therefore, it is also known as data hiding.
 To achieve encapsulation in Java :
 (i) Declare the variables of a class as private.
(ii) Provide public setter and getter methods to modify and view the variables values.
Benefits of Encapsulation :
 The fields of a class can be made read-only or write-only.
 A class can have total control over what is stored in its fields.
 The users of a class do not know how the class stores its data. A class can change the data type of a field and users
of the class do not need to change any of their code.

Chapter -9: Arrays
Quick Review
 Java provides a data structure, the array, which stores a fixed-size sequential collection of elements of the same
type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of
variables of the same type.
 Elements of array will be referred as array-name [n], where n is the number of element in the array.
 Instead of declaring individual variables, such as number0, number1, ..., and number99, you declare one array
variable such as numbers and use numbers[0], numbers[1], and ..., numbers[99] to represent individual variables.
 There are two types of array :
 (i)Single Dimensional Array
 (ii)Double Dimensional Array
 Array Creation : Syntax for array creation
 array - name = new type [size];
 where new is a keyword that allocates memory for an array.
 Declaring Array Variables :
 To use an array in a program, you must declare a variable to reference the array, and you must specify the type of
array the variable can reference. 
[8 ] Oswaal ICSE Chapterwise Quick Review, COMPUTER APPLICATIONS, Class-X
 The syntax for declaring an array variable.
 DataType arrayRef var [];
 Basic Operations on Arrays :
 (i) Searching : It is the process to determine whether the given is present in the array or not. These are of two
types –
 (a) Linear Search
 (b) Binary Search
 (ii) Sorting : The process of arranging data in ascending or descending order. There are two ways to sort the
data –
 (a) Selection Sort
 (b) Bubble Sort

Chapter -10 : Input / Output
Quick Review
 Input is any information needed by program to complete its execution while output is any information that the
program must convey to the user.
 The input stream is used to read data from a source and the Output stream is used for writing data to a destination.
 There are various ways to read input from the keyboard, the java.util.scanner class is one of them.
 The scanner class allows the user to read values of various types.
 The syntax to create a scanner object is scanner input = new scanner (system.in);
 The Java scanner class breaks the input into tokens using a delimiter that is white space by default. It provides
many methods to read and parse various primitive values.
 Java scanner class is widely used to parse text for string and primitive types using regular expression.
 Java scanner class extends object class and implements iterator and closeable interfaces.
 Methods for checking appearance of a specific token.
Method Description
public String next()
public String nextLine()
public byte nextByte()
public short nextShort()
public int nextInt()
public long nextLong()
public float nextFloat()
public double nextDouble()
it returns the next token from the scanner.
it moves the scanner position to the next line and
returns the value as a string.
it scans the next token as a byte.
it scans the next token as a short value.
it scans the next token as an int value.
it scans the next token as a long value.
it scans the next token as a float value.
it scans the next token as a double value.


See this
https://brainly.in/question/7574029
for the qusetion which soil is formed by the weathering of basic igenous rocks.

Geography answers
https://www.youtube.com/watch?v=XyQYguQb8yM