Java Programming 2079

1. What is byte code? Discuss Java architecture with suitable figure.

Byte Code: Byte code is the compiled object code of a Java program, generated by the Java
compiler (javac) from Java source code (.java files). It is an intermediate representation that is
not fully compiled into machine-specific code but is instead platform-independent. This byte
code, stored in .class files, is executed by the Java Virtual Machine (JVM). The JVM interprets
or compiles the byte code into machine-specific code, enabling Java programs to run on any
platform with a JVM installed. This aligns with Java’s “Write once, run anywhere” principle.
The document explains that byte code is processed by the JVM rather than directly by the
processor, and its structure is designed to be understandable only by the JVM.
Java Architecture: The Java architecture facilitates platform independence through several key
components, as outlined in the document:
 Java Source Code: Java programs are written in .java files, containing classes, methods,
variables, and objects, using Unicode characters for universal compatibility.
 Java Compiler (javac): The compiler converts the .java source code into byte code
(.class files). This byte code is platform-independent, meaning it can run on any system
with a JVM.
 Java Virtual Machine (JVM): The JVM is a software-based virtual computer that
resides within a real computer. It interprets the byte code and translates it into machine-
specific code for the underlying hardware. The JVM’s primary functions are:
o Enabling platform independence by allowing Java programs to run on any device
or operating system.
o Managing and optimizing program memory, including garbage collection.
 Java Interpreter: The interpreter within the JVM converts byte code into machine code
specific to the host system. Different interpreters are used for different platforms,
ensuring compatibility.
 Java Runtime Environment (JRE): The JRE includes the JVM and necessary libraries,
providing the environment needed to run Java applications.
Figure:
2. What are different types of loops in Java? Write a Java program to find factorial of
entered number.
Types of Loops in Java: Although the provided document does not explicitly list loop types,
based on standard Java programming knowledge and the context of the document, Java supports
the following loop constructs, which are commonly covered in programming courses like the one
referenced:
1. for Loop:
o Used when the number of iterations is known in advance.
o Syntax: for (initialization; condition; update) { // code }
o Example: Iterating over a fixed range, such as printing numbers from 1 to 10.
2. while Loop:
o Used when the number of iterations is not known, and the loop continues as long
as a condition is true.
o Syntax: while (condition) { // code }
o Example: Reading input until a specific condition is met.
3. do-while Loop:
 o Similar to the while loop but guarantees at least one execution of the loop body
before checking the condition.
o Syntax: do { // code } while (condition);
o Example: Prompting user input until valid data is provided.
4. Enhanced for Loop (for-each):
o Used to iterate over arrays or collections.
o Syntax: for (Type variable : collection) { // code }
o Example: Iterating over elements in an array or list.
Java Program to Find Factorial of an Entered Number: Below is a Java program to calculate
the factorial of a number entered by the user, using a for loop for clarity and efficiency:
import java.util.Scanner;

public class Factorial {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter a non-negative integer to calculate its factorial: ");
int number = scanner.nextInt();

// Validate input
if (number < 0) {
System.out.println("Factorial is not defined for negative numbers.");
} else {
long factorial = 1; // Use long to handle larger factorials
for (int i = 1; i <= number; i++) {
factorial *= i;
}
System.out.println("Factorial of " + number + " is: " + factorial);
}

scanner.close();
}
}
Sample Output:
Enter a non-negative integer to calculate its factorial: 5
Factorial of 5 is: 120
Alternative Using while Loop:
import java.util.Scanner;

public class Factorial {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter a non-negative integer to calculate its factorial: ");
int number = scanner.nextInt();

if (number < 0) {
System.out.println("Factorial is not defined for negative numbers.");
} else {
long factorial = 1;
int i = 1;
while (i <= number) {
factorial *= i;
i++;
}
System.out.println("Factorial of " + number + " is: " + factorial);
}

scanner.close();
}
}
OR: Discuss the concept of static data members and static methods with example.
Static Data Members and Static Methods: The document does not explicitly cover static
members and methods in detail, but it mentions that static fields are not serialized because they
belong to the class, not an instance. Based on this and standard Java concepts, here is a
comprehensive explanation:
 Static Data Members:
o Declared with the static keyword, these belong to the class rather than any
specific object.
o Shared across all instances of the class, meaning all objects access the same copy
of the static variable.
o Commonly used for constants or shared resources, such as counters or
configuration settings.
o Example: A static variable to track the number of objects created for a class.
 Static Methods:
o Also declared with the static keyword, these belong to the class and can be called
without creating an instance.
o Cannot access non-static (instance) variables or methods directly, as they are not
tied to an object.
o Often used for utility functions or operations that don’t require object-specific
data.
o Example: The main method in Java is static, allowing it to be called without
instantiating the class.
Example Program:
public class Student {
// Static data member
static int studentCount = 0;
// Instance variables
int id;
String name;

// Constructor
public Student(int id, String name) {
this.id = id;
this.name = name;
 studentCount++; // Increment static counter when a new student is created
}

// Static method
public static int getStudentCount() {
return studentCount;
}

// Instance method
public void display() {
System.out.println("ID: " + id + ", Name: " + name);
}

public static void main(String[] args) {

// Creating instances
Student s1 = new Student(1, "Alice");
Student s2 = new Student(2, "Bob");

// Calling instance method

s1.display();
s2.display();

// Calling static method

System.out.println("Total students: " + Student.getStudentCount());
}
}
Output:
ID: 1, Name: Alice
ID: 2, Name: Bob
Total students: 2
3. What is interface? How it can be used for achieving multiple inheritance? Explain with
example.
Interface in Java: An interface in Java is a blueprint of a class that defines a set of abstract
methods (and optionally constants) that implementing classes must provide. The document does
not explicitly define interfaces but mentions the Serializable interface (page 149) as a marker
interface, which has no methods but marks a class as capable of serialization. Based on this and
standard Java knowledge:
 An interface is declared using the interface keyword.
 It contains abstract methods (no implementation), default methods (with implementation
since Java 8), and static constants.
 A class implements an interface using the implements keyword and must provide
implementations for all abstract methods.
 Interfaces enable abstraction, loose coupling, and multiple inheritance in Java.
Achieving Multiple Inheritance: Java does not support multiple inheritance through classes (a
class cannot extend multiple classes) to avoid issues like the diamond problem. However, a class
can implement multiple interfaces, effectively achieving multiple inheritance of behavior. This
allows a class to inherit method declarations from multiple sources.
Example Program:
// Interface 1
interface Printable {
void print();
}

// Interface 2
interface Displayable {
void display();
}

// Class implementing multiple interfaces

class Document implements Printable, Displayable {
String content;
 public Document(String content) {
this.content = content;
}

// Implementing method from Printable

@Override
public void print() {
System.out.println("Printing document: " + content);
}

// Implementing method from Displayable

@Override
public void display() {
System.out.println("Displaying document: " + content);
}
}

public class MultipleInheritanceDemo {

public static void main(String[] args) {
Document doc = new Document("Sample Document");
doc.print();
doc.display();
}
}
Output:
Printing document: Sample Document
Displaying document: Sample Document

OR: Why inheritance is important? Write a Java program to demonstrate single

inheritance.
Importance of Inheritance: The document highlights inheritance as a key feature of object-
oriented programming (OOP) in Java. Inheritance is important because:
 Code Reusability: Allows a subclass to inherit properties and methods from a superclass,
reducing redundant code.
 Extensibility: Enables the creation of new classes that extend existing ones, adding or
modifying functionality.
 Polymorphism: Supports method overriding and dynamic method dispatch, enabling
flexible and extensible designs.
 Hierarchical Organization: Models real-world relationships (e.g., a “Car” is a type of
“Vehicle”), improving code structure.
 Maintainability: Changes to the superclass automatically propagate to subclasses,
simplifying updates.
Java Program to Demonstrate Single Inheritance:
// Superclass
class Animal {
String name;

public Animal(String name) {

this.name = name;
}

public void eat() {

System.out.println(name + " is eating.");
}
}

// Subclass
class Dog extends Animal {
public Dog(String name) {
super(name); // Call superclass constructor
}
 // Overriding method
@Override
public void eat() {
System.out.println(name + " is eating bones.");
}

// Additional method
public void bark() {
System.out.println(name + " is barking.");
}
}

public class SingleInheritanceDemo {

public static void main(String[] args) {
Dog dog = new Dog("Buddy");
dog.eat(); // Calls overridden method
dog.bark(); // Calls subclass-specific method
}
}
Output:
Buddy is eating bones.
Buddy is barking.

4. What is exception? Discuss the use of try...catch...finally with suitable example.

Exception in Java: An exception is an event that disrupts the normal flow of a program’s
execution, typically due to errors like invalid input, file not found, or network issues. The
document does not explicitly define exceptions but provides examples of exception handling in
file operations and database connectivity, where try...catch blocks handle IOException and other
exceptions.
 Types of Exceptions:
 o Checked Exceptions: Checked at compile-time (e.g., IOException,
SQLException). Must be handled or declared.
o Unchecked Exceptions: Occur at runtime (e.g., NullPointerException,
ArrayIndexOutOfBoundsException). Optional to handle.
 Purpose: Exception handling ensures robust programs by gracefully managing errors,
preventing crashes, and providing meaningful feedback.
Use of try...catch...finally:
 try Block: Contains code that might throw an exception.
 catch Block: Handles specific exceptions thrown in the try block, allowing the program
to recover or log the error.
 finally Block: Executes regardless of whether an exception occurs, typically used for
cleanup (e.g., closing files or database connections).
Example:
import java.io.*;

public class FileReadWriteExample {

public static void main(String[] args) {
FileReader reader = null;
FileWriter writer = null;
try {
// Reading from a file
reader = new FileReader("MyFile.txt");
BufferedReader bufferedReader = new BufferedReader(reader);
String line;
System.out.println("Reading file contents:");
while ((line = bufferedReader.readLine()) != null) {
System.out.println(line);
}

// Writing to a file
writer = new FileWriter("MyFile.txt", true); // Append mode
 writer.write("Hello World\n");
writer.write("Good Bye!\n");
} catch (IOException e) {
System.out.println("An error occurred: " + e.getMessage());
e.printStackTrace();
} finally {
try {
if (reader != null) {
reader.close();
}
if (writer != null) {
writer.close();
}
} catch (IOException e) {
System.out.println("Error closing resources: " + e.getMessage());
}
}
}
}
Reading file contents:
[Existing content of MyFile.txt]
After execution, the file will append:
Hello World
Good Bye!
If an error occurs (e.g., file not found), the output might be:
An error occurred: MyFile.txt (No such file or directory)
[Stack trace]
5. What are byte stream classes? Explain the classes with example.
Byte Stream Classes in Java: Byte stream classes in Java handle input and output of data in the
form of bytes (8-bit units), suitable for processing raw data like binary files, images, or non-text
data. Byte streams as part of the java.io package, emphasizing their role in reading from and
writing to sources like files. Key byte stream classes include:
 FileInputStream: Reads bytes from a file.
 FileOutputStream: Writes bytes to a file.
 BufferedInputStream: Buffers input to reduce direct access to the underlying source,
improving performance.
 BufferedOutputStream: Buffers output to reduce direct writes, enhancing efficiency.
When to Use Byte Streams: Byte streams are ideal for handling raw data, such as binary files
(e.g., images, audio, or executables), where character encoding is not required. The document
contrasts byte streams with character streams, noting that byte streams process data byte by byte,
while character streams handle Unicode characters.
Example:
java.io.*;

public class BStream {

public static void main(String[] args) throws IOException {
FileInputStream sourceStream = null;
FileOutputStream targetStream = null;
try {
sourceStream = new FileInputStream("sourcefile.txt");
targetStream = new FileOutputStream("targetfile.txt");
// Reading source file and writing to target file byte by byte
int temp;
while ((temp = sourceStream.read()) != -1) {
targetStream.write((byte) temp);
}
} finally {
if (sourceStream != null) {
sourceStream.close();
}
if (targetStream != null) {
 targetStream.close();
}
}
}
}
Additional Example with Buffered Streams: To demonstrate BufferedInputStream and
ufferedOutputStream:
import java.io.*;

public class BufferedStreamExample {

public static void main(String[] args) throws IOException {
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
bis = new BufferedInputStream(new FileInputStream("sourcefile.txt"));
bos = new BufferedOutputStream(new FileOutputStream("targetfile.txt"));
int temp;
while ((temp = bis.read()) != -1) {
bos.write(temp);
}
} finally {
if (bis != null) {
bis.close();
}
if (bos != null) {
bos.flush(); // Ensure all buffered data is written
bos.close();
}
}
}
}
6. What is event handling? Explain handling of action events with example.
Event Handling in Java: Event handling is the mechanism by which a program responds to user
interactions or system-generated events, such as button clicks, mouse movements, or key presses.
In Java, event handling is primarily used in GUI applications (e.g., using AWT or Swing) to
make interfaces interactive. The examples of handling action events in Swing applications,
where components like buttons trigger actions.
 Key Components:
o Event Source: The component generating the event (e.g., a JButton).
o Event Object: An object (e.g., ActionEvent) that describes the event.
o Event Listener: An interface (e.g., ActionListener) that defines methods to
handle the event.
o Event Handler: The code that responds to the event, implemented in the listener.
 Action Events: Generated by components like JButton, JMenuItem, or JTextField when
a user performs an action (e.g., clicking a button or selecting a menu item). The
ActionListener interface, with its actionPerformed(ActionEvent e) method, is used to
handle these events.
Example:
import javax.swing.*;
import java.awt.event.*;

public class SwingDemo {

public SwingDemo() {
JFrame jframe = new JFrame("This is a simple JFrame App");
jframe.setSize(400, 300);
jframe.setLocationRelativeTo(null);
jframe.getContentPane().setLayout(null);
jframe.setVisible(true);

JLabel lbl1 = new JLabel("First Number:");

lbl1.setBounds(20, 10, 100, 10);
jframe.add(lbl1);
 JTextField txt1 = new JTextField();
txt1.setBounds(120, 10, 120, 20);
jframe.add(txt1);

JLabel lbl2 = new JLabel("Second Number:");

lbl2.setBounds(20, 50, 100, 10);
jframe.add(lbl2);
JTextField txt2 = new JTextField();
txt2.setBounds(120, 50, 120, 20);
jframe.add(txt2);

JLabel lbl3 = new JLabel("Result: ");

lbl3.setBounds(20, 80, 100, 30);
jframe.add(lbl3);

JButton btn = new JButton("Calculate");

btn.setBounds(100, 120, 100, 30);
jframe.add(btn);

// Adding ActionListener to the button

btn.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ae) {
String first = txt1.getText();
String second = txt2.getText();
int a = Integer.parseInt(first);
int b = Integer.parseInt(second);
int c = a + b;
lbl3.setText("Result: " + c);
}
});
}
 public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
new SwingDemo();
}
});
}
}

Result: 50