INTERNSHIP REPORT

A report submitted in partial fulfilment of the requirements for the Award of

Degree of

BACHELOR OF ENGINEERING
in
COMPUTER SCIENCE AND ENGINEERING

Submitted by

LIBIN RC ( 961421104039 )

Prowhiz , Chennai.

( Duration: 22nd July, 2024 to 22nd August, 2024 )

MAR EPHRAEM COLLEGE OF ENGINEERING AND

TECHNOLOGY
ANNA UNIVERSITY: CHENNAI 600 025

DECEMBER 2024

ANNA UNIVERSITY: CHENNAI 600 025

 BONAFIDE CERTIFICATE

Certified that the “ Internship report ” submitted by “LIBIN RC

( 961421104039 )” , is work done by him and submitted during 2024 – 2025
academic year, in partial fulfilment of the requirements for the award of the
degree of BACHELOR OF ENGINEERING in COMPUTER SCIENCE
AND ENGINEERING, at Prowhiz, Chennai.

Internship Coordinator Head of the Department

University examination held on

Internal Examiner External Examiner

INTERNSHIP CERTIFICATE
 COMPANY PROFILE

Prowhiz is a dynamic and innovative professional training and coaching platform

established in 2019, dedicated to empowering young talent and preparing them for
successful careers. With a focus on bridging the gap between academic learning and
real-world corporate demands, Prowhiz offers comprehensive training programs
designed to enhance both technical and soft skills. The platform also provides
efficient job placement solutions, ensuring that graduates and young professionals
are not only skilled but also ready to excel in the workforce.

Through specialized programs, Prowhiz trains individuals in a wide array of

technical fields such as programming languages (including Java, Python, and web
development), while simultaneously focusing on critical soft skills like
communication, teamwork, and professional conduct. This holistic approach
prepares participants to meet the challenges of the modern job market.

The company is led by Monica Paul, the CEO and Founder, who also heads
placement operations. With a deep passion for nurturing talent, Monica has made it
her mission to ensure that each participant is equipped with the right skills and
knowledge to thrive in their chosen careers. Prowhiz’s commitment to excellence,
innovation, and integrity continues to help it make a significant impact on the
professional journey of young individuals.
 ABSTRACT

The One-Month Java Training Program conducted by Prowhiz was an intensive

and immersive learning experience designed to equip participants with in-depth
knowledge and practical skills in Java programming. The program commenced with
foundational topics, including Java syntax, data types, operators, control structures,
and loops, ensuring that participants built a solid base in programming essentials. As
the training progressed, it delved into Core Java concepts, such as object-oriented
programming (OOP), encompassing principles like encapsulation, inheritance,
polymorphism, and abstraction. Participants were also trained in exception handling
and file management, critical components for developing robust and efficient Java
applications.

A significant portion of the program focused on Data Structures and Algorithms

(DSA), introducing participants to the fundamentals of arrays and various sorting
techniques, including Bubble Sort, Selection Sort, and Insertion Sort. These sessions
emphasized the importance of algorithmic thinking and efficiency in problem-
solving, laying the groundwork for tackling more advanced data structures.

The training program adopted a hands-on approach to learning, with daily coding
sessions, assignments, and real-world projects. One of the highlights was a mini-
project where participants applied their newly acquired skills to design and
implement practical solutions, such as management systems or small-scale
applications. This project-based learning not only reinforced theoretical knowledge
but also provided exposure to software development processes and debugging
practices.

In addition to core programming skills, the training introduced participants to

essential development tools and methodologies. IntelliJ IDEA and Eclipse IDE
were used for coding, while GitHub facilitated version control and collaboration.
These tools helped participants adhere to industry-standard practices and improved
their workflow efficiency.

Overall, the structured curriculum, combined with expert guidance and real-world
applications, made the training program a comprehensive learning journey. By the
end of the program, participants had developed strong technical proficiency,
problem-solving skills, and a readiness to take on challenges in the software
development industry. The program also fostered confidence and adaptability,
making participants well-prepared for professional roles in the technology sector.
 EXECUTIVE SUMMARY

The One-Month Java Training Program conducted by Prowhiz was a

comprehensive initiative aimed at providing participants with in-depth knowledge
of Java programming. The program was designed to cover both foundational and
advanced topics, ensuring that participants gained the technical skills necessary for
success in the field of software development.

The training began with Java fundamentals, focusing on syntax, data types,
operators, control structures, and loops, laying a strong foundation for programming.
Building upon these basics, the program advanced to Core Java concepts, where
participants explored Object-Oriented Programming (OOP) principles, including
encapsulation, inheritance, polymorphism, and abstraction. Essential topics such as
exception handling and file manipulation were also covered, preparing participants
to develop robust and efficient applications.

In addition to Core Java, the program introduced participants to Data Structures

and Algorithms (DSA). The focus was on understanding and implementing arrays
and sorting algorithms like Bubble Sort, Selection Sort, and Insertion Sort. These
sessions emphasized algorithmic thinking and problem-solving, equipping
participants to approach technical challenges methodically.

The training was conducted with a strong emphasis on practical learning.

Participants engaged in daily coding exercises and hands-on assignments to
reinforce theoretical concepts. Development tools like IntelliJ IDEA, Eclipse, and
GitHub were utilized to familiarize participants with industry-standard workflows
and practices.

Through consistent practice and expert guidance, participants developed a strong

foundation in Java programming and improved their debugging and logical
reasoning skills. They also gained exposure to collaborative coding practices and
professional development tools, preparing them for future roles in the technology
industry.

This report provides a detailed account of the training program, outlining its
structure, content, and the key learning outcomes achieved by the participants.
 INDEX

[Link] CONTENTS [Link]

1. INTRODUCTION 08

2. TRAINING OBJECTIVES 11

3. TOOLS AND TECHNOLOGIES USED 14

4. KEY LEARNINGS 17

5. CHALLENGES FACED 21

6. CODINGS ASSIGNMENTS AND SCREENSHOTS 24

7. CONCLUSION 31

8. BIBLIOGRAPHY 32
 1. INTRODUCTION

The One-Month Java Training Program conducted by Prowhiz Company was

designed to provide participants with a thorough understanding of Java
programming, ranging from foundational concepts to intermediate-level techniques.
This program aimed to prepare participants for challenges in the technology industry
by equipping them with the knowledge and skills needed to develop efficient and
scalable software solutions.

1. ABOUT PROWHIZ COMPANY

Prowhiz Company is a recognized leader in professional training and development,

specializing in delivering high-quality technical education tailored to meet industry
standards. With a mission to bridge the gap between academic learning and industry
demands, Prowhiz designs comprehensive programs that emphasize hands-on
learning and practical application. This Java training program reflects the company’s
commitment to empowering participants with essential programming expertise.

2. PURPOSE OF THE TRAINING

The primary goal of the training program was to provide participants with the skills
and confidence to write and understand Java code. The program focused on building
a strong foundation in Java fundamentals while introducing advanced features and
concepts. The purpose of this training was to:

• Equip participants with a robust understanding of Java basics and Object-

Oriented Programming (OOP).
• Strengthen problem-solving abilities through algorithmic thinking.
• Familiarize learners with tools and technologies commonly used in software
development.

3. IMPORTANCE OF JAVA IN THE SOFTWARE INDUSTRY

Java is one of the most popular and versatile programming languages in the world,
known for its platform independence, robustness, and scalability. Its applications
span various domains, including:
 • Enterprise Software Development: Java powers large-scale enterprise
systems in industries like banking and healthcare.
• Mobile App Development: Java is a cornerstone for Android applications.
• Web Development: Backend development frameworks such as Spring and
Hibernate use Java.
• Big Data and Analytics: Tools like Hadoop rely on Java for performance and
scalability.

Given its widespread adoption, Java proficiency is a sought-after skill, opening

career opportunities across diverse industries.

4. SCOPE OF THE TRAINING PROGRAM

The program was structured to provide a comprehensive understanding of Java

programming. It included:

• Java Basics: Syntax, data types, variables, loops, and control structures.
• Core Java: OOP principles (encapsulation, inheritance, polymorphism,
abstraction), exception handling, and file manipulation.
• Data Structures and Algorithms (DSA): Introduction to arrays and sorting
algorithms like Bubble Sort, Selection Sort, and Insertion Sort.
• Development Tools: Training on IntelliJ IDEA, Eclipse, and GitHub to align
participants with industry workflows.

This broad scope ensured participants were equipped with both theoretical
knowledge and practical coding skills.

5. TRAINING METHODOLOGY

The program adopted a learner-focused approach, combining theoretical instruction

with extensive hands-on exercises. Key aspects of the methodology included:

• Interactive Lectures: Conceptual explanations supported by real-world

examples.
• Practical Coding Sessions: Daily exercises to solidify understanding and
improve problem-solving skills.
• Weekly Assessments: Regular tests to evaluate participants’ progress and
reinforce learning.
 • Industry-Standard Tools: Use of IntelliJ IDEA, Eclipse, and GitHub to
simulate professional development environments.

This combination of theory and practice ensured participants gained a holistic

understanding of Java programming.

6. EXPECTED OUTCOMES

Upon completion of the training, participants were expected to:

• Develop a strong foundation in Java programming concepts.

• Understand and implement Object-Oriented Programming (OOP) principles.
• Write, test, and debug Java programs effectively.
• Solve problems using basic data structures and algorithms.
• Utilize development tools and adhere to industry best practices.

The program aimed to build confidence and competence, ensuring participants were
well-prepared to pursue further studies or professional roles in software
development.
 2. TRAINING OBJECTIVES

The One-Month Java Training Program at Prowhiz Company was designed with
specific goals to ensure participants developed a thorough understanding of Java
programming and its applications in software development.

The training objectives are detailed as follows:

1. UNDERSTANDING JAVA BASICS

The first objective was to establish a strong foundation in Java programming by:

• Grasping fundamental concepts: Learning Java syntax, data types,

variables, operators, and the structure of a Java program.
• Control structures: Mastering decision-making constructs such as if-else
statements, switch cases, and loops (for, while, do-while) to control program
flow.
• Code writing and debugging: Developing the ability to write clean, efficient,
and error-free code for basic applications.

2. MASTERING CORE JAVA CONCEPTS

Participants were introduced to the advanced features of Java, focusing on:

• Object-Oriented Programming (OOP):

o Encapsulation to protect data within classes.
o Inheritance for creating reusable and hierarchical relationships.
o Polymorphism to enhance flexibility in program design.
o Abstraction for simplifying complex systems.
• Exception handling: Learning to handle runtime errors gracefully using try-
catch blocks and custom exceptions.
• File manipulation: Reading, writing, and managing files using Java I/O
streams to enable data persistence.
3. INTRODUCTION TO DATA STRUCTURES AND ALGORITHMS (DSA)

Building problem-solving skills through:

• Foundational data structures: Understanding and implementing arrays for

data storage and operations.
• Sorting algorithms: Applying techniques such as Bubble Sort, Selection
Sort, and Insertion Sort to organize data efficiently.

These topics emphasized the importance of algorithmic thinking and optimization in

real-world applications.

4. PRACTICAL APPLICATION AND HANDS-ON LEARNING

A critical component of the training was hands-on practice:

• Daily coding sessions: Reinforcing theoretical knowledge with practical

assignments.
• Real-world relevance: Solving problems that simulate software development
tasks.
• Collaboration tools: Utilizing industry-standard tools like IntelliJ IDEA for
development and GitHub for version control and teamwork.

5. ENHANCING PROBLEM-SOLVING SKILLS

Participants were encouraged to develop a logical approach to coding by:

• Tackling coding challenges to strengthen their understanding of programming

constructs.
• Debugging complex scenarios to build confidence in troubleshooting.

6. EXPOSURE TO DEVELOPMENT TOOLS

Understanding the professional environment through:

• Integrated Development Environments (IDEs): Proficiency in IntelliJ

IDEA and Eclipse for efficient coding and debugging.
 • Version control systems: Mastering GitHub for collaborative coding,
managing repositories, and tracking changes.

7. FOSTERING PROFESSIONAL GROWTH

Beyond technical skills, the program aimed to develop soft skills critical for
workplace success:

• Time management: Meeting deadlines for coding tasks and assignments.

• Teamwork: Collaborating with peers during coding exercises and
discussions.
• Communication: Clearly articulating problem-solving approaches and
solutions.

By achieving these training objectives, the program ensured participants were not
only proficient in Java but also equipped with the skills to tackle real-world
challenges effectively and confidently.
 3. TOOLS AND TECHNOLOGIES USED

The One-Month Java Training Program at Prowhiz Company integrated several

industry-standard tools and technologies to provide participants with hands-on
experience and exposure to professional development environments. This section
outlines the tools used during the training, with a primary focus on Eclipse IDE.

1. ECLIPSE IDE

Eclipse IDE (Integrated Development Environment) was the core tool used for the
training. It is one of the most widely used platforms for Java development and offers
a comprehensive suite of features to support writing, debugging, and managing Java
applications.

Key Features of Eclipse IDE

• User-Friendly Interface:
Eclipse provides an intuitive interface that is customizable, allowing
participants to organize projects and workspaces according to their
preferences.
• Code Editor with Syntax Highlighting:
The editor in Eclipse highlights syntax and provides instant feedback,
making it easier to read, write, and debug Java code.
• Auto-Completion and Suggestions:
Eclipse offers auto-completion and intelligent suggestions as developers
write their code, reducing errors and improving productivity.
• Real-Time Error Detection:
Eclipse continuously checks for errors as code is written and alerts the user
immediately, making debugging much easier.
• Integrated Debugger:
Eclipse includes a powerful debugger to help developers step through their
code, set breakpoints, and inspect variables. This feature allows participants
to understand code behavior and identify issues efficiently.
• Refactoring Tools:
Eclipse supports refactoring, allowing participants to restructure their code
(renaming methods, variables, or classes) without introducing errors,
enhancing code maintainability.
• Plugin Support:
Eclipse can be extended through plugins, offering features for testing,
 version control, and integration with other programming languages and
frameworks, though plugins were not the primary focus during this training.

How Eclipse Was Used During Training

• Writing, testing, and debugging Java programs.

• Organizing Java projects and files in a clean and efficient manner.
• Using the built-in debugger to track down and fix bugs in code.
• Writing algorithms, such as sorting methods, and testing them directly within
Eclipse.
• Reinforcing concepts learned during theoretical lessons through hands-on
coding sessions.

2. JAVA DEVELOPMENT KIT (JDK)

The Java Development Kit (JDK) is essential for compiling and running Java
programs. During the training, the JDK provided participants with all the necessary
tools to develop Java applications.

Key Components of the JDK

• Java Compiler (javac): Converts Java source code into bytecode that can be
run on the Java Virtual Machine (JVM).
• Java Virtual Machine (JVM): Executes Java bytecode, enabling platform-
independent code execution.
• Standard Libraries: A rich set of pre-built classes and methods (such as
[Link] for collections, [Link] for file handling) used for developing
a wide range of applications.

The JDK was used throughout the program to compile and execute Java applications,
including writing, testing, and deploying Java code.

3. INTELLIJ IDEA

IntelliJ IDEA is another popular IDE for Java development, known for its advanced
features aimed at enhancing developer productivity. While Eclipse was the primary
IDE for the program, IntelliJ IDEA was also introduced to familiarize participants
with different development environments.
Key Features of IntelliJ IDEA

• Smart Code Completion: IntelliJ IDEA provides more advanced code

completion features, suggesting the most relevant code snippets based on
context.
• Built-in Tools: The IDE comes with built-in tools for testing, version control,
and debugging, making it easier for developers to manage and maintain
projects.
• User-Friendly Debugging: IntelliJ IDEA’s debugger is highly effective for
stepping through code and analyzing variable values during runtime.

The training relied heavily on Eclipse IDE, which offered all the essential features
for Java development, including coding, testing, and debugging. IntelliJ IDEA was
also introduced, providing an alternative environment for participants to understand
the diversity of tools available to Java developers. The Java Development Kit
(JDK) formed the backbone of the development environment, providing the
necessary tools for compiling and executing Java programs. By using these tools,
participants gained valuable experience that aligns with industry practices and
prepared them for professional roles in Java development.
 4. KEY LEARNINGS

The One-Month Java Training Program at Prowhiz Company provided

participants with a comprehensive understanding of Java programming, covering
both foundational and advanced topics. Through structured lessons, practical
exercises, and real-world coding challenges, participants developed the skills
required for effective problem-solving and professional software development.

1. COMPREHENSIVE JAVA FUNDAMENTALS

• Basic Syntax and Structure: Participants gained a clear understanding of

how Java programs are structured, including writing and running basic
programs.
• Data Types and Variables: Mastered the use of primitive data types (e.g.,
int, float, char) and reference data types, along with variable declaration and
initialization.
• Operators: Learned the use of arithmetic, relational, logical, and bitwise
operators to perform various operations.
• Control Structures:
o Conditional Statements: Explored if-else and switch constructs to
handle decision-making scenarios.
o Loops:
▪ For Loops: For iterating a specific number of times.
▪ While Loops: For indefinite iterations until a condition is met.
▪ Do-While Loops: For ensuring execution before condition
checking.
▪ Participants practiced loop-based challenges, such as printing
patterns and calculating factorials.

2. MASTERY OF CORE JAVA CONCEPTS

• Object-Oriented Programming (OOP):

o Encapsulation: Securing class data using access modifiers and
methods.
o Inheritance: Creating parent-child relationships to enable code
reusability and modularity.
o Polymorphism: Implementing flexibility with method overloading
and overriding.
 o Abstraction: Simplifying complex systems through abstract classes
and interfaces.
• String Manipulation:
o Participants explored the String class, understanding immutability and
its importance.
o Practiced methods such as substring(), charAt(), replace(),
toUpperCase(), and split() for manipulating strings.
o Solved problems like reversing strings, checking for palindromes, and
finding substrings.
• Exception Handling:
o Identified and managed runtime errors using try-catch blocks, finally
clauses, and custom exceptions.
o Built robust applications that gracefully handled user input errors.
• File Handling:
o Learned to read and write files using Java I/O streams.
o Worked on practical tasks such as creating, updating, and reading text
files.

3. ADVANCED TOPICS IN JAVA

• Arrays:
o Declared and initialized single-dimensional and multi-dimensional
arrays.
o Practiced operations like searching, sorting, and updating elements.
• Data Structures and Algorithms (DSA):
o Implemented sorting algorithms such as Bubble Sort, Selection Sort,
and Insertion Sort.
o Solved challenges related to array manipulation, such as merging arrays
and finding duplicates.
• StringBuilder and StringBuffer:
o Learned to use these classes for efficient string operations, especially
in scenarios involving frequent modifications.
• Collections Framework (Optional for Some Participants):
o Briefly introduced to collections such as ArrayList and HashMap to
understand dynamic data structures.
4. PRACTICAL CODING EXPERIENCE

• Daily Assignments: Practiced coding tasks focused on Java basics, OOP

concepts, and data handling.
• Real-World Scenarios: Wrote programs to solve everyday problems, such as
calculating compound interest, processing user data, or managing lists of
information.
• Debugging: Developed skills to identify and fix logical and runtime errors
through tools like the Eclipse debugger.

5. EXPOSURE TO DEVELOPMENT TOOLS

• Eclipse IDE:
o Used as the primary development environment for coding, debugging,
and organizing projects.
o Leveraged features like auto-completion, syntax highlighting, and error
detection to streamline development.
• IntelliJ IDEA: Briefly explored for its smart coding features and alternative
workflows.
• Java Development Kit (JDK): Gained hands-on experience with JDK tools
for compiling and executing Java programs.

6. STRENGTHENED PROBLEM-SOLVING AND LOGICAL THINKING

• Solved algorithmic challenges related to arrays, strings, and control structures.

• Improved logical reasoning by designing efficient solutions for tasks
involving loops and recursion.
• Participated in coding exercises that emphasized clarity and efficiency in
program design.

7. PROFESSIONAL AND PERSONAL GROWTH

• Confidence in Coding: Through consistent practice, participants gained

confidence in Java programming and troubleshooting.
• Teamwork and Communication: Collaborative exercises and discussions
fostered teamwork and improved communication skills.
 • Time Management: Managed assignments and tasks within deadlines,
developing essential professional habits.

The training program covered a broad range of topics, from Java fundamentals to
advanced concepts such as OOP, string manipulation, and data structures. With a
balance of theory and hands-on practice, participants emerged with a deep
understanding of Java programming and enhanced their problem-solving
capabilities, preparing them for real-world challenges in software development.
 5. CHALLENGES FACED

During the One-Month Java Training Program at Prowhiz Company,

participants encountered several challenges that tested their understanding, problem-
solving abilities, and adaptability. Overcoming these challenges played a crucial role
in their learning and professional growth.

1. UNDERSTANDING ADVANCED CONCEPTS

• Object-Oriented Programming (OOP):

o Initially, participants found it challenging to grasp OOP principles such
as polymorphism and abstraction.
o Differentiating between method overloading and overriding required
focused practice and examples.
• Exception Handling:
o Understanding how to use try-catch blocks effectively and when to
create custom exceptions was initially confusing.

2. DEBUGGING COMPLEX PROGRAMS

• Debugging Java code presented challenges, especially when programs

involved nested loops, recursive calls, or large datasets.
• Participants had to learn systematic approaches to identify errors and resolve
logical issues.

3. STRING MANIPULATION

• Manipulating strings using methods like substring(), split(), and replace() was
initially tricky.
• Tasks such as checking for palindromes or finding patterns in strings required
a deeper understanding of the String class and problem-solving techniques.

4. WORKING WITH DATA STRUCTURES AND ALGORITHMS (DSA)

• Arrays:
o Implementing operations like searching, sorting, and merging arrays
was challenging for participants unfamiliar with algorithmic thinking.
 • Sorting Algorithms:
o Understanding the logic behind Bubble Sort, Selection Sort, and
Insertion Sort and implementing them efficiently was a significant
hurdle.
o Analyzing algorithm complexity added an additional layer of difficulty
for some participants.

5. FILE HANDLING

• Participants faced issues when reading and writing files using Java I/O
streams, particularly in understanding the difference between
FileReader/FileWriter and BufferedReader/BufferedWriter.

6. TIME MANAGEMENT

• Balancing daily coding assignments with the pace of the training sessions
proved challenging.
• Meeting deadlines for tasks while ensuring accuracy required participants to
improve their time management skills.

7. ADAPTING TO DEVELOPMENT TOOLS

• Eclipse IDE:
o While Eclipse provided powerful features, participants initially
struggled with navigating the interface, setting up projects, and using
the debugger effectively.
o Configuring the IDE for various tasks, such as linking libraries or
managing multiple projects, required additional practice.

8. LOGICAL THINKING AND PROBLEM-SOLVING

• Breaking down complex problems into manageable steps was challenging,

especially for tasks requiring nested loops or recursive functions.
• Developing efficient solutions and optimizing code for performance required
persistent effort and practice.
9. MANAGING ERRORS AND EDGE CASES

• Participants often encountered unexpected behaviors in programs due to

unhandled edge cases or improper input validation.
• Learning to anticipate and account for such scenarios was a key learning area.

10. APPLYING THEORETICAL CONCEPTS TO PRACTICAL

SCENARIOS

• Bridging the gap between theoretical understanding and practical application

was challenging in the initial stages.
• Writing programs that integrated multiple concepts, such as OOP and file
handling, demanded comprehensive understanding and attention to detail.

The challenges faced during the training were instrumental in enhancing

participants' technical and problem-solving skills. By addressing these obstacles,
participants gained a deeper understanding of Java programming and developed the
resilience and confidence required to tackle real-world software development tasks
effectively.
 6. CODING ASSIGNMENTS AND SCREENSHOTS

This section includes six coding assignments completed during the training program.
Each assignment contains a detailed description of the problem, the corresponding
Java code, and an explanation of its functionality. These assignments demonstrate
the practical application of Java concepts, including loops, arrays, string
manipulation, and sorting algorithms.

1. LOGIN VALIDATION SYSTEM

Problem Statement:
Design a program that simulates a login system. The user is prompted to enter a
password with a maximum of three attempts. If the correct password is entered
within three attempts, display a "Login Successful" message; otherwise, display a
"Login Failed" message. The program should also inform the user of the remaining
attempts after each failed login.

Code:

package Training;
import [Link];

public class Login {

public static void main(String[] args) {
String default_password = "Libin@123";
int attempts = 0;
int remaining = 3;

while (attempts < 3) {

Scanner obj = new Scanner([Link]);
[Link]("Enter the password: ");
String password = [Link]();

if ([Link](default_password)) {
[Link]("Login Successful");
break;
 } else {
if (attempts < 2) {
[Link]("Incorrect password. Try Again.");
}
[Link]("Chances remaining: " + (--remaining));
attempts++;
}
}

if (attempts >= 3) {
[Link]("Login Failed");
}
}
}

Output:

2. REVERSE AN INTEGER

Problem Statement:
Create a program that reverses an integer using both numeric operations and string
manipulation techniques. The program should handle input as an integer and
demonstrate the results using two methods to achieve the reversal.
Code:

package Self_Prep;
import [Link];

public class Reverse_an_integer {

public static void main(String[] args) {
Scanner obj = new Scanner([Link]);
[Link]("Enter a number: ");
int num = [Link]();
int originalNum = num;

// Integer method
int reversedNum = 0;
while (num > 0) {
int digit = num % 10;
reversedNum = reversedNum * 10 + digit;
num = num / 10;
}
[Link]("Reversed using numeric method: " +
reversedNum);
}
}

Output:
3. AUTOMORPHIC NUMBER CHECK

Problem Statement:
Develop a program to check if a number is an automorphic number. An
automorphic number is a number whose square ends with the same digits as the
number itself. For example, 25 is automorphic because 252=62525^2 =
625252=625 ends in 25. The program should handle any integer input and
determine if it meets the criteria.

Code:

package Self_Prep;
import [Link];

public class Automorphic_Number {

public static void main(String[] args) {
Scanner obj = new Scanner([Link]);
[Link]("Enter a number: ");
int num = [Link]();
int square = num * num;

if ([Link](square).endsWith([Link](num))) {
[Link](num + " is an automorphic number.");
} else {
[Link](num + " is not an automorphic number.");
}
}
}

Output:
4. FIND SECOND LARGEST NUMBER IN AN ARRAY

Problem Statement:
Write a program to find the second largest number in an array of integers. The
program should handle arrays of various sizes and ensure that repeated maximum
values are not considered as the second largest.

Code:

package Self_Prep;
import [Link];

public class Second_Largest_num_in_array {

public static void main(String[] args) {
Scanner obj = new Scanner([Link]);
[Link]("Enter the size of the array: ");
int size = [Link]();
int[] arr = new int[size];

[Link]("Enter the values of the array: ");

for (int i = 0; i < size; i++) {
arr[i] = [Link]();
}

int largest = Integer.MIN_VALUE;

int secondLargest = Integer.MIN_VALUE;

for (int num : arr) {

if (num > largest) {
secondLargest = largest;
largest = num;
} else if (num > secondLargest && num != largest) {
secondLargest = num;
}
}
[Link]("Second Largest: " + secondLargest);
}
}
Output:

5. SELECTION SORT ALGORITHM

Problem Statement:
Implement the Selection Sort algorithm to sort an array of integers in ascending
order. The program should repeatedly find the minimum element from the unsorted
part of the array and place it at the beginning.

Code:

package Training;
import [Link];

public class Selection_sort {

public void selectionSort(int[] arr) {
for (int i = 0; i < [Link] - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < [Link]; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
int temp = arr[minIndex];
arr[minIndex] = arr[i];
 arr[i] = temp;
}
}

public static void main(String[] args) {

Scanner scan = new Scanner([Link]);
[Link]("Enter the size of the array: ");
int size = [Link]();
int[] arr = new int[size];

[Link]("Enter the array values: ");

for (int i = 0; i < [Link]; i++) {
arr[i] = [Link]();
}

Selection_sort sorter = new Selection_sort();

[Link](arr);

[Link]("Sorted Array: ");

for (int num : arr) {
[Link](num + " ");
}
}
}

Output:
 7. CONCLUSION

The One-Month Java Training Program conducted by Prowhiz was a

comprehensive learning journey designed to provide participants with a strong
foundation in Java programming. Through a carefully structured curriculum and
hands-on practice, the training bridged the gap between theoretical concepts and
their practical applications, equipping participants with the skills required to thrive
in the software development industry.

The program began with the fundamentals of Java, including syntax, control
structures, loops, and data types, and progressed to advanced topics such as Object-
Oriented Programming (OOP), exception handling, file manipulation, and basic
Data Structures and Algorithms (DSA). Participants gained valuable insights into
the workings of Java, developing their logical thinking and problem-solving
abilities.

Practical coding assignments, such as implementing sorting algorithms, checking for

automorphic numbers, and resizing arrays, reinforced theoretical knowledge and
improved coding efficiency. Exposure to tools like Eclipse IDE provided
participants with the experience of working in professional development
environments, enhancing their understanding of industry-standard practices.

Despite initial challenges, such as debugging complex programs and understanding

advanced concepts, participants demonstrated remarkable progress. The training
program not only enriched their technical skills but also fostered essential
professional qualities, including time management, teamwork, and adaptability.

By the end of the program, participants emerged as confident and competent Java
developers, ready to tackle real-world challenges. This report captures the essence
of the training journey, highlighting the key learnings, assignments, and experiences
that made it a transformative educational experience. The knowledge and skills
acquired during this program serve as a strong foundation for future growth in the
dynamic field of software development.
 BIBLIOGRAPHY

The following resources were referred to during the One-Month Java Training
Program at Prowhiz Company to enhance theoretical knowledge and practical
application skills:

Books:

1. Herbert Schildt
Java: The Complete Reference, 11th Edition
Publisher: McGraw-Hill Education
Description: A comprehensive guide to Java programming, covering core
concepts, advanced features, and practical examples.
2. Kathy Sierra and Bert Bates
Head First Java, 2nd Edition
Publisher: O'Reilly Media
Description: An engaging book for beginners to understand Java concepts in
an intuitive and visual manner.
3. Robert Lafore
Data Structures and Algorithms in Java
Publisher: Pearson Education
Description: A detailed explanation of data structures and algorithms, with a
focus on Java implementation.

Web Resources:

1. Oracle Documentation
[Link]
Description: The official Java tutorials provided by Oracle, offering an in-
depth understanding of Java concepts and libraries.
2. GeeksforGeeks
[Link]
Description: A resource-rich website with tutorials, coding examples, and
problem-solving techniques in Java and related topics.
3. W3Schools
[Link]
Description: Beginner-friendly Java tutorials with practical examples and
exercises.