Java_Aug_Sep2023

PART A:

Short Answer Questions

1. Define Polymorphism.

-Polymorphism is a concept in object-oriented programming that allows objects to be treated as

instances of their parent class rather than their actual class. It enables one interface to be used for a
general class of actions. There are two types:

- Compile-time Polymorphism (Method Overloading): Same method name with different

parameters.

- Run-time Polymorphism (Method Overriding): Same method name in the parent and child class.

2. What are the Java Tokens?

- Java tokens are the smallest elements of a Java program. They are:

- Keywords: Reserved words like `class`, `public`, `static`, etc.

- Identifiers: Names given to variables, classes, methods, etc.

- Literals: Fixed values like `10`, `'a'`, `"Hello"`.

- Operators: Symbols like `+`, `-`, `*`, `/`.

- Separators: Symbols like `;`, `,`, `()`, `{}`, `[]`.

3. How to create objects?

- Objects in Java are created using the `new` keyword. For example:

ClassName obj = new ClassName();

Example:

class Car {

String model;

Car myCar = new Car();

myCar.model = "Tesla";

4. What is Swing in Java?

 - Swing is a part of Java Foundation Classes (JFC) used to create window-based applications. It is
built on AWT (Abstract Window Toolkit) and provides more sophisticated components like tables,
lists, scroll panes, buttons, etc.

5. Define Threads.

- A Thread in Java is a lightweight process. It is a separate path of execution and allows multiple
operations to run concurrently. Java provides built-in support for multithreaded programming.

6. What is a package

- A packagein Java is a namespace that organizes a set of related classes and interfaces. It helps in
avoiding name conflicts and controlling access.

package mypack;

public class MyClass {

// class body

PART B:

Four marks Questions

7. Explain features of Java.

- Simple: Easy to learn, syntax similar to C++.

- Object-Oriented: Everything is an object.

- Portable: Write once, run anywhere (WORA).

- Platform-independent: Java bytecode runs on any platform with a JVM.

- Secure: Provides a secure execution environment.

- Robust: Strong memory management, exception handling.

- Multithreaded: Supports multithreading.

- High Performance: Just-In-Time (JIT) compilers.

8. What is a constructor? Explain constructor overloading with an example.

- A constructor is a special method invoked when an object is instantiated. It initializes the object.

- Constructor Overloading: Multiple constructors with different parameter lists.

class Example {
 int x;

Example() {

x = 0;

Example(int a) {

x = a;

Example obj1 = new Example();

Example obj2 = new Example(10);

9. What is inheritance? Discuss various types of inheritance.

- Inheritance is a mechanism where one class inherits the properties and behavior of another class.

- Single Inheritance: One subclass inherits from one superclass.

- Multilevel Inheritance: A class is derived from another derived class.

- Hierarchical Inheritance: Multiple subclasses inherit from one superclass.

- Multiple Inheritance (through interfaces in Java): A class implements multiple interfaces.

- Hybrid Inheritance: Combination of two or more types of inheritance.

10. Explain layout manager in Java.

- Layout managers are used to arrange components in a container. Types:

- FlowLayout: Arranges components in a left-to-right flow.

- BorderLayout: Arranges components in five regions: north, south, east, west, center.

- GridLayout: Arranges components in a grid with equal-sized cells.

- CardLayout: Manages two or more components, each as a card.

- GridBagLayout: More flexible and complex than GridLayout.

11. What is exception handling? Explain types of exceptions.

 - Exception Handling in Java is a mechanism to handle runtime errors to maintain the normal flow
of the application.

- Checked Exceptions: Compile-time exceptions (e.g., IOException).

- Unchecked Exceptions: Runtime exceptions (e.g., NullPointerException).

- Errors: Serious problems that a reasonable application should not try to catch (e.g.,
OutOfMemoryError)

try {

// code that may throw an exception

} catch (ExceptionType e) {

// code to handle the exception

12. WAP to find the sum of digits of a given number using objects and class.

class SumOfDigits {

int number;

SumOfDigits(int num) {

this.number = num;

int calculateSum() {

int sum = 0, temp = number;

while (temp != 0) {

sum += temp % 10;

temp /= 10;

return sum;

public static void main(String[] args) {

SumOfDigits obj = new SumOfDigits(1234);

System.out.println("Sum of digits: " + obj.calculateSum());

 }

PART C:

Eight Mark’s Questions

13. a) Discuss the access specifiers with example.

- Access Specifiers define the scope of class members (variables and methods).

- private: Accessible only within the class.

- default (no modifier): Accessible within the same package.

- protected: Accessible within the same package and subclasses.

- public: Accessible from anywhere.

class Example {

private int a;

public int b;

protected int c;

int d; // default access

b) Explain different types of looping statements.

- For Loop: Repeats a statement or block for a specified number of times.

Example code:

for (int i = 0; i < 10; i++) {

System.out.println(i);

- While Loop: Repeats a statement or block while a condition is true.

Example code:

int i = 0;

while (i < 10) {

 System.out.println(i);

i++;

- Do-While Loop: Similar to while loop, but executes at least once.

Example code

int i = 0;

do {

System.out.println(i);

i++;

} while (i < 10);

14. a) Explain process of applet execution.

- Applet is a Java program that runs in a web browser.

- Steps of execution:

1. Load: The applet is loaded by the browser or applet viewer.

2. Initialize: The `init()` method is called for initialization.

3. Start: The `start()` method is called to start the execution.

4. Paint: The `paint()` method is called to draw on the applet window.

5. Stop: The `stop()` method is called to stop the execution.

6. Destroy: The `destroy()` method is called before the applet is destroyed.

Example code:

import java.applet.Applet;

import java.awt.Graphics;

public class MyApplet extends Applet {

public void init() {

// initialization code

}
 public void start() {

// start code

public void paint(Graphics g) {

g.drawString("Hello, Applet!", 20, 20);

public void stop() {

// stop code

public void destroy() {

// destroy code

b) What are the features of Swing?

- Lightweight Components: Do not rely on native peer components.

- Pluggable Look and Feel: Can change the appearance of components at runtime.

- Rich Set of GUI Components: More than AWT, including tables, trees, sliders.

- MVC Architecture: Separate the model, view, and controller.

- Double Buffering: Smooth graphics rendering.

15. a) Explain the life cycle of a thread.

- New: Thread is created but not yet started.

- Runnable: Thread is ready to run but waiting for CPU time.

- Running: Thread is executing.

- Blocked/Waiting: Thread is blocked or waiting for a resource.

- Terminated: Thread has finished execution.

Example code:
public class My

Thread extends Thread {

public void run() {

System.out.println("Thread is running");

public static void main(String[] args) {

MyThread t = new MyThread();

t.start(); // Thread moves from New to Runnable state

b) What is an array? Explain one dimension array.

- An array is a collection of elements of the same type stored in contiguous memory locations.

- One-dimensional array: Linear array

int[] arr = new int[5]; // declaration and instantiation

arr[0] = 10; // initialization

System.out.println(arr[0]); // accessing element

16. What is an interface? Explain different kinds of interfaces.

- An interface in Java is a reference type, similar to a class, that can contain only constants,
method signatures, default methods, static methods, and nested types. Interfaces cannot contain
instance fields or constructors.

- Types of interfaces:

- Marker Interface: No methods, used to indicate a particular property of the class (e.g.,
Serializable).

- Functional Interface: An interface with exactly one abstract method (e.g., Runnable,
Comparator).

17. a) Explain the life cycle of an applet.

- Load: Applet class is loaded.

 - Initialize: `init()` method is called for initialization.

- Start: `start()` method is called to start execution.

- Paint: `paint()` method is called to perform drawing.

- Stop: `stop()` method is called to stop execution.

- Destroy: `destroy()` method is called before applet is destroyed.

public class MyApplet extends Applet {

public void init() { /* initialization code */ }

public void start() { /* start code */ }

public void paint(Graphics g) { /* drawing code */ }

public void stop() { /* stop code */ }

public void destroy() { /* destroy code */ }

b) Differentiate method overloading and method overriding.

- Method Overloading: Multiple methods with the same name but different parameters

class Example {

void display(int a) { }

void display(String b) { }

- Method Overriding: Subclass provides a specific implementation of a method already defined in

its superclass.

class Parent {

void show() { }

class Child extends Parent {

@Override

void show() { }

18. a) Write a program to implement arithmetic operations using inheritance.

 class Arithmetic {

int a = 10;

int b = 5;

class Addition extends Arithmetic {

int add() {

return a + b;

class Subtraction extends Arithmetic {

int subtract() {

return a - b;

public class Main {

public static void main(String[] args) {

Addition add = new Addition();

Subtraction sub = new Subtraction();

System.out.println("Addition: " + add.add());

System.out.println("Subtraction: " + sub.subtract());

b) What are the advantages and disadvantages of Java Beans?

- Advantages:

- Reusability: Beans can be reused in different environments.

- Customization: Beans can be customized in design-time environments.

- Ease of use: Can be manipulated visually.

 - Compatibility: Follows a set of conventions for property, event, and method naming.

- Disadvantages:

- Complexity: Can be complex to set up for beginners.

- Performance: May be slower due to the overhead of the bean framework.

- Size: Larger codebase for the same functionality.