QUESTION BANK:

1. Explain object-oriented principles.

Java is based on Object-Oriented Programming (OOP). The main principles are:

 Encapsulation: Binding data (variables) and code (methods) together, while restricting direct
access from outside.
Encapsulation means binding data and methods into a single unit called a class and
protecting data from outside access.
It helps in data security and provides a clean way to use objects.
In Java, encapsulation is achieved using classes:
 Private members → accessible only inside the class.
 Public methods → used to access private data safely.
Example:
class Student {
private int age; // data hidden
// public method to set value
void setAge(int a) {
age = a;
}
// public method to get value
int getAge() {
return age;
}
}
public class Main {
public static void main(String[] args) {
Student s = new Student();
[Link](20);
[Link]("Age: " + [Link]());
}
}

 Inheritance: Inheritance means one class can use the properties and methods of another
class.
It helps in code reusability — no need to write the same code again.
It also supports hierarchical classification (like parent–child relationships).
Example:
class Animal {
void eat() {
[Link]("Eating...");
}
}

class Dog extends Animal {

void bark() {
[Link]("Barking...");
}
}
public class Main {
public static void main(String[] args) {
 Dog d = new Dog();
[Link](); // from parent
[Link](); // from child
}
}

 Polymorphism: Polymorphism means one interface, many forms — the same method name
can have different behaviors depending on the situation.
It is achieved through method overloading (same name, different parameters) and method
overriding (same name, same parameters, different class).
Example:
class MathOperation {
int add(int a, int b) {
return a + b;
}
double add(double a, double b) {
return a + b;
}
}

public class Main {

public static void main(String[] args) {
MathOperation m = new MathOperation();
[Link]([Link](5, 10));
[Link]([Link](3.5, 2.5));
}
}

 Abstraction: Hiding unnecessary details and showing only important features.

Makes programs easier to extend and modify without breaking everything.
Helps in code reusability and maintenance.
Example: Using abstract classes or interfaces.
abstract class Shape {
abstract void draw(); // only declared
}

class Circle extends Shape {

void draw() {
[Link]("Drawing Circle");
}
}

public class Main {

public static void main(String[] args) {
Shape s = new Circle();
[Link]();
}
}

2. Explain Operators with an example for each

 1. Arithmetic operators
Used for basic math operations.
+,-,*,/,%
Example:
int a = 10, b = 3;
[Link](a + b); // 13
[Link](a - b); // 7
[Link](a * b); // 30
[Link](a / b); // 3
[Link](a % b); // 1

2. Relational Operators
Used to compare two values.
==, !=, >, <, >=, <=
Example:
int a = 5, b = 8;
[Link](a == b); // false
[Link](a < b); // true

3. Logical Operators
Used to combine conditions.
&& (AND), || (OR), ! (NOT)
Example:
int x = 10, y = 20;
[Link](x < y && y > 15); // true
[Link](x < y || x > y); // true
[Link](!(x < y)); // false

4. Assignment Operators
Used to assign values.
=, +=, -=, *=, /=
Example:
int n = 5;
n += 3; // n = n + 3
[Link](n); // 8

5. Increment and Decrement

++ increases by 1, -- decreases by 1.
Example:
int a = 5;
a++; // a = 6
a--; // a = 5
[Link](a);

3. Explain break, continue, and goto statements.

1. Break statement
Used to exit a loop or switch immediately
Example:
for (int i = 1; i <= 5; i++) {
if (i == 3)
break; // stops the loop when i = 3
 [Link](i);
}
// Output: 1 2

2. continue statement
Used to skip the current iteration and continue with the next one.
for (int i = 1; i <= 5; i++) {
if (i == 3)
continue; // skips when i = 3
[Link](i);
}
// Output: 1 2 4 5

3. goto
java does not support goto, but we can use labels to jump within loops.
Example:
outer:
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
if (i == 2 && j == 2)
break outer; // exits both loops
[Link](i + " " + j);
}
}
// Output:
// 1 1
// 1 2
// 1 3
// 2 1

4. Explain different types of Control and looping statements in Java.

Control statements
1. if statement
Executes code only if a condition is true.
Example:
int a = 10;
if (a > 5)
[Link]("a is greater than 5");

2. if-else statement
Executes one block if condition is true, another if false.
Example:
int a = 3;
if (a > 5)
[Link]("a is greater");
else
[Link]("a is smaller");

3. else-if ladder
Checks multiple conditions.
Example:
 int marks = 75;
if (marks >= 90)
[Link]("Grade A");
else if (marks >= 60)
[Link]("Grade B");
else
[Link]("Grade C");

4. switch statement
Used when there are multiple fixed choices.
int day = 2;
switch (day) {
case 1: [Link]("Monday"); break;
case 2: [Link]("Tuesday"); break;
default: [Link]("Other day");
}

Looping statements
1. for loop
Runs a block of code a fixed number of times.
Example:
for (int i = 1; i <= 5; i++)
[Link](i);
Output:
1
2
3
4
5

2. while loop
Repeats while a condition is true.
Example:
int i = 1;
while (i < 5) {
[Link](i);
i++;
}
Output:
1
2
3
4

3. do-while loop
Executes the block at least once, then checks the condition.
int i = 1;
do {
[Link](i);
i++;
 } while (i <= 5);
Output:
1
2
3
4
5

5) Explain typecasting.
Typecasting in Java (Simple Explanation)
Typecasting means converting one data type into another.
There are two types:
1. Implicit (Widening) – done automatically by Java.
int num = 10;
double d = num; // int to double (automatic)
[Link](d);
Output: 10.0

2. Explicit (Narrowing) – done manually by the programmer.

double x = 9.78;
int y = (int) x; // double to int (manual)
[Link](y);
Output:
9

6) Explain Constructors with example.

Constructors in Java
A constructor is a special method in a class that is automatically called when an object is created.
It is used to initialize objects. A constructor initializes object data. It runs automatically when the
object is created. Can be parameterized (takes values) or default (no parameters).
 Constructor name = Class name
 It has no return type (not even void)
Example:
class Student {
String name;
int age;
// Constructor
Student(String n, int a) {
name = n;
age = a;
 }
void display() {
[Link]("Name: " + name);
[Link]("Age: " + age);
}
}
public class Main {
public static void main(String[] args) {
Student s1 = new Student("Alex", 20); // calls constructor
[Link]();
}
}
Output:
Name: Alex
Age: 20

7) Explain Overloading with any real time example.

Method Overloading means using the same method name but with different parameters (number
or type). It allows a class to perform similar tasks in different ways. Overloading helps make
programs more readable and flexible, by using one method name for similar actions.
Example:
class Calculator {
// Add two integers
int add(int a, int b) {
return a + b;
}
// Add three integers (same method name, different parameters)
int add(int a, int b, int c) {
return a + b + c;
}
// Add two double numbers
double add(double a, double b) {
return a + b;
 }
}
public class Main {
public static void main(String[] args) {
Calculator calc = new Calculator();
[Link]("Sum of 2 numbers: " + [Link](5, 10));
[Link]("Sum of 3 numbers: " + [Link](2, 3, 4));
[Link]("Sum of doubles: " + [Link](2.5, 3.5));
}
}
Output:
Sum of 2 numbers: 15
Sum of 3 numbers: 9
Sum of doubles: 6.0

8) Explain the arguments that can be passed within methods with example.
Arguments in Methods
Arguments are the values passed to a method when it is called.
There are two types of arguments in Java:
1. Call by Value – A copy of the value is passed.
2. Call by Reference (using objects) – The reference (address) of the object is passed.
Example 1: Call by Value
class Example {
void changeValue(int a) {
a = a + 10; // changes local copy only
[Link]("Inside method: " + a);
}
}

public class Main {

public static void main(String[] args) {
int num = 5;
Example obj = new Example();
 [Link](num);
[Link]("Outside method: " + num);
}
}
Output:
Inside method: 15
Outside method: 5
Example 2: Call by Reference (using objects)
class Box {
int size = 5;
}

class Example {
void change(Box b) {
[Link] = [Link] + 10; // modifies original object
}
}

public class Main {

public static void main(String[] args) {
Box b1 = new Box();
Example obj = new Example();
[Link](b1);
[Link]("New size: " + [Link]);
}
}
Output:
New size: 15

9) Explain this, final, super, and static keywords with example for each.
1. this Keyword
Refers to the current object of the class.
Used when local and instance variables have the same name.
Example:
class Student {
int age;

Student(int age) {
[Link] = age; // 'this' refers to the current object
}

void show() {
[Link]("Age: " + age);
}
}

public class Main {

public static void main(String[] args) {
Student s1 = new Student(20);
[Link]();
}
}
Output:
Age: 20
2) final Keyword
Used to make a variable constant, method unchangeable, or class non-inheritable.
Example:
class Example {
final int VALUE = 100; // cannot be changed

void display() {
// VALUE = 200; ❌ Error: cannot modify final variable
[Link]("Value: " + VALUE);
}
}

public class Main {

public static void main(String[] args) {
Example e = new Example();
[Link]();
 }
}
Output:
Value: 100

3) super Keyword
Used to access parent class members (variables, methods, or constructors).
Example:
class Animal {
void sound() {
[Link]("Animal makes sound");
}
}

class Dog extends Animal {

void sound() {
[Link](); // calls parent class method
[Link]("Dog barks");
}
}

public class Main {

public static void main(String[] args) {
Dog d = new Dog();
[Link]();
}
}
Output:
Animal makes sound
Dog barks

4) static Keyword
Belongs to the class rather than an object.
Can be used for variables, methods, or blocks.
Example:
class Counter {
static int count = 0; // shared by all objects

Counter() {
count++;
}

static void showCount() {

[Link]("Count: " + count);
}
}

public class Main {

public static void main(String[] args) {
new Counter();
new Counter();
 [Link]();
}
}
Output:
Count: 2

10) Explain access controls in Java.

Access controls (also called Access Modifiers) define how accessible classes, methods, and
variables are from other classes or packages.
private → Accessible only in the same class
(no modifier) → Accessible within the same package
protected → Accessible in the same package and by subclasses
public → Accessible from anywhere
Example:
class Example {
private int a = 10; // accessible only inside this class
int b = 20; // default access (package level)
protected int c = 30; // accessible in subclasses
public int d = 40; // accessible everywhere

void show() {
[Link](a + " " + b + " " + c + " " + d);
}
}

public class Main {

public static void main(String[] args) {
Example obj = new Example();
// [Link](obj.a); ❌ private - not accessible
[Link](obj.b); // ✅ default
[Link](obj.c); // ✅ protected (same package)
[Link](obj.d); // ✅ public
}
}

11) Explain Single and Multilevel inheritance with example for each.
Single Inheritance
In Single Inheritance, one class inherits from another class (only one parent).
Example:
class Animal {
void eat() {
[Link]("Eating...");
}
}

class Dog extends Animal { // Dog inherits from Animal

void bark() {
[Link]("Barking...");
}
}
public class Main {
public static void main(String[] args) {
Dog d = new Dog();
[Link](); // inherited method
[Link](); // child’s own method
}
}
Output:
Eating...
Barking...

Multilevel Inheritance
In Multilevel Inheritance, a class is derived from another derived class (a chain of
inheritance).
Example:
class Animal {
void eat() {
[Link]("Eating...");
}
}

class Dog extends Animal {

void bark() {
[Link]("Barking...");
}
}

class Puppy extends Dog {

void weep() {
[Link]("Weeping...");
}
}

public class Main2 {

public static void main(String[] args) {
Puppy p = new Puppy();
[Link](); // from Animal
[Link](); // from Dog
[Link](); // from Puppy
}
}
Output:
Eating...
Barking...
Weeping...

12) Develop a Java recursive program to find the nth Fibonacci number, factorial and
conversion from decimal to binary.
nᵗʰ Fibonacci number
public class FibonacciRecursion {
static int fibonacci(int n) {
 if (n <= 1)
return n;
return fibonacci(n - 1) + fibonacci(n - 2);
}

public static void main(String[] args) {

int n = 5;
[Link]("Fibonacci of " + n + " = " + fibonacci(n));
}
}
Output:
Fibonacci of 5 = 5

Factorial using Recursion

public class FactorialRecursion {
static int factorial(int n) {
if (n == 0)
return 1;
return n * factorial(n - 1);
}

public static void main(String[] args) {

int n = 5;
[Link]("Factorial of " + n + " = " + factorial(n));
}
}
Output:
Factorial of 5 = 120

Decimal to Binary using Recursion

public class DecimalToBinaryRecursion {
static void decimalToBinary(int n) {
if (n > 0) {
decimalToBinary(n / 2);
[Link](n % 2);
}
}

public static void main(String[] args) {

int n = 10;
[Link]("Binary of " + n + " = ");
decimalToBinary(n);
}
}
Output:
Binary of 10 = 1010