1.What are java constants? Where do we use Java constants?
A: Java constants:
In Java, a constant is a variable whose value cannot be
changed once it's assigned.
Constants are often used to represent values that will not change, such
as the number of students in a class.
A constant can be declared within a method, class, or interface.
Syntax
To declare a constant in a class, we use the final keyword:
public final int NUM_STUDENTS = 100;
To declare a constant in an interface, use
the static and final keywords:
public static final int NUM_STUDENTS = 100;
Note: The statements above declare a constant named NUM_STUDENTS with a
value of 100.
2.What are the types pf variables? Or What is the life of Java
variables?
A: Types of Java Variables:
There are three types of variables in Java:
Local, Instance and Static.
Local Variables:
A variable defined within a block or method or constructor is called a
local variable.
The Local variable is created at the time of declaration and
destroyed when the function completed its execution.
The scope of local variables exists only within the block in which
they are declared.
Instance Variables
Instance variables are known as non-static variables and are
declared in a class outside of any method, constructor, or block.
Instance variables are created when an object of the class is
created and destroyed when the object is destroyed.
Static Variables:
Static variables are also known as class variables.
These variables are declared similarly to instance variables. The
difference is that static variables are declared using the static
keyword within a class outside of any method, constructor, or
block.
3.What is meant type casting in java? Or What is meant by type
conversion in java?
A: Type conversion, also known as type casting, is the process of
changing a value from one data type to another.
Java provides various data types just like any
other dynamic language such as boolean, char, int, unsigned int,
signed int, float, double, long, etc in total providing 7 types
where every datatype acquires different space while storing in
memory.
Automatic Type Conversion:
Conversion takes place when two data types are automatically
converted. This happens when:
The two data types are compatible.
When we assign a value of a smaller data type to a bigger data
type.
Narrowing or Explicit Conversion
If we want to assign a value of a larger data type to a smaller
data type we perform explicit type casting or narrowing.
This is useful for incompatible data types where automatic
conversion cannot be done.
Type Promotion in Expressions:
Difference Between Explicit and Implicit Conversion
The below table demonstrates the key difference between Explicit and
Implicit Conversion
Implicit Explicit
Aspect Conversion Conversion
Requires explicit
No additional
type casting
syntax required.
Syntax (e.g., (int)).
Works with both
Only works with
compatible and
compatible types
incompatible
(e.g., numeric).
Data Compatibility types.
May result in data
No risk of data
loss (e.g.,
loss.
Risk of Data Loss truncation).
Smaller type to Larger type to
Direction larger type. smaller type.
4. How to accept input from the keyboard?
Accepting input from the keyboard:
The Scanner class in Java, found in
the java.util package, is a utility used for obtaining input from
various sources, such as the user (via the keyboard), files, or
other input streams. It simplifies the process of parsing primitive
types (like int, double, boolean) and strings from the input.
Input Source:
The Scanner class can read input from System.in (standard
input, typically the keyboard), File objects, or any object
implementing the Readable interface.
Syntax:
Scanner inputScanner = new Scanner(System.in);
Methods for Data Types:
It provides various "next" methods to read specific data
types:
nextInt(): Reads an integer.
nextDouble(): Reads a double.
nextLine(): Reads an entire line of text (including spaces)
until a newline character is encountered.
next(): Reads the next token (word) from the input.
hasNextInt(), hasNextDouble(), etc.: Checks if the next token
in the input matches the specified data type.
Closing the Scanner:
It is crucial to close the Scanner object after use to
release system resources, especially when dealing with file
input. This can be done using the close() method.
5.How to read input with java.util.Scanner class?
A: Reading input in Java using the java.util.Scanner class involves
a few key steps:
Import the Scanner class: Begin your Java program by importing
the Scanner class from the java.util package.
import java.util.Scanner;
Create a Scanner object: Instantiate a Scanner object, typically
associating it with System.in to read input from the console.
Scanner scanner = new Scanner(System.in);
Prompt the user (optional but recommended): Before reading input,
provide a clear message to the user indicating what kind of input is
expected.
System.out.print("Enter your name: ");
Read input using appropriate methods: The Scanner class provides various
methods to read different data types:
o nextLine(): Reads an entire line of text until a newline character
is encountered.
o next(): Reads a single word (token) until a whitespace character is
encountered.
o nextInt(): Reads an integer value.
o nextDouble(): Reads a double-precision floating-point value.
o nextBoolean(): Reads a boolean value (true or false).
o And many more for other data types
like nextByte(), nextFloat(), nextLong(), nextShort(), nextBigInteg
er(), nextBigDecimal().
6.How to display output with System.out.printf()?
A: The printf() method takes a format string as its first
argument, followed by a variable number of arguments that
correspond to the format specifiers within the string.
Syntax:
System.out.printf("Format string with specifiers", arg1,
arg2, ...);
Common Format Specifiers:
%s: String
Example: The %s character is a placeholder for the string "World":
Syntax: System.out.printf("Hello %s!", "World");
%d: Decimal integer
Syntax: System.out.printf("%f\n", a);
%f: Floating-point number (float or double)
Syntax: System.out.printf("%5.3f\n", a);
%c: Character
Syntax: System.out.println("%b\n", c);
%b or %B: Boolean value
%o: Octal integer
%x or %X: Hexadecimal integer
%e or %E: Scientific notation
%n: Platform-specific newline character.
7.How to display formatted output with String.format()?
A: In Java, the String.format() method is used to produce a
formatted string using a format string and a variable number of
arguments. This method is similar in functionality to
the printf() function in C.
Basic Usage:
The String.format() method takes at least two arguments: a format
string and the arguments to be formatted.
String formattedString = String.format("Format string with
placeholders", arg1, arg2, ...);
Format Specifiers:
Placeholders within the format string are
called format specifiers, which begin with a % symbol and indicate
how an argument should be formatted. Common format specifiers
include: %s: for strings, %d: for decimal integers, %f: for
floating-point numbers, and %b` or %B: for boolean values.
Examples:
Formatting a String:
String name = "Alice";
String message = String.format("Hello, %s!", name);
System.out.println(message); // Output: Hello, Alice!
Formatting an Integer:
int age = 30;
String formattedAge = String.format("You are %d years old.",
age);
System.out.println(formattedAge); // Output: You are 30 years
old.
Formatting a Floating-Point Number with Precision:
Java
double price = 19.9987;
String formattedPrice = String.format("The price is $%.2f",
price);
System.out.println(formattedPrice); // Output: The price is
$20.00
8.Describe control statements in java?
Control statements in Java are fundamental
constructs that govern the flow of execution within a program. They
enable decision-making, repetition of code blocks.
Java's control statements are categorized into three main types:
Decision-Making Statements (Conditional Statements):
These statements allow the program to execute different blocks of code
based on whether a specified condition evaluates to true or false.
if statement: Executes a block of code if a condition is true.
if-else statement: Executes one block of code if a condition is
true and another if it's false.
else-if ladder: Allows for multiple conditions to be checked
sequentially, executing the block associated with the first true
condition.
switch statement: Provides a way to execute different blocks of
code based on the value of a variable or expression.
Looping Statements (Iterative Statements):
These statements enable the repeated execution of a block of code as
long as a certain condition remains true.
for loop: Used when the number of iterations is known or can be
determined beforehand.
while loop: Executes a block of code repeatedly as long as a
condition remains true, checking the condition before each
iteration.
do-while loop: Similar to the while loop, but guarantees at least
one execution of the code block before checking the condition.
for-each loop (Enhanced for loop): Provides a simplified way to
iterate over elements of arrays and collections.
Jump Statements:
These statements alter the flow of execution by transferring control to
a different part of the program.
break statement: Terminates the execution of the innermost loop
or switch statement and transfers control to the statement
immediately following it.
continue statement: Skips the current iteration of a loop and
proceeds to the next iteration.
return statement: Exits the current method and optionally returns a
value.
9.What is Decision making statements in java?
Java if statement:
The Java if statement is the most simple decision-making
statement. It is used to decide whether a certain statement or
block of statements will be executed or not i.e. if a certain
condition is true then a block of statements is executed otherwise
not.
Syntax:
if(condition)
{
// Statements to execute if
// condition is true
}
Working of if statement:
1. Control falls into the if block.
2. The flow jumps to Condition.
3. Condition is tested.
1. If Condition yields true, goto Step 4.
2. If Condition yields false, goto Step 5.
4. The if-block or the body inside the if is executed.
5. Flow steps out of the if block.
Flowchart if statement:
Java if-else Statement:
The if statement alone tells us that if a
condition is true it will execute a block of statements and if the
condition is false it won't. But what if we want to do something
else if the condition is false? Here, comes the "else" statement.
We can use the else statement with the if statement to execute a
block of code when the condition is false.
Syntax of if-else Statement
if (condition) {
// Executes this block if // condition is true
} else
{// Executes this block if // condition is false
}
Working of if-else Statement
1. Control falls into the if block.
2. The flow jumps to the condition.
3. The condition is tested:
1. If the condition yields true, go to Step 4.
2. If the condition yields false, go to Step 5.
4. The if block or the body inside the if is executed.
5. If the condition is false, the else block is executed instead.
6. Control exits the if-else block.
Flowchart of Java if-else Statement
if-else-if Ladder: Used when there are multiple conditions to check
sequentially. The first condition that evaluates to true has its
corresponding block of code executed.
Syntax:
if (condition1) {
// Code for condition1
} else if (condition2) {
// Code for condition2
} else {
// Code if none of the above conditions are true
}
switch Statement: This statement is used to select one of many code
blocks to be executed based on the value of a single variable or
expression. It is often a more readable alternative to a long if-else-
if ladder when dealing with discrete values.
Syntax:
switch (expression) {
case value1:
// Code for value1
break;
case value2:
// Code for value2
break;
default:
// Code if no case matches
}
10.What are Iterative statements in java?
A: Iteration statements in Java, also known as looping statements, enable
the repeated execution of a block of code based on a specific
condition. Java provides three main types of iteration statements:
for loop: This loop is typically used when the number of iterations is
known in advance. It consists of three parts:
o Initialization: Executed once at the beginning of the loop, usually
to declare and initialize a loop control variable.
o Condition: Evaluated before each iteration. If true, the loop body
executes; otherwise, the loop terminates.
o Increment/Decrement: Executed after each iteration, usually to
update the loop control variable.
Syntax:
for (int i = 0; i < 5; i++) {
System.out.println("Iteration: " + i);
}
while loop: This loop repeatedly executes a block of code as long as a
given boolean condition remains true. The condition is evaluated before
each iteration. If the condition is initially false, the loop body will
not execute even once.
Syntax:
int count = 0;
while (count < 3) {
System.out.println("Count: " + count);
count++;
}
do-while loop: Similar to the while loop, but the loop body is executed
at least once before the condition is evaluated. After the first
execution, the loop continues to repeat as long as the condition remains
true.
Syntax:
int i = 0;
do {
System.out.println("Value of i: " + i);
i++;
} while (i < 2);
