JAVA PROGRAMMING

INTERNSHIP REPORT

Submitted by

ASATH K [717823L204]

in partial fulfillment for the award of the degree of

BACHELOR OF ENGINEERING
IN

ELECTRONICS AND COMMUNICATION ENGINEERING

ANNA UNIVERSITY, CHENNAI

JUNE 2024
 CERTIFICATE

This is to certify that the Internship report submitted by ASATH K

(717823L204) is work done by him and submitted during 2024 – 2025 academic
year, in partial fulfillment of the requirements for the award of the degree of
BACHELOR OF ENGINEERING in ELECTRONICS AND
COMMUNICATION ENGINEERING.

Department Internship Coordinator Head of the Department

Certified that the candidate was examined in the viva-voce examination

held
on …………………

.………………………
(Internal Examiner)
INTERNSHIP CERTIFICATE
 ACKNOWLEDGEMENT

I would like to show my gratitude to the management of

Karpagam College of Engineering Dr. R. VASANTHAKUMAR,
B.E., (Hons), D.Sc., Chairman and Managing Trustee, Karpagam
Educational Institutions for providing me with all sorts of support in
complete of this internship.

I express my kind sincere effort and profound gratitude to our

Principal Dr. V. KUMAR CHINNAIYAN, M.E., Ph.D for his
guidance and sustained encouragement for the successful completion
for this internship.

I feel immense pleasure in expressing my humble note of

gratitude to our Head of the Department Dr. R. SARANKUMAR,

M.E., Ph.D for his remarkable guidance and besides his positive

approach. He has offered incessant help in all possible ways from the
beginning.

A word of thanks would not be sufficient for the work of my

Internship Coordinator Mrs S MALINI AP/Department of Electronics

and Communications Engineering whose efforts and inspiration lead

us through every trying circumstance.

I will thank throughout the arise in the course of the internship

and extend my thanks to other Faculty member, Parents and Friends

for providing their moral support in successfully completing this

internship
 TABLE OF CONTENT

CHAPTER NO TITLE

ABSTRACT

LIST OF FIGURES

WEEKLY OVERVIEW OF INTERNSHIP

1 INTRODUCTION

2 DISCUSSION

3 CONCLUSION

4 REFERENCE
 ABSTRACT
This abstract introduces a structured and comprehensive Java internship program
designed to equip participants with essential skills in software development using
Java. The internship cover foundational to advanced topics essential for building
robust and scalable applications.

The internship begins with an exploration of identifiers and primitive data types,
where participants learn about naming conventions and fundamental data types
such as int, float, and char. This foundational knowledge sets the stage for
understanding memory allocation and basic data operations in Java.

Participants will then dive into structured data types, focusing on arrays and the
use of classes and objects to organize and manipulate data effectively. Practical
exercises will demonstrate how to implement and utilize these data structures in
real-world scenarios.

Reference types in Java will be thoroughly explored, including object

instantiation, memory management, and the principles of garbage collection.
Participants will gain hands-on experience in managing object references and
leveraging Java's robust memory management capabilities.

Blocks and exception handling are critical aspects of reliable Java programming.
Participants will learn to structure code using blocks, handle exceptions using
try-catch blocks, and implement error management strategies to ensure robust
application behavior under various conditions.

Control structures form the backbone of program logic in Java. Participants will
master conditional statements (if-else, switch), iterative structures (for, while, do-
while), and control flow mechanisms to effectively manage program execution
and decision-making processes.

The internship will also cover procedures and functions in Java, emphasizing
method declaration, parameter passing, return types, and method invocation.
Participants will understand the benefits of modular programming and practice
creating reusable code components through function abstraction.

Object-oriented programming (OOP) principles will be central to the internship,

covering classes, objects, constructors, inheritance, and polymorphism.
Participants will learn to design and implement object-oriented solutions that
promote code reusability, maintainability, and scalability.

Inheritance and its role in Java will be explored in depth, focusing on how classes
inherit properties and behaviors from parent classes. Participants will gain
practical experience in method overriding and using class hierarchies to model
complex relationships in software design.

Interfaces provide a powerful mechanism for achieving abstraction and multiple

inheritance in Java. Participants will learn to define interfaces, implement
interface methods in classes, and leverage interfaces to design flexible and
extensible software solutions.

The internship will also introduce inner classes as a means of organizing classes
within other classes, including member classes, local classes, and anonymous
classes. Participants will explore how inner classes enhance encapsulation and
facilitate cleaner code organization in Java projects.

Throughout the internship, participants will engage in hands-on coding exercises,

projects, and mentorship sessions to apply their knowledge in practical settings.
The culmination of the program will be a final project where participants
integrate multiple Java concepts into a cohesive application, demonstrating their
proficiency and readiness for careers in software development.

By the conclusion of the Java internship program, participants will have acquired
a solid foundation in Java programming, equipped with practical skills and
industry-relevant experience to pursue entry-level roles in software development
or advance their academic pursuits.
 LIST OF FIGURES

FIGURE NO FIGURE NAME

2.1 History of JAVA.

2.2 Origins and Evolution

2.3 Key Features

2.4 identifiers and primitive data types

2.5 structured data types

2.6 reference types

2.7 blocks and exception handling

2.8 control structures

2.9 procedures and functions

2.10 object oriented programming,

packages and classes
 WEEKLY OVERVIEW OF INTERNSHIP

DATE DAY NAME OF THE TOPIC

F
15 / 06/ 2024 Saturday Introduction to Java, History of Java
i
16 / 06/ 2024
g Sunday Setting up Java Environment, Installing JDK and Eclipse

17 / 06/ 2024
2
Monday Basic Syntax and Data Types in Java
.
18 / 06/ 2024 Tuesday Variables, Operators, and Control Structures in Java
19 / 06/ 2024
A Wednesday Introduction to Java Classes and Objects
b
o
20 / 06/ 2024 Thursday Creating and Using Java Methods

21 / 06/ 2024 Friday Review and Practice of Week 1 Topics

O
u
22 / 06/ 2024 Saturday Practice and Assignment Submission
r
23 / 06/ 2024 Sunday Review and Reflection of Week 1
P
24r / 06/ 2024 Monday Identifiers and Primitive Data Types in Java
o
25v/ 06/ 2024 Tuesday Structured Data Types
i
26d/ 06/ 2024 Wednesda Reference Types
e y
27 / 06/ 2024 Thursday Blocks and Exception Handling

28 / 06/ 2024 Friday Control Structures

29 / 06/ 2024 Saturday Procedures and Functions

30 / 06/ 2024 Sunday Review and Reflection on Java Internship Program

 CHAPTER 1
INTRODUCTION

The Java Internship program at Website Makers, where participants embark

on a journey to deepen their understanding and proficiency in Java
programming. Our internship is meticulously designed to equip participants
with essential skills required for modern software development. Throughout
the program, participants will delve into foundational concepts such as Java
syntax, data types, and control structures, laying a solid groundwork for
advanced topics including object-oriented programming, concurrency, and
database connectivity. Hands-on learning is emphasized through practical
coding exercises, collaborative projects, and mentorship from experienced
instructors. By the end of the internship, participants will not only have
mastered Java fundamentals but also gained practical experience in
designing, developing, and debugging Java applications. This immersive
experience culminates in a final project where participants apply their
knowledge to solve real-world challenges, preparing them for successful
careers in Java programming and beyond.
 CHAPTER 2
DISCUSSION

2.1History of JAVA
Java, developed by Sun Microsystems (which was later acquired
by Oracle Corporation), emerged in the early 1990s as a programming
language with a specific goal: to be platform-independent and portable. Its
history is rooted in addressing the challenges faced by software developers
due to the proliferation of different types of hardware and operating
systems.

2.2 Origins and Evolution

Origins and Early Development

The origins of Java can be traced back to a project initiated by James Gosling, Patrick
Naughton, and Mike Sheridan at Sun Microsystems in 1991. Initially named "Oak," the
project aimed to develop software for consumer electronic devices such as set-top
boxes. The primary challenge they encountered was the variety of hardware platforms
and operating systems, which made software development and deployment
cumbersome and costly.

Evolution into Java

In 1994, recognizing the limitations of existing programming languages for their

project, the team re-evaluated and restructured Oak to better address these challenges.
The language was subsequently renamed "Java," inspired by the coffee culture at Sun
Microsystems. The official announcement of Java came in May 1995, accompanied by
the promise of "Write Once, Run Anywhere" (WORA), a concept central to Java’s
design philosophy.
2.3 Key Features

Java introduced several groundbreaking features that set it apart from its predecessors:

 Platform Independence: Java achieves platform independence through its

bytecode intermediate representation. Programs are compiled into bytecode,
which can run on any device equipped with a Java Virtual Machine (JVM),
regardless of the underlying hardware or operating system.
 Object-Oriented Programming: Java was designed as an object-oriented
language from the ground up, supporting principles such as encapsulation,
inheritance, and polymorphism. This made it easier for developers to build
modular and reusable code, enhancing productivity and maintainability.
 Automatic Memory Management: Java introduced automatic garbage
collection, alleviating developers from manual memory management tasks. This
feature enhanced program reliability and reduced the occurrence of memory-
related errors.
 Rich Standard Library: Java’s comprehensive standard library provides a vast
collection of pre-built classes and APIs for common programming tasks, ranging
from input/output operations to networking and GUI development.

Adoption and Community Involvement

Java’s open design and community-driven development approach played a crucial role
in its rapid adoption. The establishment of the Java Community Process (JCP) in 1998
formalized the involvement of developers, organizations, and industry experts in
shaping the future direction of Java. This collaborative effort ensured that Java evolved
to meet the evolving needs of the software development industry.

Java Today

Today, Java remains one of the most widely used programming languages globally. It
powers a diverse range of applications, including enterprise software, mobile
applications (Android), web applications, and embedded systems. Its versatility,
performance, and strong ecosystem of tools and frameworks continue to make it a
preferred choice for developers and organizations across various industries.

In summary, Java’s history is characterized by its innovative approach to addressing

platform independence, robust object-oriented design, and community-driven
evolution. It has consistently adapted to technological advancements while maintaining
its core principles of portability, reliability, and scalability, cementing its position as a
cornerstone of modern software development.Top of Form
 2.4 Identifiers and primitive data types

Identifiers Java does not restrict the lengths of identifiers. Although the language
does allow the use of a “_” to be included in identifier names, the emerging style is to use
a mixture of upper and lower case characters. The following are example identifiers

exampleNameInJava
example_name_in_Java

Note that Java is case sensitive. Hence, the identifier exampleNameInJava

is differ- ent from ExampleNameInJava.

Primiti Java provides both a variety of discrete data types and a

ve data floating point type.
types
Discrete data types. The following discrete data types are
supported:
• int — a 32-bit signed integer;
• short — a 16-bit signed integer;
• long — a 64-bit signed integer;
• byte — an 8-bit signed integer;
• boolean — the truth values, true and false;
• char— Unicode characters (16 bits).
All the usual operators for these types are available.
Enumeration types have been introduces as of Java 1.5.
Although not a primitive type it behaves like a descrete type
and can be used in a switch statement. The follow- ing
example illustrates a simple enumeration type for days of the
week.

public enum Day{SUNDAY, MONDAY, TUESDAY, WEDNESDAY,

THURSDAY, FRIDAY, SATURDAY}
Floating point numbers
Java provides float and double types that support the 32 and 64 bit IEEE 754 float- ing point
values respectively. Note, that floating point literals are automatically consid- ered to be
of double precision. Consequently, they must either be explicitly converted to float or
they can be followed by the letter f. For example

float bodyTemperature = (float) 98.6;

// or
float bodyTemperature = 98.6f;

Note that the assignment operator is “=” and that comments are delimited by “/*” and
“*/”. Java also allows “//” for comments ending a line.
 2.5 structured data types

Java supports arrays; both single and multi dimensional arrays can be created;
for example:

final int max = 10; // a constant

float[] reading = new float[max]; // index is 0 .. max-1
boolean[][] switches = new boolean[max][max];
Note that arrays are represented by objects and that indexes start at 0. The
length of the array can be determined by the length field associated with the
array
Java has no record structure as such. However, the same effect can be
achieved using classes. The details of classes will be given in Section 7 but,
for now, consider the following class for the date:

class Date {
int day, month, year;
}
Date birthDate = new Date();
birthate.day = 31;
birthDate.month = 1;
birthDate.year = 2000;
It is not possible to express range constraints on the values of the date's components.
Note also that as a “record” is a class, an allocator (the new operator) must be used to
create an instance of the Date. Initialization of the object can be achieved using con-
structors (see Section 7).
Important note:
All objects created by the new operator are stored in an
area of memory called the heap. An activity called garbage
collection will free up any associated memory when the
object is no longer referenced.
2.6 Reference types
All objects in Java are references to the actual locations containing the
encapsulated data, hence no additional access or pointer type is required.
Furthermore, no forward declaration is required. For example:

class
n be used even though
N // its declaration has not been completed yet.
o }
d
Notee that as a result of representing objects as reference values,
comparing two objects is a comparison between their references
not {their values. Hence,
i
Noden ref1=newNode();Node
ref2t = new Node();
...
v
if(ref1
a == ref2) { ... }
willl compare the locations of the objects not the values
u
encapsulated
e by the objects (in this case, the values of the value and
next; fields). To compare values requires a class to implement an
explicit equals method. A similar situation occurs with object
N
assignment. The assignment operator assigns to the reference. To
o
create
d an actual copy of an object requires the class to provide
methods
e to clonethe object.

n
e
x
t
;
/
/
T
h
e
t
y
p
e
n
o
d
e
c
a
2.7 Blocks and exception handling
In Java, a block (or compound statement) is delimited by “{“ and “}”, and
usually has the following structure

{
< declarative part >

< sequence of statements >

}
although the declarative part can be dispersed throughout the block.
Java can have exception handlers at the end of a block if the block is labeled as a
tryblock. Each handler is specified using a catch statement. Consider, the following:

try {
//code that might throw an exception
} catch (Exception err) {
// Exception caught, print error message on
// the standard output. System.out.println(err.getMessage());
}
The catch statement is like a function declaration, the parameter of which
identifies the exception type to be caught. Inside the handler, the object name
behaves like a local variable. A handler with parameter type T will catch a
thrown object of type E if:
• T and E are the same type,
• or T is a parent (super) class of E at the throw point.
It is this last point that integrates the exception handling facility with the
object-ori- ented programming model. In the above example the Exception
class is the root class of all application exceptions. Hence, the catch clause
will catch all application exceptions. Here, getMessage is a method declared in
the Exception class. A call to E.getMessage will execute the appropriate routine
for the type of object thrown. If no exception handler is found in the calling
context of a function, the calling context is terminated and a handler is
sought in its calling context. Hence, Java supports
exception propagation.
 Finally clauses
Java also supports a finally clause as part of a try statement. The code attached to this clause
is guaranteed to execute whatever happens in the try statement irrespective
of whether exceptions are thrown, caught, propagated or, indeed, even if there are no
exceptions thrown at all.

try {
...
} catch(...) {
...
} finally {
// code that will be executed under all circumstances
}

Checked and unchecked exceptions

In Java, all exceptions are subclasses of the predefined class java.lang.Throw- able. The
language also defines other classes, for example: Error, Exception, and
RuntimeException. The relationship between these (and some common exceptions) is
depicted in Figure 1.

Throwable

Error Exception

RunTimeException InterruptedException

SecurityException NullPointerException IllegalArgumentException

IllegalMonitorStateException IllegalThreadStateException
Checked

unchecked

fig 1. Part of the The Java Predefined Throwable Class Hierarchy

Throughout this book, the term Java exception is used to denote any class derived from
Exception. Objects derived from Error describe internal errors and resource exhaustion in
the Java run-time support system. Although these errors clearly have a major impact on the
program, there is little that the program can do when they are

thrown (raised) as no assumptions can be made concerning the integrity of the system.
Objects derived from the Exception hierarchy represent errors that programs can handle or
can throw themselves. RuntimeExceptions are those exceptions that are raised by the run-
time system as a result of a program error. They include errors such as those resulting from
a bad cast (ClassCastException), array bounds error (IndexOutOfBoundException), a null
pointer access (NullPointerExcep-tion), integer divide by zero (ArithmeticException) etc.

Throwable objects which are derived from Error or RuntimeExceptionsare called unchecked
exceptions, the others are termed checked exceptions. Checked exceptions must be
declared by the function that can throw them. The compiler will check that an appropriate
handler can be found. The compiler makes no attempt to ensure that handlers for
unchecked exceptions exist.
 2.8 Control structures
Control structures can be grouped together into three categories: sequences, decisions
and loops.
Sequence structures
Most languages implicitly require sequential execution, and no specific control struc- ture
is provided. The definitions of a block in Java indicate that between { and } there is a
sequence of statements. Execution is required to follow this sequence.

Decision structures
The most common form of decision structure is the ifstatement; for example:

if(A != 0) {
if(B/A > 10) {
high = 1;
} else { high = 0;
}
}

In general, a multiway decision can be more explicitly stated and efficiently imple-
mented, using a switchstructure.

switch(command) {
case 'A' :
case 'a' : action1(); break; /* A or a */
case 't' : action2(); break;case 'e' : action3();
break;case 'x' :
case 'y' :
case 'z' : action4(); break; /* x, y or z */
default : /* no action */
}
As with C and C++, it is necessary to insert statements to break out of the switch once the
required command has been identified. Without these, control continues to the next option
(as with the case of A).
Loop (iteration) structures
Java supports the usual for and while statements. The following example illustrates the for
statement; the code assigns into the first ten elements of array, A, the value of their positions
in the array:

for(i = 0; i <= 9; i++) {

/* i must be previously declared */ A[i]= i; /* i can
be read/written in the loop */
} /* the value of i is defined */
/* after the loop */
The free use of the loop control variable (i here) in this manner can be the
cause of many errors, consequently, Java also allows a local variable to be
declared inside the forloop.

for(int i = 0; i <= max; i++) {A[i]= i;

}

An example while statement is given below

while(<expression>) {
/* Expression evaluating to true or false. */
/* False implies loop termination. */
<sequence of statements>
}
Java also supports a variant where the test occurs at the end of the
loop:

do {
< sequence of statements>
} while (<expression>);

The flexibility of an iteration statement is increased by allowing control to

pass out of the loop (that is, the loop to terminate) from any point within it
(break) or for control to pass directly to the next iteration (continue):

while(true) {
...
if(<expression1>) break;
if(<expression2>) continue;
...
}
2.9 Procedures and functions

Procedures and functions can only be declared in the context of a class, they are known
collectively as methods. In fact, strictly Java only supports functions; a procedure is
considered to be a function with no return value (indicated by void in the function
definition).

Java passes primitive data type (int, boolean, float etc.) parameters (often called
arguments) by value. Variables of class type are reference variables. Hence, when they are
passed as arguments they are copied, but the effect is as if the object was passed by reference.
Consider a function that calculates the roots of a quadratic equation

public class Roots {

double R1, R2;
}

// the following must be declared in a class context

boolean quadratic(double A, double B, double C,
Roots R);
Note Java requires the roots of the equation to be passed as a class type, as primitive types
(including double) are passed by copy and there are no pointer types.

Function bodies

The bodies of functions are illustrated by completing the quadratic definitions given
above.

boolean quadratic(double A, double B,

double C, Roots R) {
double disc;
disc = B*B - 4.0*A*C;
if(disc < 0.0 || A == 0.0) { // no rootsR.R1 = 0; //
arbitrary values R.R2 = 0;
return false;
}
R.R1 = (-B + Math.sqrt(disc)) / (2.0*A);
 R.R2 = (-B - Math.sqrt(disc)) / (2.0*A);
return true;
}

The invoking of a function merely involves naming the function (including

any object or class name) and giving the appropriately typed parameters in
parentheses.
2.10 Object-oriented programming, packages andclasses

Objects have four important properties [Wegner, 1987]. They have

• inheritance (type extensibility)

• automatic object initialization (constructors)

• automatic object finalization (destructors)
• dynamic binding of method calls (polymorphism — sometimes called
run-time dispatching of operations).
All of which are supported, in some form, by Java’s class and interface
mechanisms. Related classes and interfaces can be grouped together into
larger units called pack- ages.
Inheritance is perhaps the most significant concept in an object
abstraction. This enables a type (class) to be defined as an extension of a
previously defined type. The new type inherits the “base” type but may
include new fields and new operations. Once the type has been extended then
run-time dispatching of operations is required to ensure the appropriate
operation is called for a particular instance of the family of types.
Earlier in this section, a simple class for the date type was introduced.

class Date {
int day, month, year;
}
This example only illustrates how data items can be grouped together. The
full facilities of a class allow the data items (or instance variables or fields as
Java calls them) to be encapsulated and, hence, abstract data types to be
defined. As an example, consider the class for a queue abstraction.
First, a package to contain the queue can be declared (if there is no
named pack- age, then the system assumes an unnamed package). Items
from other packages can be imported. Then classes to be declared inside the
package are given. One of these classes Queue is declared as public, and it is
only this that can be accessed outside the package. The keyword public is
termed a modifier in Java, the other ones for classes include abstract and final.
An abstract class is one from which no objects can be created. Hence, the class
has to be extended (to produce a subclass) and that subclass made non-
abstract before objects can exist. A final modifier indicates that the class
cannot be subclassed. No modifier indicates that the class is only accessi- ble
within the package. A class can have more than one modifier but certain
combina- tions, such as abstractand final, are meaningless.

Each class can declare local instance variables (or fields), constructor methods
and ordinary (member) methods. A static field is a class-wide field and is shared between
all instances of the owning class. The field is accessible even if there are no

instances of the class. Constructor methods have the same name as their associated class.
An appropriate constructor method is automatically called when objects of the class are
created. All methods of the object can also have associated modifiers. These dictate the
accessibility of the method; public, protected and private are allowed. Public methods allow
full access, protected allows access only from within the same package or from with a
subclass of the defining class and private allows access only from within the defining class.
Instance variables can also have these modifiers. If no modifier is given, the access is
restricted to the package. Static methods (class-wide methods) can be invoked without
reference to an object. They, therefore, can only access static fields or other static methods.
Member methods and instance variables can have other modifiers which
will be introduced throughout this book.
The code for the Queue class can now be given.

package queues; // package name

import somepackage.Element; // import element type
class QueueNode { // class local to packageElement data; //
queued data item
QueueNode next; // reference to next QueueNode
}

public class Queue {

// class available from outside the package
public Queue() { // public constructorfront = null;
back = null;
}

public void insert(Element E) { // visible methodQueueNode

newNode = new QueueNode(); newNode.data = E;
newNode.next = null;
if(empty()) { front = newNode;
}

else {
back.next = newNode;
}
back = newNode;
}
public Element remove() { //visible method
ifempty()) {
Element
tmp= front.data;
front = front.next; if(empty())
back = null;
return tmpE;
}
// Garbage collection will free up the QueueNode
// object which is now dangling.
return null; // queue empty
}
public boolean empty() { // visible method
return (front == null);
}
private QueueNode front, back; // instance variables
}

Java 1.5 has introduced extra facilities for generic programming. The above
example assumed that the queue was for the Element class. To generalise this
class so that it deals with any element, the Element is defined as a generic
parameter:

package queues; // package name

class QueueNode<Element> { // class local to packageElement data; //
generic queued data item QueueNode next; // reference to next
QueueNode
}
public class Queue<Element> {
// class available from outside the package
public Queue() { // public constructor
... // as before
}
.. // as before
}
The queue can now be instantiated for a particular class

Queue<String> dictionary = new Queue<String>();

 CHAPTER 4

CONCLUSION
Throughout this internship, I have explored various aspects of Java
programming language, from its foundational concepts to advanced
object-oriented principles. Starting with an exploration of Java's
origins and evolution, we traced its journey from a language
designed for embedded systems to its current ubiquitous role in
enterprise software development. Key features such as identifiers,
primitive data types, and structured data types were essential in
understanding Java's syntax and data handling capabilities.
Moving forward, we delved into more advanced topics like
reference types, exception handling, and control structures, which
are crucial for building robust and error-resilient applications.
Procedures, functions, object-oriented programming paradigms, and
the concept of packages and classes provided a deeper insight into
Java's modular and scalable approach to software development.
In conclusion, this internship has not only equipped me with
practical Java programming skills but also deepened my
understanding of software development principles. I look forward
to applying these skills in future projects and continuing to explore
the dynamic field of Java development.
 CHAPTER 4
REFERENCES
ensure to include proper references to the sources you consulted
during your research. These might include textbooks, online
resources, official Java documentation, and any other relevant
materials that helped you understand and implement Java concepts
effectively.
1. Herbert Schildt. "Java: The Complete Reference, Eleventh
Edition". McGraw-Hill Education, 2018.
Oracle Corporation. "The Java Tutorials". Available online:
https://docs.oracle.com/javase/tutorial