Revising Basic Java Concepts

The smallest individual unit in a program is called a token.

Keywords, identifiers, literals, operators and punctuators are tokens available in Java.

Keywords are the words with special meaning associated with them. These are reserved for special purpose and must not be used as normal identifier names. Some keywords of Java are default, return, if, private etc.

No, keywords cannot be used as identifiers.

Identifiers are the names given by the programmer to various program units of Java. Identifiers are the names of variables, methods, classes, packages and interfaces etc.

Identifier forming rules of Java state the following:

1. Identifiers can have alphabets, digits, _ (underscore) and $\text{\textdollar}$ characters and can be of any length.
2. They must not be a keyword or Boolean literal or null literal.
3. They must not begin with a digit.
4. Java is case sensitive i.e., upper-case letters and lower-case letters are treated differently.

Single character enclosed in single quotation marks (' ') makes a character literal. For example, 'a', '5', $\text{\textdollar}$, '1' are character literals.

Non-graphic characters are represented in Java using escape sequence. An escape sequence is represented by a backslash (\) followed by one or more characters. For example, '\n', '\t' are escape sequences for new line and tab respectively.

u * t + (1.0 / 2.0) * f * t * t

Math.sqrt(Math.pow(a,2) + Math.pow(b,2))

Math.pow(a, b) + b >= Math.pow(b, a) + a

Math.pow(((3 * x + 5 * y) / (5 * x + 3 * y)) - ((8 * x * y) / (2 * y * x)), 3.0 / 2)

In an implicit conversion, the result of a mixed mode expression is obtained in the higher most data type of the variables without any intervention by the user. For example:

int a = 10;
float b = 25.5f, c;
c = a + b;

In case of explicit type conversion, the data gets converted to a type as specified by the programmer. For example:

int a = 10;
double b = 25.5;
float c = (float)(a + b);

The explicit conversion of an operand to a specific type is called Type Casting.

Type Casting in Java is done using the type cast operator. It is a unary operator. It's syntax is:

(<target datatype>) <value>

For example :

int a = 10;
double b = 25.5;
float c = (float)(a + b);

The resultant data type will be double.

Explanation

    bh - i + db / fl - i * fl + db / i
⇒ byte - int + double / float - int * float + double / int
⇒ byte - int + double - float + double
⇒ int + double - float + double
⇒ double - float + double
⇒ double + double
⇒ double

The resultant data type will be int.

Explanation

Here, the programmer is performing an explicit type conversion to int using the type cast operator. Hence, the resultant data type will be int.

The result of the given expression will be double type.

Explanation

$\Big(\dfrac{\text{int} * (\text{int} - \text{int} * \text{long})}{\text{(\text{long} + \text{float})}}\Big) - \Big(\dfrac{(\text{int} + \text{float}) / \text{double}}{(\text{long})(\text{double} + \text{int})}\Big) \\[1em] \Rightarrow \Big(\dfrac{\text{int} * (\text{int} - \text{long})}{\text{float}}\Big) - \Big(\dfrac{\text{float} / \text{double}}{\text{long}}\Big) \\[1em] \Rightarrow \Big(\dfrac{\text{int} * \text{int}}{\text{float}}\Big) - \Big(\dfrac{\text{double}}{\text{long}}\Big) \\[1em] \Rightarrow \text{float} - \text{double} \\[1em] \Rightarrow \text{double}$

The result will be of long double data type.

Explanation

$\Big(\dfrac{\text{int} + \text{long}}{\text{float} + \text{double}} + \dfrac{\text{short}}{\text{long double}}\Big)^4 \\[1em] \Rightarrow \Big(\dfrac{\text{long}}{\text{double}} + \dfrac{\text{short}}{\text{long double}}\Big)^4 \\[1em] \Rightarrow \Big(\text{double} + \text{long double}\Big)^4 \\[1em] \Rightarrow \text{long double}$

The output value is -2. The type of expression is int.

Explanation

    Math.abs(-5) - Math.abs(-7)
⇒ 5 - 7
⇒ -2

The output value is 0.12. The type of expression is double.

Explanation

    Math.abs(-1e-1) + Math.abs(-2e-2)
⇒ 0.1 + 0.02
⇒ 0.12

The output value is 0.08. The type of expression is double.

Explanation

Math.sqrt() method returns the square root of its argument. As square root of 0.0064 is 0.08 hence that is the output. The return type of Math.sqrt() is double so the type of expression is double.

The output value is 2.7. The type of expression is double.

Explanation

Math.pow(2.7, 2) will calculate square of 2.7 as we are raising it to the power 2. After this, calculating square root with Math.sqrt() will return the same number 2.7. The return type of Math.sqrt() is double so the type of expression is double.

The output value is 3. The type of expression is long.

Explanation

Math.round() rounds off its argument to the nearest mathematical integer. If argument is float, return type is int, if argument is double, return type is long. In this case, 3.499 will be treated as double because suffix 'f' is not there. Hence, it will return a value of long data type.

The output value is 0.095. The type of expression is double.

Explanation

Math.max(a, b) returns the maximum of a and b. As 0.095 is greater than 1.5e-2, hence, 0.095 is the output. Since the argument is double so the data type of return value is also double.

The output value is 5.0. The type of expression is double.

Explanation

Math.ceil(x) returns the smallest double value that is greater than or equal to the argument and is equal to a mathematical integer. Hence, output is 5.0 and data type of result is double.

The output value is -5.0. The type of expression is double.

Explanation

Math.min(a, b) returns the minimum of a and b. As one of the arguments is of double type hence, data type of return value is also double.

The output value is 7.0. The type of expression is double.

Explanation

Math.floor( ) returns the largest double value that is less than or equal to the argument and is equal to a mathematical integer. Hence, output is 7.0 and data type of result is double.

The output value is -2.0. The type of expression is double.

Explanation

Math.ceil( ) returns the smallest double value that is greater than or equal to the argument and is equal to a mathematical integer. -2.0 is the smallest mathematical integer greater than -2.73. Hence, output is -2.0 and data type of result is double.

The output value is 2.0. The type of expression is double.

Explanation

Math.pow(x, y) returns x raised to the power of y as a double value. Math.pow(16, 0.25) is equivalent to $\sqrt[4]{16}$. Hence, output is 2.0 and data type of result is double.

The output value is 0.0625. The type of expression is double.

Explanation

Math.pow(x, y) returns x raised to the power of y as a double value. Math.pow(4, -2) is equivalent to 4^-2 i.e., $\dfrac{1}{4^2}$ = 0.0625. Hence, output is 0.0625 and data type of result is double.

The output value is 2. The type of expression is long.

Explanation

Math.round() rounds off its argument to the nearest mathematical integer. If argument is float, return type is int, if argument is double, return type is long. In this case, 1.49 + 0.1 = 1.59 so it will be rounded of to 2, the nearest mathematical integer. 1.59 will be treated as double because suffix 'f' is not there. Hence, it will return a value of long data type.

The output value is 1.1. The type of expression is long.

Explanation

Math.round() rounds off its argument to the nearest mathematical integer.

    Math.round(1.49) + 0.1
⇒ 1 + 0.1
⇒ 1.1

If argument is float, return type is int, if argument is double, return type is long. In this case, 1.49 will be treated as double because suffix 'f' is not there. Hence, it will return a value of long data type.

Math.sqrt(Math.pow(a,2) - Math.pow(b,2))

Math.PI * (Math.pow(x,6) - Math.pow(y,6))

4.0 / 3.0 * Math.PI * Math.pow(r,3)

Math.abs(Math.pow(z,4) - 1)

The correct expression to get the desired result is given below:

(int)(6 * Math.random( )) + 1

Explanation

The formula to get an integer number between 1 and n is:

int r = (int) (n * Math.random()) + 1

The break statement when used inside a switch, ends that case and proceeds to the first statement that follows switch statement. In case, the break statement is missing, the control flows to the next case below the matching case and continues to execute all the cases, till the end of switch statement. This is called fall through.

The iterative constructs or iteration statements allow a set of instructions to be performed repeatedly until a certain condition is fulfilled. The iteration statements are also called loops or looping statements.

Java provides three iteration statements:

1. for
2. while
3. do-while

The loop which tests the condition before entering the loop is called entry-controlled loop. It does not execute if the condition is false.

for and while are entry controlled loops in Java.

If a loop tests the condition at the time of exit from the loop, it is called exit-controlled loop. This loop executes at least once even if the condition is false.

do-while loop is an exit controlled loop in Java.

do-while loop is an exit controlled loop. Thus, its body is executed atleast once even if the test-condition is false.

A loop may contain another loop in its body. This form of a loop is called nested loop. In a nested loop, the inner loop must terminate before the outer loop.

For example:

for(int i = 0; i < 5; i ++) {
    for(int j = 0; j < i; j++)  {
        System.out.print(j + ' ');
    }
    System.out.println();
}

public class KboatPattern
{
    public static void main(String args[]) {
        for (int i = 1; i <= 5; i++) {
            for (int j = 4; j >= i; j--)
                System.out.print(" ");
            for (int k = i; k >= 1; k--)
                System.out.print(k);
            System.out.println();
        }
    }
}

Output

public class KboatPattern
{
    public static void main(String args[]) {
        for (int i = 5; i >= 1; i--) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + " ");
            }
            System.out.println();
        }
    }
}

Output

//

public class KboatPattern
{
    public static void main(String args[]) {
        int a = 1, b = 0;
        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= i; j++) {
                if (j % 2 == 0)
                    System.out.print(b + " ");
                else
                    System.out.print(a + " ");
            }
            System.out.println();
        }
    }
}

Output

import java.util.Scanner;

public class KboatPattern
{
    public static void main(String args[]) {
        for (int i = 5; i >= 1; i--) {
            for (int j = i; j < 5; j++) { 
                System.out.print(" ");
            }
            for (int k = 0; k < i; k++) { 
                System.out.print('*');
            }
            System.out.println();
        }
        for (int i = 4; i >= 1; i--) {
            for (int j = 1; j < i; j++) {
                System.out.print(" ");
            }
            for (int k = i; k <= 5; k++) {
                System.out.print('*');
            }
            System.out.println();
        }
    }
}

Output

1. Primitive data type
2. Non-primitive data type
3. Primitive data type
4. Non-primitive data type

Option 1 — BEST OF LUCK is the correct option.

Explanation

System.out.print does not print a newline at the end of its output so the println statement begins printing on the same line. So the output is BEST OF LUCK printed on a single line.

Math.sqrt(3 * x + Math.pow(x,2)) / (a + b))

The value of y will be 33.

Explanation

    y += ++y + y-- + --y
⇒ y = y + ++y + y-- + --y         y = 8
⇒ y = 8 + 9 + y-- + --y              y = 9
⇒ y = 8 + 9 + 9 + --y                 y = 8
⇒ y = 8 + 9 + 9 + 7                    y = 7
⇒ y = 33

(1) Math.floor(-4.7)

Output

-5.0

Explanation

Math.floor method returns the largest double value that is less than or equal to the argument and is equal to a mathematical integer. As -5.0 is the largest mathematical integer less than -4.7 so it is the output. Note that -4.7 is a negative number so the largest integer less than -4.7 is -5.0 and not -4.0.

(2) Math.ceil(3.4) + Math.pow(2,3)

Output

12.0

Explanation

Math.ceil(x) function returns the smallest whole number greater than or equal to x. Math.ceil(3.4) gives 4.0 and Math.pow(2,3) gives 8.0. So the output is 4.0 + 8.0 = 12.0.

1. r1 has 5.83
2. r2 has 4.0

Explanation

1. Math.min(-2.83, -5.83) returns -5.83 as -5.83 is less than -2.83. (Note that these are negative numbers). Math.abs(-5.83) returns 5.83.
2. Math.floor(16.3) returns 16.0. Math.sqrt(16.0) gives square root of 16.0 which is 4.0.

1. Less than operator. (It is a relational operator)
2. Increment operator. (It is an arithmetic operator)
3. Logical AND operator. (It is a logical operator)
4. Ternary operator. (It is a conditional operator)

char occupies 2 bytes and int occupies 4 bytes.

/ operator computes the quotient whereas % operator computes the remainder.

Output

z = 5.0

Explanation

z = Math.sqrt(x * x + y * y)
  ⇒ Math.sqrt(3.0 * 3.0 + 4.0 * 4.0)
  ⇒ Math.sqrt(9.0 + 16.0)
  ⇒ Math.sqrt(25.0)
  ⇒ 5.0

Output

2 to the power of 5 is 32
2 to the power of 4 is 16

Explanation

The execution of while loop is shown in the table below:

    n = result / 2, p = i - 1;
⇒ n = 32 / 2, p = 5 - 1
⇒ n = 16, p = 4

The output of the program is a list of the factors of each integer between 2 and 100, printed to the console.

Output

Factors of2:  
Factors of3:  
Factors of4:  2 
Factors of5:  
Factors of6:  2 3 
Factors of7:  
Factors of8:  2 4 
Factors of9:  3 
Factors of10:  2 5 
...
...
Factors of95:  5 19 
Factors of96:  2 3 4 6 8 12 16 24 32 48 
Factors of97:  
Factors of98:  2 7 14 49 
Factors of99:  3 9 11 33 
Factors of100:  2 4 5 10 20 25 50

Explanation

This Java program finds the factors of integers between 2 and 100.

The program uses two nested for loops to generate the integers to be factored and to find their factors. The outer for loop generates the numbers from 2 to 100 whose factors are to be found.

The inner for loop starts with j = 2 and continues until j < i, incrementing j by 1 each time through the loop. This loop checks whether j is a factor of i by checking whether the remainder of i divided by j is equal to zero. If j is a factor of i, it is printed to the console on the same line as the message "Factors of [i]: ".

After the inner loop has completed, a newline character is printed to the console using System.out.println(). This causes the next message ("Factors of [i+1]: ") to be printed on a new line.

Let us consider the execution of nested 'for' loop for a single value of i (say, i = 6). The given table follows the execution:

Output

20

Explanation

Initially i = 5.

The test condition i > 10 is false and so the control comes to the next statement following 'for' loop — System.out.println(i * 4); and prints 20 (5 * 4) on the screen.

The errors are as follows:

1. The variable count is not declared. It needs to be declared before it can be used.
2. The syntax of 'for' loop requires semicolons ( ; ) as separators, and not comma ( , ). The correct code is as follows:

for(int count = 0;  count < 5;  count = count + 1)	
	System.out.println("This is  count:" + count);	
System.out.println("Done!");

The errors are as follows:

1. The variables — x, y, z, are not declared. They need to be declared before they can be used.
2. The letter 'm' in math should be in uppercase as Java is a case-sensitive language. Also, the correct name of the function is pow. Hence, it must be written as Math.pow().

The correct code snippet is as follows:

int x = 3;	
int y = 4;	
double z = Math.pow(x*x, y/2);

The variable y is declared inside 'if' block. Its scope is limited to if block and it cannot be used outside the block.

The correct code snippet is as follows:

class Test {	
	public static void main (String args[])  {	
		int x = 10;	
        int y;
        if(x == 10)  {
            y = 20;
            System.out.println("x and y: "+ x +"  "+ y);
            x = y * 2;
        }
        y = 100;
        System.out.println("x is"+ x);
    }
}

Java uses Unicode character set.

Smallest individual unit in a program is called token.

statement

Reason — Smallest individual unit in a program is called a token and a statement is composed of many tokens like keywords, identifiers, operators, constants etc.

20_to_50

Reason — An identifier must not begin with a digit. It may contain underscore.

"a"

Reason — Since a is enclosed in double quotes (" "), it becomes a String literal. Character literals are always enclosed within single quotes (' ').

final

Reason — Keyword final creates a named constant.

ch = ch + 2

Reason — += is a shorthand operator. The operator pair += tells the compiler to assign to ch the value of ch + 2.

java.lang

Reason — The Math class is part of java.lang package.

default

Reason — The default clause is optional and, if it is missing, no action takes place if all matches fail.

break

Reason — In the absence of break statement, the control flows to the next case below the matching case leading to fall-through.

1

Reason — By default, the if-part and else-part can contain only one statement. To include more than one statements, the set of statements need to be enclosed in curly braces and included as one compound statement.

for

Reason — for loop is usually used when the number of iterations are fixed.

do-while

Reason — do-while is an exit controlled loop as it executes atleast once even when the condition is false.

do-while

Reason — do-while is an exit controlled loop as it executes atleast once even when the condition is false. The condition is checked at the time of exit.

break

Reason — break statement is used to terminate the complete execution of a loop.