Course Title

Java II: Desktop and Web Application Development

Course Introduction
Welcome to Java II: Desktop and Web Application Development.

This course is designed for students who have successfully completed Core Java and are
ready to advance toward building real-world software applications. In Java II, the focus shifts
from learning the Java language itself to applying Java as a powerful development platform.

Throughout this course, students will explore how Java is used to develop desktop
applications using graphical user interface frameworks and web applications using modern
enterprise technologies. Emphasis is placed on practical development skills, application
structure, and industry-relevant tools.

Students will gain hands-on experience with:

➔​ Java desktop application development using Swing and JavaFX​

➔​ Event-driven programming and user interface design​

➔​ Database interaction and data persistence​

➔​ Java web technologies and frameworks​

➔​ Development environments and project structuring​

By the end of this course, students will be able to design, implement, and deploy functional
Java desktop and web applications, preparing them for advanced studies, professional
software development, and real-world programming projects.

This course bridges the gap between programming fundamentals and application-level
development, enabling students to transform theoretical knowledge into practical solutions.
Chapter 1: Java Application Development Overview (Java II)
Java is a mature, object-oriented programming language originally developed by Sun
Microsystems and now maintained by Oracle. After mastering Core Java concepts such as
syntax, control structures, object-oriented programming, and exception handling, the next step

is to understand how Java is applied in real-world software systems. Java II focuses on using
Java as a platform for building desktop applications and web-based enterprise systems.

Java’s strength lies in its platform independence, achieved through the Java Virtual Machine
(JVM). Programs compiled into bytecode can execute on any operating system with a
compatible JVM, enabling Java applications to scale across diverse environments such as
desktops, servers, and cloud platforms.

Java Runtime Architecture and Memory Management

Java applications run inside the Java Virtual Machine (JVM), which abstracts hardware and
operating system differences. Memory allocation and deallocation are handled automatically
through Java’s garbage collection mechanism, eliminating manual memory management and
reducing common issues such as memory leaks and dangling pointers.

The JVM manages:

●​ Heap memory for object storage​

●​ Stack memory for method execution​

●​ Garbage collection for reclaiming unused objects​

Understanding this runtime behavior is essential when developing long-running desktop

applications and high-load web applications.

Java Development Platform

Java application development relies on two core components:

Java Development Kit (JDK)

The JDK provides the complete toolset required for Java application development. It includes
the Java compiler, debugging tools, and runtime libraries. Developers use the JDK to write,
compile, test, and package Java applications.
Java Runtime Environment (JRE)

The JRE supplies the JVM and standard libraries required to execute Java applications. It is
intended for deployment environments where applications are run but not developed.

In Java II, students primarily work with the JDK while targeting environments that rely on the
JRE for execution.

Java Desktop Application Frameworks

Java supports multiple frameworks for building desktop-based graphical user interfaces (GUIs).
These frameworks abstract low-level system interactions and provide reusable components for
building interactive applications.

Abstract Window Toolkit (AWT)

AWT is Java’s original GUI framework and relies on native operating system components.
Because it delegates rendering to the host system, AWT components are considered
heavyweight and platform-dependent. While performant, AWT is rarely used in modern
applications due to inconsistent appearance across platforms.

Swing

Swing is a lightweight GUI framework built entirely in Java and part of the Java Foundation
Classes (JFC). It offers a comprehensive set of components such as tables, trees, lists, and
menus, enabling the development of complex desktop applications with a consistent look and
feel across platforms. Swing remains widely used in enterprise desktop software.

JavaFX

JavaFX is the modern Java GUI framework designed for rich client applications. It supports
CSS-based styling, animations, multimedia integration, and hardware-accelerated graphics.
JavaFX is suitable for building visually rich, responsive desktop applications and represents the
preferred choice for new Java desktop development.
Role of Java in Desktop Application Development
Java desktop frameworks provide structured, event-driven programming models that simplify
user interface design and interaction handling. By separating application logic from
presentation, developers can build maintainable, scalable desktop applications that run
consistently across operating systems.

In Java II, students move beyond simple components and focus on layout management, event
handling, application lifecycle management, and UI customization.

Java Web Application Frameworks

In addition to desktop applications, Java is extensively used in server-side and enterprise web
development. Java web frameworks support the creation of scalable, secure, and data-driven
web applications.

Spring Framework

Spring is a comprehensive framework for enterprise Java development. It provides dependency

injection, aspect-oriented programming, transaction management, and web application support
through Spring MVC. Spring simplifies application configuration and promotes clean architecture
through layered design.

Hibernate

Hibernate is an Object-Relational Mapping (ORM) framework that enables Java applications to

interact with relational databases using object-oriented principles. It abstracts SQL operations,
manages entity relationships, and simplifies database persistence, making it a core component
of modern Java web applications.

Jakarta EE

Jakarta EE provides a standardized enterprise platform for building large-scale, distributed

applications. It includes APIs such as Servlets, JavaServer Pages (JSP), and JavaServer Faces
(JSF), which are foundational technologies in Java web development.
Role of Java in Web Application Development
Java web frameworks enable the development of dynamic and secure web applications by
providing built-in support for authentication, session management, database integration, and
application scalability. These frameworks are commonly used in enterprise environments where
reliability and maintainability are critical.

Java II emphasizes understanding how desktop and web technologies fit together within Java’s
ecosystem.

Development Environment Setup

To develop Java desktop and web applications, a properly configured development environment
is required. This includes installing a supported JDK and an Integrated Development
Environment (IDE).

In this course, NetBeans IDE is used due to its strong support for Java SE, Swing, JavaFX, and
web technologies, as well as its visual GUI builder.

Installing the Java Development Kit

JDK 17 (or later LTS version) is recommended for Java II. After installation, environment
variables such as JAVA_HOME and system PATH must be configured to enable compiler and
runtime access from the command line.

Installation verification is performed using:

●​ java -version​

●​ javac -version​
Creating Your First Java GUI Project in NetBeans
In Java programming, especially when dealing with graphical user interfaces (GUIs) using the
Swing library, JFrame, JPanel, and JLabel are fundamental components that serve distinct
roles:

JFrame
In Java programming, a JFrame is the main container that holds the components of your
application's interface. When you start building an app, you create a JFrame to serve as the
primary window.

JPanel
A JPanel is used within a JFrame to organize the layout of smaller components like buttons,
labels, and text fields. You can think of it as a panel in your app where you group related items
together.

JLabel
A JLabel is used in Java Swing to display text or an image on the interface. It's a simple way to
add information or labels within your GUI.

Creating your first Java project with a JFrame, JLabel, and JPanel in an Integrated
Development Environment (IDE) like NetBeans involves a few straightforward steps. Here’s a
detailed guide to help you start with a simple GUI (Graphical User Interface) application.

How To Create Your First Java GUI Project in NetBeans

1)​ Open NetBeans IDE:

a)​ Start NetBeans.
b)​ Navigate to File > New Project.
2)​ Set Up the Project:
a)​ Choose Java with Ant or Java with Maven from the Categories and Java
Application from the Projects list, then click Next.

b)​ Enter a name for your project, such as MyFirstGUIApp.

c)​ Specify the project location if the default isn’t suitable.
d)​ Make sure the option Create Main Class is unchecked.
e)​ Click Finish.
3)​ Create a JFrame:
a)​ Right-click on the Source Packages in your project tree.
b)​ Select New > JFrame Form.

c)​ Name your JFrame, for example, MainApplicationFrame, and define the
package, then click Finish.

d)​ This will open a visual designer where you can drag and drop GUI components.
4)​ Design the JFrame:
a)​ Drag and drop a JPanel from the palette into the JFrame window that appeared
in the designer view. This panel will serve as a container for other components.
b)​ Drag and drop a JLabel onto the JPanel you just placed in the JFrame.
c)​ Using the properties window (usually found at the bottom right of the IDE),
change the text of the JLabel to something like "Hello, World!"

5)​ Customize JFrame Properties:

a)​ In the properties window, set the title of the JFrame by changing the title
property.
b)​ Ensure the default close operation is set to EXIT_ON_CLOSE, making sure your
application stops running when you close the window.
 6)​ Run Your Project:
a)​ Click the Run button in the toolbar (looks like a play symbol) or right-click the
project and select Run.
b)​ This compiles the code and runs your application, displaying the JFrame with a
JPanel containing a JLabel.

Customizing GUI: Colors and Fonts

After setting up your Java GUI with basic components in NetBeans, the next step is to
personalize the appearance of your JFrame, JPanel, and JLabel to make the interface more
visually appealing and user-friendly. Customizing colors and fonts is a straightforward process
that can significantly impact the look and feel of your application.

Customizing Colors
Colors in your GUI can be set to align with your application's theme or to make certain elements
stand out. Here’s how you can modify the colors of your JFrame, JPanel, and JLabel:

1)​ JFrame Background Color:

a)​ Click on your JFrame in the design view.
b)​ In the properties window, find the ‘background’ property.
c)​ Click on the color picker next to the property and choose a color that suits your
application's theme.
 2)​ JPanel Background Color:
a)​ Select the JPanel within your JFrame.
b)​ Access the ‘background’ property in the properties window.
c)​ Use the color picker to select a different color that complements or contrasts with
the JFrame color, depending on the desired effect.
3)​ JLabel Text Color:
a)​ Click on the JLabel.
b)​ Locate the ‘foreground’ property in the properties window, which changes the
color of the text.
c)​ Choose a color that ensures good readability against the JPanel’s background.

Customizing Fonts

Changing the font type, size, and style can enhance the readability in your GUI. Here's how to
customize the font settings for your JLabel, which can also be applied to other text-containing
components:

1)​ JLabel Font Customization:

a)​ Select the JLabel in the design view.
b)​ In the properties window, find the ‘font’ property.
c)​ Click on the ellipsis (…) to open the font customization dialog.
d)​ Choose the desired font family, style, and size. For instance, you might select a
bold style to make the JLabel text stand out more prominently.