ICSE Computer Application - Class X - MCQ - CALCUTTA PUBLIC SCHOOL - Quiz

It allows the method to be called without creating an instance of the class.

Explanation:

In Java, the static keyword is used for:

1. Static Methods and Variables:

   • Methods: A static method belongs to the class rather than instances of the class. This means you can call the method directly on the class itself without needing to create an instance.

class Example {
    static void staticMethod() {
        System.out.println("Static method");
    }
}

// Calling the static method without creating an instance
Example.staticMethod();

Let's break down the two string method operations in Java for the string "MISSISSIPPI":

1. "MISSISSIPPI".indexOf('S')

The indexOf('S') method returns the index of the first occurrence of the character 'S' in the string "MISSISSIPPI".

• The string "MISSISSIPPI" has the following indices:

  
  M  I  S  S  I  S  S  I  P  P  I
  0  1  2  3  4  5  6  7  8  9 10
  
  

• The first occurrence of 'S' is at index 2.

So, "MISSISSIPPI".indexOf('S') returns 2.

2. "MISSISSIPPI".lastIndexOf('I')

The lastIndexOf('I') method returns the index of the last occurrence of the character 'I' in the string "MISSISSIPPI".

• From the same index mapping, the last occurrence of 'I' is at index 10.

So, "MISSISSIPPI".lastIndexOf('I') returns 10.

Addition Operation

Now, adding these two results together:

indexOf('S') + lastIndexOf('I')
= 2 + 10
= 12

So, the correct answer is:

12

In Java, when evaluating an expression that contains multiple data types, the type with the highest precision and range is chosen to represent the result of the entire expression. The promotion rules are applied as follows:

1. If the expression involves double, float, long, and int, it is promoted to the type with the highest precision and range among these.

2. The precedence of types from lowest to highest precision is:

   • int
   • long
   • float
   • double

Given the presence of double, int, float, and long in the expression, the highest precision and range type is double.

Therefore, the whole expression will be promoted to:

c) double

Let's analyze the given code step by step to determine its output.

Code:

String A = "26.0";
String B = "74.0";

double C = Double.parseDouble(A);
double D = Double.parseDouble(B);

System.out.println((C + D));
        

Explanation:

1. String Initialization:

   String A = "26.0";
String B = "74.0";
   Here, two strings A and B are initialized with the values "26.0" and "74.0" respectively.

2. Parsing Strings to Double:

   double C = Double.parseDouble(A);
double D = Double.parseDouble(B);
   The Double.parseDouble(String s) method converts the string argument to a double type. So, C will be 26.0 and D will be 74.0.

3. Calculating Sum:

   System.out.println((C + D));
   The sum of C and D is calculated. Therefore:
   C + D = 26.0 + 74.0 = 100.0

4. Printing the Result:

   The result is printed using System.out.println, which will display 100.0.

Conclusion:

The output of the code is: 100.0

The this keyword in Java is used for a specific purpose related to the current instance of a class. Here's what each option means in the context of the this keyword:

a) It is used to declare a constant variable.

• This is incorrect. The this keyword is not used to declare constant variables. Constant variables in Java are declared using the final keyword.

b) It refers to the current instance of the class.

• This is correct. The this keyword is used to refer to the current instance of the class within its methods and constructors. It helps to distinguish between instance variables and parameters with the same name, and to call other constructors or methods within the same class.

c) It is used to call static methods.

• This is incorrect. Static methods can be called using the class name, not the this keyword. The this keyword cannot be used to call static methods.

d) It represents the return value of a function.

• This is incorrect. The return value of a function is specified using the return keyword, not this.

Correct Answer:

b) It refers to the current instance of the class.

The parseLong() function is a member of the Long wrapper class.

Explanation:

• parseLong() is a static method provided by the Long wrapper class in Java.
• It is used to convert a String into a long value.

Correct Answer:

a) Long wrapper class

The name of a constructor in Java must match the name of the class exactly. Therefore, if the name of the class is Computer, the possible name of the constructor must be:

c) Computer()

Explanation:

• Constructor Name: In Java, a constructor is a special method that is called when an instance of a class is created. The constructor must have the same name as the class and does not have a return type, not even void.

• Options:

  • a) computer(): Not correct because the constructor name should match the class name exactly, including case.
  • b) COMPUTER(): Not correct because Java is case-sensitive, and the constructor name must match the class name exactly.
  • c) Computer(): Correct, as it matches the class name exactly.
  • d) com(): Not correct because it does not match the class name.

Correct Answer:

c) Computer()

Let's analyze the corrected Java code to determine its type:

Corrected Code:

class Out {

    int a = 5; // Adding a variable to compare with x

    int cal() {
        int x = 10;
        if (x > a) {
            return --x; // Decrements x by 1 and returns 9
        } else {
            return ++x; // Increments x by 1 and returns 11
        }
    }

    public static void main(String[] args) {
        Out ob = new Out(); // Create an instance of the class
        int x = ob.cal(); // Call the method cal() and store the result in x
        System.out.println(x); // Print the value of x
    }
}
        

Explanation:

The method cal() performs an operation based on the class-level variable a and modifies the value of x. It returns 9 in this case, because x is greater than a.
- The method is considered an impure method because it depends on and operates based on mutable state.

Answer:

The program demonstrates an example of an Impure Method.

both a and b

When the "break" statement is executed within the outer loop, then the outer loop will stop.

public class BreakOuterLoopExample {
    public static void main(String[] args) {
        // Outer loop
        for (int i = 1; i <= 3; i++) {
            System.out.println("Outer loop iteration: " + i);

            // Inner loop
            for (int j = 1; j <= 2; j++) {
                System.out.println("  Inner loop iteration: " + j);
                if (i == 2 && j == 1) {
                    System.out.println("  Breaking out of the outer loop.");
                    break; // Breaks out of the outer loop
                }
            }

            if (i == 2) {
                break; // Ensures the outer loop stops after the break in the inner loop
            }
        }
    }
}

Output:

Outer loop iteration: 1
  Inner loop iteration: 1
  Inner loop iteration: 2
Outer loop iteration: 2
  Inner loop iteration: 1
  Breaking out of the outer loop.

In this example, the break statement inside the inner loop causes the outer loop to stop when i is 2 and j is 1. The outer loop does not continue after this point.

If a 'for loop' is used within a 'for loop', it is called a nested for loop.