COURSE CODE & NAME DCA2202 – PROGRAMNING IN JAVA

SEMESTER IV

PROGRAM BCA

ROLL NO. 2114501437

NAME OM AGARWAL
 (Q1) (a) Explain any five features of Java.
(Answer)
five features of Java

1. Platform Independence: The "Write Once, Run Anywhere" idea of Java enables
developers to create code on one platform and run it on others without change. The
Java Virtual Machine (JVM) does this by interpreting Java bytecode and maintaining
compatibility across multiple operating systems.

2. Object-Oriented: Java is a completely object-oriented language that follows OOP

concepts. It promotes modular and reusable code by utilizing ideas like as classes,
objects, inheritance, encapsulation, and polymorphism, hence improving code
structure and maintainability.

3. Automatic Memory Management (Garbage Collection): Java uses a garbage

collection technology to implement automatic memory management. It detects and
reclaims memory used by objects that are no longer in use, lowering the risk of
memory leaks and making memory management easier for developers.

4. Multithreading and Dynamic: Java is more dynamic than C and C++. It is capable
of adapting to its changing surroundings. It enables programmers to link new class
libraries, objects, and methods dynamically. Java applications can contain a
substantial quantity of run-time information that can be used to resolve object
accesses.
Java allows for multithreading programming. It employs several threads to run
various sections of the same application in simultaneously. The multithreading
functionality enables programmers to create programs that can do numerous tasks at
the same time. It optimizes CPU and main memory use since the program does not
have to complete one job before beginning the next.

5. Security and Robustness: Java places a premium on security and robustness. To

protect programs from dangerous code, it employs bytecode verification, runtime
security checks, and a security manager. Furthermore, Java's powerful exception
management framework allows for the identification and graceful treatment of
problems, which improves program stability.

(Q1) (b) What is Bytecode? Explain in brief.

(Answer)
Bytecode
Bytecode is a sort of computer code that is used in programming and software development.
It is a low-level program representation that is intended to be run by a virtual machine or
interpreter.

Simply said, bytecode is an intermediate code that is created from a program's source code. It
is not directly run by the hardware of the computer, but rather by a software component
known as a virtual machine. The bytecode instructions are interpreted and executed by this
virtual computer.

Bytecode is also frequently used in just-in-time (JIT) compilation, in which bytecode is

dynamically transformed into machine code during runtime to increase efficiency. This
provides for a compromise between bytecode portability and machine code execution
performance.

Bytecode Advantages
1. Portability: Because bytecode is platform-independent, software applications can
execute on multiple computer systems without being recompiled.

2. Distribution: Bytecode simplifies the distribution of software programs across

operating systems and hardware architectures.

3. Just-in-time Compilation: For enhanced efficiency, bytecode is frequently utilized in

just-in-time (JIT) compilation, where it is dynamically transformed into machine code
during runtime

4. Efficiency: By allowing the efficient execution of software programs, Bytecode

achieves a balance between portability and efficiency.

Overall, bytecode is important in modern software development because it provides an

intermediate representation of a program that may be run on several systems. It supports just-
in-time compilation and adds to the efficient execution of software programs.

(Q2) How do you implement inheritance in Java?

(Answer)

In Java, inheritance is a technique that allows one class to inherit attributes and methods from
another.
When a class extends another class, it inherits all of the superclass's public and protected
properties and methods. This allows for replication of code while also promoting a sense of
hierarchy in object-oriented programming.

The base class (parent class): it provides the data members and methods in the application.
A base class is often referred to as a parent class or a superclass.

Derived Class (Child Class): A subclass is often referred to as a child class or Subclass. The
derived class inherits all of the base class's members and member functions. The derived
class could offer more capabilities than the Base class and may have easier access to the Base
class.

To inherit the parent class, a child class must contain the term "extends." The term "extends"
tells the compiler that the child class derives its parent class's functions and members.

Here's an example of implementing inheritance in Java:

public class Animal {

protected String name;
public Animal(String name) {
this.name = name;
}
public void eat() {
 System.out.println(name + " is eating.");
}
}

public class Dog extends Animal {

public Dog(String name) {
super(name);
}
public void bark() {
System.out.println(name + " is barking.");
}
}

public class Main {

public static void main(String[] args) {
Dog dog = new Dog("Buddy");
dog.eat();
dog.bark();
}
}

In this case, the 'Dog' class extends the 'Animal' class. The 'Dog' class inherits the 'name' field
and the 'eat()' function from the 'Animal' class. It also defines its own function, 'bark()'.
When you create an instance of the 'Dog' class, you may use both the inherited 'eat()' function
and the unique 'bark()' method.

But, Why do we need of Inheritance? The following are the two primary reasons why we
require inheritance:

1. Code Reusability: Subclasses can inherit attributes and methods from their
superclasses, increasing code reuse. This eliminates the need to rewrite common
functionality across classes.
2. Code Extensibility: Subclasses can expand their superclass's functionality by
introducing new methods or overriding existing ones. This allows for class
customisation and specialization without altering the original code.
3. Polymorphism: Polymorphism is enabled through inheritance, which allows objects
from various subclasses to be viewed as objects from their superclass. This
encourages code design flexibility and modularity.
4. Method Overriding: Subclasses can offer their own implementation by overriding
methods inherited from their superclass. This enables for behavior to be tailored to the
needs of the subclass.
5. Code Organization: Inheritance aids in code organization by establishing a
hierarchical structure of related classes. This improves the readability and
maintainability of the code.

(Q3) What are the different methods under DataInputStream and DataOutputStream?
(Answer)

DataInputStream
In Java, the DataInputStream class allows you to read primitive data types from an input
stream. It has methods for reading many sorts of data, including integers, floating-point
numbers, booleans, and texts.
'DataInputStream' is a handy Java class for reading binary data or specified data types from
an input stream in a convenient manner. It is widely used in circumstances where binary data
must be processed, such as reading serialized objects or parsing network protocols.

Using 'DataInputStream' has the benefit of providing methods for reading various sorts of
data, such as'readInt' for reading integers,'readFloat' for reading floating-point
numbers,'readBoolean' for reading booleans, and'readUTF' for reading texts encoded in UTF-
8 format. This allows you to handle diverse data kinds without having to manually parse the
byte stream.

Methods of DataInputStream:
• readBoolean(): Reads a boolean value from the input stream.
• readByte(): Reads a byte value from the input stream.
• readChar(): Reads a char value from the input stream.
• readDouble(): Reads a double value from the input stream.
• readFloat(): Reads a float value from the input stream.
• readFully(byte[] b): Reads bytes from the input stream and stores them into the byte
array b.
• readInt(): Reads an int value from the input stream.
• readLine(): Reads a line of text from the input stream.
• readLong(): Reads a long value from the input stream.
• readShort(): Reads a short value from the input stream.
• readUTF(): Reads a string encoded in UTF-8 format from the input stream.
• skipBytes(int n): Skips n bytes from the input stream.

DataOutputStream

In Java, the DataOutputStream class allows you to write primitive data types to an output
stream. It has methods for writing several forms of data, including integers, floating-point
numbers, booleans, and strings.

'DataOutputStream' is a handy Java class for publishing binary data or specified data types to
an output stream in a convenient manner. It is widely used in contexts where binary data must
be stored, such as serializing objects or developing network protocols.

The fact that 'DataOutputStream' has methods for writing several sorts of data, such as
'writeInt' for writing integers, 'writeFloat' for writing floating-point numbers, 'writeBoolean'
for writing booleans, and 'writeUTF' for writing texts encoded in UTF-8 format, is one
advantage. This makes it easy to work with multiple data formats without having to explicitly
convert them to bytes.

Methods of DataOutputStream:
• writeBoolean(boolean v): Writes a boolean value to the output stream.
• writeByte(int v): Writes a byte value to the output stream.
• writeChar(int v): Writes a char value to the output stream.
• writeDouble(double v): Writes a double value to the output stream.
 • writeFloat(float v): Writes a float value to the output stream.
• writeInt(int v): Writes an int value to the output stream.
• writeLong(long v): Writes a long value to the output stream.
• writeShort(int v): Writes a short value to the output stream.
• writeUTF(String str): Writes a string encoded in UTF-8 format to the output stream.

(Q4) (a) How to use assertion in Java?

(Answer)

In the Java programming language, an assertion is a statement that allows you to verify your
program's assumptions. For example, if you develop a method that estimates a particle's
speed, you may claim that the determined speed is less than the speed of light.

Each assertion includes a boolean expression that you expect to be true when the assertion is
executed. If it is false, the system will generate an error. The assertion supports your
assumptions about the behavior of your program by checking that the boolean expression is
actually true, boosting your confidence that the program is error-free.

To utilize assertions in Java, use the assert keyword followed by a boolean expression. If the
boolean expression evaluates to false, an AssertionError is thrown.

Here is an example of how to use assertions in Java:

public class Example {

public static void main(String[] args) {
int age = 18;

// Assert that the age is greater than or equal to 18

assert age >= 18 : "Age must be 18 or older";

// Rest of the code

System.out.println("You are eligible to vote!");
}
}

In this example, we have an age variable that reflects the age of a person. The assertion age
>= 18 determines whether or not the age is higher than or equal to 18. If the assertion fails
(the age is less than 18), an AssertionError with the provided error message is thrown.

During development and testing, assertions can be used to detect programming mistakes,
check assumptions, and offer feedback when unexpected situations arise.

(Q4) (b) What is Autoboxing and Unboxing in Java?

(Answer)

Autoboxing
Autoboxing is a Java feature that enables for the automated conversion of primitive data
types and their appropriate wrapper classes. It makes converting between primitive types and
their object representations easier by removing the requirement for explicit conversion code.

In Java, primitive data types like int, double, boolean, and so on have equivalent wrapper
classes like Integer, Double, Boolean, and so on. When necessary, autoboxing converts a
primitive type to its equivalent wrapper class, while unpacking converts the wrapper class
back to the primitive type.

When working with primitive types and their wrapper classes, autoboxing and unpacking
provide additional flexibility and ease. They reduce the need for manual conversion code and
improve the readability of the code.

It's crucial to remember that autoboxing and unpacking have a performance penalty because
they require the generation of new objects.

Unboxing
Unboxing is the process of turning a wrapper class object back to its equivalent primitive
value. It is the inverse procedure of autoboxing.

When a primitive value is assigned to a wrapper class object in Java, autoboxing happens,
and the primitive value is automatically wrapped in the wrapper class object. Unboxing, on
the other hand, occurs when the value held in the wrapper class object is removed and
transformed back to its original primitive type.

Unboxing allows you to interact with primitive values even if they were previously wrapped
in a wrapper class object. It enables easy switching between primitive types and their
respective wrapper classes.

(Q5) Draw and explain the JDBC Application Architecture?

(Answer)
JDBC Application Architecture

Java has remained a popular programming language in nearly all computer science domains,
including web development, software development, databases, and so on. It controls a larger
portion of the IT sector. JDBC (Java Database Connectivity) is a well-known Java API. It
provides a natural Java interface for SQL work. JDBC is required to provide a "pure Java"
option for application development.

The Java API handles connecting to a database, running queries and instructions, and
processing database result sets. To access spreadsheets and databases, JDBC and database
drivers collaborate. JDBC's design describes the components utilized to connect to the
database. To send a request to a specific database, an application can utilize the JDBC API
classes and interfaces.

JDBC Architecture may be classified into two types: two-tier architecture, and three-tier
architecture.

two-tier architecture

In the two-tier model, a Java applet or program interfaces directly with the data source. This
needs the usage of a JDBC driver capable of interacting with the data source under
consideration. The user's instructions are sent to the database or other data source, and the
results of the statements are provided to the user. The data source might be located on another
computer to which the user has a network connection. A client/server setup occurs when the
user's workstation serves as the client and the system that holds the data source serves as the
server.

three-tier architecture

In the three-tier model, commands are transmitted to a "middle tier" of services, which then
sends the commands to the data source. The data source analyzes the commands and sends
the results to the intermediate tier, which then forwards them to the user. MIS directors like
the three-tier design because the intermediate tier allows them to keep control over access and
the sorts of modifications that may be made to corporate data.

JDBC components that help you interface with a database. The JDBC components are as
follows:

• JDBC Driver Manager: The Driver Manager loads database-specific drivers in a

JDBC application. This driver manager connects to a database. It also performs a
database-specific call to the database to handle the user request.

• Driver Manager: A driver is a software interface that handles database server

connectivity. DriverManager objects are used for communication.
 • JDBC-ODBC Bridge Drivers: These drivers connect database drivers to databases.
The bridge converts JDBC method calls into ODBC method calls. The sun.jdbc.odbc
package, which provides the native library, is used to access the ODBC (Open
Database Connectivity) features.

• JDBC API: Sun Microsystems has offered the JDBC API, which allows you to
develop a Java program that communicates with any database. The JDBC Driver
implements the JDBC API.

• JDBC Test Suite: The JDBC Test Suite is used to test JDBC Driver actions such as
inserting, deleting, and updating. It helps to determine whether the JDBC Drivers will
run the program. It assures that JDBC Drivers will run the application with confidence
and conformance.

• Database Server: The database server with which the JDBC client wishes to
communicate, for example, Oracle, MySQL, SQL Server, and so on.

• Statement: You utilize objects generated with this interface to communicate SQL
statements to the database. Certainly, derived interfaces take parameters in addition to
performing stored processes.

• RuleSet: When you use Statement objects to perform a SQL query, these objects
preserve data acquired from a database. It acts as an iterator, letting you to cycle over
the data contained within it.

(Q6) What are the important steps required to create a JavaFX FXML Application?
(Answer)

JavaFX FXML program is a sort of Java program that creates graphical user interfaces
(GUIs) using the JavaFX framework and FXML (FXML is an XML-based language for
defining the user interface of a JavaFX application). It enables developers to separate the user
interface design and layout from the application logic, making the development process more
modular and manageable.

The user interface in JavaFX FXML Application is defined using FXML files, which employ
XML syntax to describe the structure and look of the GUI. These FXML files may be written
and updated in a text editor or using tools like Scene Builder.

The application logic is built as Java classes that interface with the FXML files, including
event handling and business logic. These Java classes establish the user interface components'
functionality and manage user interactions.

JavaFX FXML Application has a comprehensive range of UI controls, layouts, and style
choices that enable developers to construct visually beautiful and interactive applications. It
also includes CSS capabilities for customizing the user interface components.

Developing a JavaFX FXML application entails numerous critical processes, such as creating
a user interface (UI) utilizing FXML and Java code, developing application business logic,
and testing.
1. Set Up Your Development Environment: Make sure Java and JavaFX are both
installed. Use an Integrated Development Environment (IDE) with JavaFX support,
such as Eclipse or IntelliJ IDEA.

2. Create a New JavaFX Project: In your IDE, create a new JavaFX project and
populate it with the required libraries.

3. Design the user interface: To design the user interface, utilize Scene Builder, a
visual layout tool for FXML, or manually construct an FXML file. Drag and drop UI
components into the canvas, such as buttons, labels, and text fields.

4. FXML Document Structure: Using XML tags, specify the structure of your UI in
your FXML file. Each UI element corresponds to a different JavaFX class and is
assigned an ID for subsequent use in code.
5. Controller Class: Create a Java controller class that matches to your FXML file. This
class should extend 'javafx.fxml.Initializable' and have methods that correspond to the
'fx:id' properties in your FXML file.

6. FXML Loading: In your Java code, load the FXML file and attach it to the controller
using the 'FXMLLoader' class.

7. Implement the application logic: Once the UI has been designed and connected to
the Java code, we can begin developing the application logic. This includes
developing Java code to handle user interactions, establish event handlers, and
implement your application's business logic. We can utilize the JavaFX API to control
UI components and respond to user actions. This separation of responsibilities enables
for greater management and upkeep of your system.

8. Running the Application: Run your JavaFX application, and the UI you designed in
FXML should appear with functionality controlled by your Java code.

9. Testing and Debugging: Test your application thoroughly, and use your IDE's
debugging tools to identify and fix any issues.

10. Deployment: Once your JavaFX FXML application is complete and tested, package
it for deployment. You can create executable JAR files or installers depending on your
target platform.