Mahavir Polytechnic, Nashik

(Year: 2024-2025)
Micro Project

Program: Information Technology

Semester: IF5I

Course: Advance Java Programming

Course Code: 220517

Title of the Project: Interactive Student Information Form

Members of the Group

Name: Shubham Gorakh Chaudhari Enrollment No: 23611220508

1
 Mahavir Polytechnic

Vision

We strive to educate students to become industry ready engineers having professional attitude and
groomed personality.

Mission

· To provide well defined system to ensure quality education by strengthening teaching learning
processes through innovative practices

· To provide a platform where students are exposed to the industry, up bridged with the industry
standards and requirements.

· To train students by teaching them leadership and teamwork skills.

· To groom students enriching their personality and social values

IT Department

Vision
IT Department strives to educate students to become Industry ready Engineers having Professional
attitude and groomed personality.

Mission
.To provides well defined system to ensure quality education by strengthening teaching learning
processes through innovative practices.

.To provides a platform where students are exposed to the Industry, up bridged with the industry
standards and requirements.

.To train students by teaching them leadership and teamwork skills.

.To groom students enriching their personality and social values.

2
 PART A
1.0 Brief Introduction

The Student Information Form is an interactive desktop application built using Java Swing and AWT
for the user interface, with JDBC (Java Database Connectivity) and MySQL for managing the backend
database. The project allows educational institutions to collect and manage detailed student records
efficiently. The form is divided into two sections: General Information and Residential Information,
providing a user-friendly interface to gather student data like name, contact details, birth date,
gender, and address. The design incorporates placeholders for input fields, which disappear when the
user clicks to enter information, enhancing usability. It also supports a multi-step form navigation with
"Next" and "Back" buttons for a smooth user experience. Upon completion, the entered data is saved
to a MySQL database, ensuring data persistence and easy retrieval. This project showcases the
effective integration of Java GUI elements with database management, making it a practical solution
for real-world applications in educational settings.

2.0 Aim/Benefits of the Micro – Project

The aim of this micro-project is to develop a Student Information Form that simplifies the process of
collecting and managing student data in educational institutions. By integrating Java Swing for the
user interface and JDBC with MySQL for the backend, the system ensures efficient data entry and
storage. The benefits include improving data accuracy, reducing paperwork, and making information
easily accessible for administrative purposes. Additionally, the project enhances the user experience
with a multi-step form and modern input field placeholders. Overall, it streamlines the student
registration process, saving time and resources for both staff and students.

3.0 Course Outcomes Addressed

CO1: Understand and apply core Java concepts – The project demonstrates proficiency in Java
programming by using Swing for creating GUI components and JDBC for database interaction.

CO2: Develop applications using event-driven programming – The project handles user inputs and
actions through event handling mechanisms such as button clicks and form validation.

CO3: Design and implement a database-driven application – By using JDBC and MySQL, the project
connects a Java-based form to a database for storing and retrieving student information.

CO4: Apply problem-solving skills to real-world scenarios – The project offers a practical solution for
managing student data, addressing common administrative needs in educational institutions.

CO5: Work on full-stack development – This project covers both front-end (Swing GUI) and back-end
(JDBC with MySQL) development, showcasing the integration of different layers of application
development.

3
4.0 Proposed Methodology
The Student Information Form project will begin by gathering and understanding the necessary
requirements for the form, such as student name, email, phone number, birthdate, gender, student
ID, and residential information. Next, the user interface will be designed using Java Swing, divided into
two panels: one for general information and the other for residential details. The layout will be
implemented using GridBagLayout to ensure a structured arrangement of form components.
ActionListeners will be added for event handling, enabling the navigation between panels with the
next, back, and submit buttons. JDBC will be used to connect the form to a MySQL database, allowing
the data to be stored and retrieved efficiently. SQL queries will manage database operations,
including inserting, updating, and fetching student details. Finally, thorough testing will be conducted
to ensure the form works correctly, and any issues will be debugged to maintain smooth functionality.

4
 Progress Report / Weekly Report
Week Duration Sign of the
Date Work / Activity Performed
No in Hrs. Faculty

1 1hr Topic Selection

2 1hr Finalizing Topic

3 1hr Information Search

4 1hr Program Execution

5 1hr Making Report

6 1hr Project Submission

5.0 Resources Required

Name Of
Sr. No Specifications Quantity Remarks
Resource/Material

1 Computer i-5, Windows 10 1

Sign of Course Teacher

5
 MICROPROJECT REPORT
1.0 Rationale

The Student Information Form project aims to simplify and digitalize the process of collecting and
managing student data. Traditional methods, such as paper forms, are prone to human error,
inefficient data storage, and retrieval issues. By creating a structured, interactive form using Java
Swing, the system becomes more user-friendly and efficient for both students and administrators. The
use of JDBC and MySQL ensures that the data is securely stored and easily accessible for future
reference. Furthermore, by breaking the form into steps (general and residential information), it
becomes more organized and intuitive for users to fill out. This project is particularly relevant in
educational institutions where efficient student record management is essential. In a broader sense, it
contributes to the move towards digital transformation in administrative processes.

2.0 Aim/Benefits of the Micro – Project

This Micro - Project aims at:

The primary aim of the Student Information Form micro-project is to develop an efficient, user-
friendly application for collecting and managing student information. This project enhances the
accuracy and reliability of student data by minimizing human errors associated with manual entry. The
implementation of a digital form allows for easy data retrieval, ensuring that administrators can
quickly access important student information when needed. Additionally, the project provides a
platform for students to enter their information in a structured format, simplifying the process for
them. By utilizing JDBC and MySQL, the system ensures secure storage and management of sensitive
data. This micro-project also offers students hands-on experience with Java Swing and database
management, enhancing their technical skills. Furthermore, it promotes the transition to digital
systems in educational institutions, improving overall operational efficiency. Ultimately, the project
serves as a practical example of how technology can streamline administrative processes in academic
settings.
COs addressed by the Micro Project:

Understanding of Java Programming Concepts: This project reinforces the

CO 1: foundational concepts of Java programming, particularly in the context of creating
graphical user interfaces (GUIs) using Java Swing.
Application of JDBC for Database Interaction: Students will gain practical experience
CO 2: in using Java Database Connectivity (JDBC) to connect, retrieve, and manipulate data
in a MySQL database, enhancing their understanding of database interactions.
Development of User-Centric Applications: The project focuses on designing user-
CO 3: friendly forms, emphasizing the importance of user experience in software
development, and fostering skills in creating intuitive interfaces.

6
 Implementation of Object-Oriented Programming (OOP) Principles: The project
CO 4: encourages the use of OOP principles, such as encapsulation, inheritance, and
polymorphism, to create a modular and maintainable codebase.
Problem-Solving and Analytical Skills: Students will develop critical problem-solving
and analytical skills by addressing challenges related to form validation, data
CO 5:
management, and user input handling throughout the project development process.

3.0 Literature Review

The literature on user interface design emphasizes the importance of creating intuitive and user-
friendly applications, particularly in educational settings. Various studies have shown that effective
GUI design can significantly enhance user satisfaction and increase the efficiency of data entry tasks.
Research by Shneiderman and Plaisant (2010) highlights the principles of usability that should be
followed during the design process, such as consistency, feedback, and error prevention. Additionally,
the integration of database management systems, like MySQL, with Java applications through JDBC
has been widely discussed in software engineering literature, demonstrating the effectiveness of this
approach for data handling. Numerous case studies illustrate the successful implementation of
student information systems using Java, emphasizing the need for robust data validation and user
authentication features. Furthermore, the significance of OOP principles in developing scalable and
maintainable software solutions has been extensively documented, encouraging developers to adopt
best practices in software design. This literature underscores the project's relevance, providing a
strong foundation for understanding the critical aspects of creating a Student Information Form using
Java Swing and MySQL.

4.0 Actual Methodology

The project begins with the design of the user interface using Java Swing, where panels are created to
collect general and residential information from students. The layout is implemented using
GridBagLayout, allowing for organized placement of input fields and labels. Each input field includes
placeholders to enhance user experience, ensuring that students understand the required data. Once
the user submits their information, the application connects to a MySQL database using JDBC to store
the collected data securely. Error handling is integrated to manage any potential issues during data
entry, such as invalid inputs or database connectivity problems. The application is tested thoroughly
to ensure all functionalities work as intended, including the navigation between panels and data
retrieval from the database. Finally, documentation is prepared to outline the design, implementation
process, and user instructions, ensuring that the application can be maintained and updated in the
future.

7
5.0 Actual Resources Used
The project utilizes Java as the primary programming language, leveraging its robust features for
building desktop applications. For the graphical user interface, Java Swing is employed, enabling the
creation of interactive panels and user-friendly forms. The MySQL database serves as the backend for
storing student information, allowing for efficient data management and retrieval. JDBC (Java
Database Connectivity) is utilized to facilitate the connection between the Java application and the
MySQL database, ensuring smooth data operations. Additionally, various software tools are used,
including an Integrated Development Environment (IDE) like Eclipse or IntelliJ IDEA for coding and
debugging. Documentation tools are also employed to create user manuals and project reports.
Finally, resources such as online tutorials and forums provide support for resolving technical
challenges encountered during the project development.

Sr. Name Of
Specifications Quantity Remarks
No Resource/Material

1
Computer i-5, Windows 10 1

2
JDK 21 1

3
JDBC V9 1

4
MySQL 8.0 1

8
6.0 Outputs of the Micro-Projects

1.Project Overview: The Student Information Form project is designed to create a comprehensive and
user-friendly application aimed at collecting and managing essential data regarding students. The
application will simplify the data entry process for both students and administrators, facilitating the
collection of vital information such as personal details, academic records, and contact information in a
structured format. The project consists of two interactive panels: the first for general information and
the second for residential information. This structured approach not only enhances user experience
but also ensures that the collected data is organized and easy to access. By addressing the challenges
of manual data entry and improving data accuracy, the application serves as a valuable tool for
educational institutions.

2.Technology Stack: The project leverages Java as its primary programming language due to its
portability, scalability, and robust object-oriented features. The graphical user interface (GUI) is
developed using Java Swing, which provides a rich set of components that facilitate the creation of
interactive forms and a smooth user experience. MySQL is employed as the database management
system, ensuring efficient data storage and retrieval, along with reliable performance. In addition,
JDBC (Java Database Connectivity) is utilized to establish a seamless connection between the Java
application and the MySQL database, allowing for effective data manipulation. This technology stack is
chosen for its reliability and ability to handle user input efficiently while ensuring a responsive
application.

3.Database Design: A well-structured MySQL database is essential for storing comprehensive student
information. The database schema includes various tables and fields to accommodate all necessary
information, such as student name, email, phone number, birth date, gender, student ID, entry year,
grade, semester, and residential details. Relationships among the tables are established to enable
efficient queries and data manipulation, making it easy to access and update student records.
Moreover, appropriate indexing is applied to enhance the performance of search queries, ensuring
quick retrieval of information. This thoughtful database design ensures that the application can scale
as the number of users and amount of data grows.

4.Setting Up the Development Environment: Setting up the development environment is a crucial

step in the project. It involves installing the Java Development Kit (JDK), which provides the necessary
tools for Java development, along with an Integrated Development Environment (IDE) such as Eclipse
or IntelliJ IDEA to streamline the coding process. Additionally, MySQL must be installed and configured
on the local machine to facilitate the creation and management of the database. Proper configuration
of the JDBC driver is vital, as it allows the Java application to communicate effectively with the MySQL
database. This setup forms the foundation of the project, enabling developers to build and test the
application in a controlled environment.

9
5.Implementing the GUI: With the development environment in place, the next step is to implement
the graphical user interface using Java Swing. The GUI design focuses on usability and accessibility,
ensuring that users can easily navigate through the application. The two panels are carefully
structured, with the first panel dedicated to general information and the second panel for residential
information. Each panel consists of various input fields, labels, and buttons, all designed to enhance
user interaction. Placeholder text is strategically added to the input fields, guiding users in entering
their data accurately. By prioritizing user experience, the GUI design contributes significantly to the
overall effectiveness of the application.

6.Handling User Input: Handling user input is a critical aspect of the application that ensures smooth
navigation and data collection. Event listeners are implemented to respond to user actions, such as
clicking buttons or entering data into fields. For example, clicking the "Next" button on the first panel
transitions the user to the residential information panel, while the "Back" button allows them to
return to the previous panel. The "Submit" button on the second panel captures all entered data and
initiates the process of storing it in the database. Validation checks are also incorporated to ensure
that all required fields are filled out correctly before submission. This comprehensive approach to
handling user input not only enhances usability but also improves data integrity.

7.Connecting to the Database: Establishing a connection to the MySQL database is a pivotal step in
the project. This involves writing code that utilizes JDBC to create a connection between the Java
application and the MySQL database. SQL queries are then executed to insert, update, or retrieve
student information based on user input. Error handling mechanisms are integrated to manage
potential database-related issues, such as connection failures or SQL syntax errors, ensuring that the
application can gracefully handle unexpected situations. By effectively connecting the application to
the database, the project ensures that data is accurately stored and easily retrievable, thereby
enhancing the application's functionality.

8.Testing the Application: Thorough testing is conducted to ensure that the application functions as
intended and meets user requirements. This includes unit testing for individual components,
integration testing to verify interactions between the GUI and database, and user acceptance testing
to gather feedback from potential users. Special attention is given to data validation, user navigation,
and database interactions to ensure reliability. Any issues identified during testing are promptly
addressed, leading to refinements in the code and user interface. User feedback is actively sought to
improve the overall experience, ensuring that the application not only meets technical standards but
also fulfills user needs effectively.

9.Documentation: Comprehensive documentation is created to serve as a guide for users and

developers alike. User manuals detail the features and functionalities of the application, providing
clear instructions on how to operate the form effectively. Technical documentation explains the code
structure, design decisions, and database schema, making it easier for future developers to
understand and maintain the application. This documentation serves as a valuable resource for
onboarding new team members and ensuring continuity in development efforts. By investing time in
thorough documentation, the project sets the stage for successful implementation and future
enhancements.
10
10.Deployment and Future Enhancements: Finally, the application is deployed for actual use within
educational institutions. Plans for future enhancements are developed based on user feedback and
evolving needs. Potential improvements may include adding features such as data export options to
various formats (CSV, PDF), enhanced validation processes for input fields, and a more sophisticated
user interface incorporating modern design elements. Additionally, the integration of security
measures, such as user authentication and data encryption, could further protect sensitive student
information. This project not only addresses immediate data collection needs but also lays the
groundwork for ongoing development and continuous improvement in student data management.

Source Code:

import javax.swing.*;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusEvent;

import java.awt.event.FocusListener;

public class StudentForm extends JFrame {

JPanel step1Panel, step2Panel;

CardLayout cardLayout;

JTextField firstNameField, middleNameField, lastNameField, emailField, phoneField, studentIDField,

entryYearField;

JComboBox<String> monthComboBox, dayComboBox, yearComboBox, genderComboBox, gradeComboBox,

semesterComboBox;

JTextField addressField, cityField, stateField, postalCodeField, countryField;

public StudentForm() {

setTitle("Student Information Form");

11
 setSize(600, 400); step1Panel.add(middleNameField, gbc);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
gbc.gridx = 2;
;
lastNameField = new JTextField(10);
cardLayout = new CardLayout();
addPlaceholder(lastNameField, "Enter Last
setLayout(cardLayout);
Name");

step1Panel.add(lastNameField, gbc);
step1Panel = new JPanel(new
GridBagLayout());
gbc.gridx = 0; gbc.gridy = 2;
GridBagConstraints gbc = new
GridBagConstraints(); step1Panel.add(new JLabel("Email"), gbc);
gbc.insets = new Insets(5, 5, 5, 5);

gbc.fill = GridBagConstraints.HORIZONTAL; gbc.gridx = 1;

step1Panel.add(new JLabel("Phone Number"),

gbc.gridx = 0; gbc.gridy = 0; gbc);

gbc.gridwidth = 3;

step1Panel.add(new JLabel("Student Name"), gbc.gridx = 0; gbc.gridy = 3;

gbc); emailField = new JTextField(20);

step1Panel.add(emailField, gbc);
gbc.gridwidth = 1;

gbc.gridx = 1;
gbc.gridx = 0; gbc.gridy = 1; phoneField = new JTextField(15);
firstNameField = new JTextField(10); step1Panel.add(phoneField, gbc);
addPlaceholder(firstNameField, "Enter First
Name");
gbc.gridx = 0; gbc.gridy = 4;
step1Panel.add(firstNameField, gbc);
step1Panel.add(new JLabel("Birth Date"), gbc);

gbc.gridx = 1;
String[] months = {"Month", "January",
middleNameField = new JTextField(10); "February", "March", "April", "May", "June", "July",
addPlaceholder(middleNameField, "Enter "August", "September", "October", "November",
"December"};
Middle Name");

12
 String[] days = {"Day", "1", "2", "3", "4", "5",
"6", "7", "8", "9", "10", "11", "12", "13", "14", "15",
gbc.gridx = 0; gbc.gridy = 8;
"16", "17", "18", "19", "20", "21", "22", "23", "24",
"25", "26", "27", "28", "29", "30", "31"}; step1Panel.add(new JLabel("Student ID"), gbc);
String[] years = {"Year", "2024", "2023",
"2022", "2021", "2020"};
gbc.gridx = 1;

step1Panel.add(new JLabel("Entry Year"), gbc);

monthComboBox = new
JComboBox<>(months);

dayComboBox = new JComboBox<>(days); gbc.gridx = 0; gbc.gridy = 9;

yearComboBox = new JComboBox<>(years); studentIDField = new JTextField(10);

step1Panel.add(studentIDField, gbc);

gbc.gridx = 0; gbc.gridy = 5;

step1Panel.add(monthComboBox, gbc); gbc.gridx = 1;

entryYearField = new JTextField(5);

gbc.gridx = 1; step1Panel.add(entryYearField, gbc);

step1Panel.add(dayComboBox, gbc);

gbc.gridx = 0; gbc.gridy = 10;

gbc.gridx = 2; step1Panel.add(new JLabel("Grade"), gbc);

step1Panel.add(yearComboBox, gbc);

gbc.gridx = 1;

gbc.gridx = 0; gbc.gridy = 6; step1Panel.add(new JLabel("Semester"), gbc);

step1Panel.add(new JLabel("Gender"), gbc);

String[] grades = {"Please Select", "A", "B", "C",

"D", "F"};
gbc.gridx = 0; gbc.gridy = 7;
String[] semesters = {"Please Select", "1", "2",
gbc.gridwidth = 1; "3", "4", "5", "6", "7", "8"};
String[] genders = {"Please Select", "Male",
"Female", "Other"};
gradeComboBox = new JComboBox<>(grades);
genderComboBox = new
JComboBox<>(genders); semesterComboBox = new
JComboBox<>(semesters);
step1Panel.add(genderComboBox, gbc);

13
 step2Panel.add(addressField, gbc);

gbc.gridx = 0; gbc.gridy = 11;

step1Panel.add(gradeComboBox, gbc); gbc.gridx = 0; gbc.gridy = 3;

step2Panel.add(new JLabel("City"), gbc);

gbc.gridx = 1;

step1Panel.add(semesterComboBox, gbc); gbc.gridx = 0; gbc.gridy = 4;

cityField = new JTextField(15);

JButton nextButton = new JButton("Next"); step2Panel.add(cityField, gbc);

gbc.gridx = 2; gbc.gridy = 12;

step1Panel.add(nextButton, gbc); gbc.gridx = 0; gbc.gridy = 5;

step2Panel.add(new JLabel("State"), gbc);

step2Panel = new JPanel(new

GridBagLayout());
gbc.gridx = 0; gbc.gridy = 6;

stateField = new JTextField(15);

gbc.gridx = 0; gbc.gridy = 0;
step2Panel.add(stateField, gbc);
gbc.gridwidth = 2;

JLabel residentialInfoLabel = new

JLabel("Residential Information"); gbc.gridx = 0; gbc.gridy = 7;

residentialInfoLabel.setFont(new Font("Arial", step2Panel.add(new JLabel("Postal Code"),

gbc);
Font.BOLD, 14));

step2Panel.add(residentialInfoLabel, gbc);
gbc.gridx = 0; gbc.gridy = 8;

postalCodeField = new JTextField(10);

gbc.gridwidth = 1;
step2Panel.add(postalCodeField, gbc);

gbc.gridx = 0; gbc.gridy = 1;
gbc.gridx = 0; gbc.gridy = 9;
step2Panel.add(new JLabel("Address"), gbc);
step2Panel.add(new JLabel("Country"), gbc);

gbc.gridx = 0; gbc.gridy = 2;

addressField = new JTextField(20); gbc.gridx = 0; gbc.gridy = 10;

14
 countryField = new JTextField(15); cardLayout.show(getContentPane(), "Step
1");
step2Panel.add(countryField, gbc);
}

});
JButton backButton = new JButton("Back");

JButton submitButton = new

JButton("Submit"); submitButton.addActionListener(new
ActionListener() {

@Override
gbc.gridx = 0; gbc.gridy = 11;
public void actionPerformed(ActionEvent e) {
step2Panel.add(backButton, gbc);
JOptionPane.showMessageDialog(null,
"Form submitted successfully!");
gbc.gridx = 1;
}
step2Panel.add(submitButton, gbc);
});

add(step1Panel, "Step 1");

setVisible(true);
add(step2Panel, "Step 2");
}

nextButton.addActionListener(new
private void addPlaceholder(JTextField textField,
ActionListener() { String placeholder) {
@Override textField.setText(placeholder);
public void actionPerformed(ActionEvent e) { textField.setForeground(Color.GRAY);
cardLayout.show(getContentPane(), "Step
2");
textField.addFocusListener(new
} FocusListener() {
}); @Override

public void focusGained(FocusEvent e) {

backButton.addActionListener(new if (textField.getText().equals(placeholder))
ActionListener() {
{
@Override textField.setText("");
public void actionPerformed(ActionEvent e) { textField.setForeground(Color.BLACK);

15
 }

} }

@Override public static void main(String[] args) {

public void focusLost(FocusEvent e) { new StudentForm();

if (textField.getText().isEmpty()) { }

textField.setText(placeholder); }

textField.setForeground(Color.GRAY);

});

16
Outputs:

Panel 1: General Information

Panel 2: Residential Information

17
 Teacher Evaluation Sheet for Micro Project

Rubrics for Assessment of Micro-Project

Poor Average Good Excellent

Characteristic to be
Sr. No
Assessed (Marks 1-3) (Marks 4-5) (Marks 6-8) (Marks 9-10)

1. Relevance to course

2. Literature survey

3. Project proposal

4. Completion of target
Analysis &
5.
representationof data
Quality of
6.
Prototype/Model
7. Report preparation

8. Presentation

9. Defense
Marks:-

Marks obtained
Marks for by the Total
Enrollment
Name Of Student Group Work individual Marks
No.
(06) based on viva (10)
(04)
23611220508 Shubham Chaudhari

Name and designation of Faculty Member_______________________________________

Signature: ________________________________________________

18
 Maharashtra State Board of Technical Education, Mumbai

CERTIFICATE

This is to certify that Mr. Shubham Gorakh Chaudhari Roll No. 48 of 5th semester of

Diploma in Information Technology of Mahavir Polytechnic has completed the

Micro Project satisfactorily in course Advance Java Programming (22517) for the

academic year 2024-2025 as prescribed in the curriculum.

Place: Nashik Enrolment No: 23611220508

Date _______________ Exam Seat No _______________________

Course Coordinator HOD Principal

Institute Seal

19