Вы находитесь на странице: 1из 37

A

PRACTICAL TRAINING
REPORT
ON

Submitted by
Shubham Saini

Core and Advance Java

11EBKCS053

Submitted in partial fulfillment for the Degree


Organization

of

(Where the training is

B.Tech

performed)
CMC Limited

in
Computer Engineering

Training Supervisor
(under whom the training
is performed)

Session 2014

Mr. Saurabh Sharma


+919782323968

2014
DEPARTMENT OF COMPUTER ENGINEERING

B.K. BIRLA INSTITUTE OF ENGINEERING &TECHNOLOGY

PILANI - 333 031 (RAJ)


(Affiliated to Rajasthan Technical University, Kota)

1|Page

2|Page

ACKNOWLEDGEMENTS
This work would not been possible, but it is the wealth of experience and acknowledges that is
generated within the portals of B.K. Birla Institute of Engineering and Technology, Pilani, which
enlightened my path to complete my training.
First and foremost I wish to place my profound gratitude and sincere thanks to respected trainee
Mr. Saurabh Sharma for his valuable time and tireless efforts without which this work would not
have completed on time.
I also like to thank Dr. P.S. Bhatnagar (Director, B.K. Birla Institute of Engineering and
technology) and Mr. Shridhar B. Dandin(Dean, B. K. Birla Institute of Engineering and
Technology) for providing me with highly motivating and vibrant atmosphere in the college and
department.
Before bring it to end I would like to add little heartfelt words to all of my friends who were part
of this training.

Date:

31/07/2014

Shubham Saini
11EBKCS053
CS 4th Year

3|Page

CONTENTS
1. Java language Features

2. Object Oriented Concept

3. Properties of Object

4. Simple Java Program Example

10

5.

Data types , Variable

11

6. Declaration of a Variable

11

7. Type Conversion

12

8. Class Fundamentals

13

9. General Form of a Class

13

10. Declaring Object & their Effect on Memory

13

11. Inheritance

14

12. Types of Inheritance

15

13. Casting in Inheritance

16

14. Final Keyword

17

15. Packages & Interfaces

17

16. Importing Package

18

17. Access Specifier

18

18. Interfaces

19

19. Implementing Interface

19

20. Exception Handling

19

21. Exception Classes

20

22. Throws Keyword

21

23. Exception Mechanism

21

24. Finally keyword

21

25. Finally Mechanism

22

26. Multithreaded Programming

22

27. Processing of Threads

22

28. Life Cycle of Threads

22

29. Two ways of Creating a Thread

23

4|Page

30. Garbage Collection

24

31. Advantage of Garbage Collection

24

32. Generic Classes

24

33. File Input Output System

25

34. Byte Streams

26

35. I/O Streams

26

36. Character Streams

28

37. Standard Streams

29

38. The Delegation Event Model

29

39. Events

29

40. Event Listeners

31

41. Basic Event Handling

31

42. Event Class Hierarchy

31

43. Event Classes

31

44. Event Sources

33

45. Event Interfaces

33

46. GUI Class Hierarchy

34

47. Conclusion

36

5|Page

JAVA LANGUAGE FEATURES:


1. Simple
2. Object-Oriented
3. Portable
4. Secured
5. Robust
6. Architecture neutral
7. Portable
8. Dynamic
9. Interpreted
10. Multithreaded
11. Distributed
12. Applet

Object Oriented Concept:1.

Classes

2.

Objects

3.

Data Encapsulation

4.

Polymorphism

5.

Data Hiding

6.

Inheritance

7.

Data Abstraction

8.

Message Passing

SIMPLE:
Java was designed to be easy for the professional programmer to learn and use effectively
Assuming that you have some programming experience, you will not find Java hard to master if
you already understand the basic concepts of object-oriented programming, learning Java will be
even easier. Best of all, if you are an experienced C++ programmer, moving to Java will require
very little effort. Because Java inherits the C/C++ syntax.

6|Page

OBJECT-ORIENTED:
Although influenced by its predecessors, Java was not designed to be source-code compatible
with any other language. This allowed the Java team the freedom to design with a blank slate.
One outcome of this was a clean, usable, pragmatic approach to objects. The object model in
Java is simple and easy to extend, while primitive types, such as integers, are kept as highperformance non objects.
1. Classes
2. Objects
3. Data Encapsulation
4. Polymorphism
5. Data Hiding
6. Inheritance
7. Data Abstraction
8. Message Passing
ROBUST:
The multiplatform environment of the Web places extraordinary demands on a program, because
the program must execute reliably in a variety of systems. Thus, the ability to create robust
programs was given a high priority in the design of Java. To gain reliability, Java restricts you in
a few key areas to force you to find your mistakes early in program development. At the same
time, Java frees you from having to worry about many of the most common causes of
programming errors. Because Java is a strictly typed language, it checks your code at compile
time.
MULTITHREADED:
Java was designed to meet the real-world requirement of creating interactive, networked
programs. To accomplish this, Java supports multithreaded programming, which allows you to
write programs that do many things simultaneously. The Java run-time system comes with an
elegant yet sophisticated solution for multi process synchronization that enables you to construct
smoothly running interactive systems. Javas easy-to-use approach to multithreading allows you
to think about the specific behavior of your program, not the multitasking subsystem.

7|Page

ARCHITECTURE-NEUTRAL:
A central issue for the Java designers was that of code longevity and portability. One of the main
problems facing programmers is that no guarantee exists that if you write a program today, it will
run tomorroweven on the same machine. Operating system upgrades, processor upgrades, and
changes in core system resources can all combine to make a program malfunction. The Java
designers made several hard decisions in the Java language and the Java Virtual Machine in an
attempt to alter this situation. Their goal was write once; run anywhere, anytime, forever. To a
great extent, this goal was accomplished.
INTERPRETED AND HIGH PERFORMANCE
As described earlier, Java enables the creation of cross-platform programs by compiling into an
intermediate representation called Java bytecode. This code can be executed on any system that
implements the Java Virtual Machine. Most previous attempts at cross-platform solutions have
done so at the expense of performance. As explained earlier, the Java bytecode was carefully
designed so that it would be easy to translate directly into native machine code for very high
performance by using a just-in-time compiler. Java run-time systems that provide this feature
lose none of the benefits of the platform-independent code.
DISTRIBUTED:
Java is designed for the distributed environment of the Internet because it handles TCP/IP
protocols. In fact, accessing a resource using a URL is not much different from accessing a file.
Java also supports Remote Method Invocation (RMI). This feature enables a program to invoke
methods across a network.
DYNAMIC:
Java programs carry with them substantial amounts of run-time type information that is used to
verify and resolve accesses to objects at run time. This makes it possible to dynamically link
code in a safe and expedient manner. This is crucial to the robustness of the Java environment, in
which small fragments of bytecode may be dynamically updated on a running system.

8|Page

PORTABLE:
Portability is a major aspect of the Internet because there are many different types of computers
and operating systems connected to it. If a Java program were to be run on virtually any
computer connected to the Internet, there needed to be some way to enable that program to
execute on different systems. For example, in the case of an applet, the same applet must be able
to be downloaded and executed by the wide variety of CPUs, operating systems, and browsers
connected to the Internet. It is not practical to have different versions of the applet for different
computers. The same code must work on all computers. Therefore, some means of generating
portable executable code was needed. As you will soon see, the same mechanism that helps
ensure security also helps create portability.
SECURITY:
As you are likely aware, every time you download a normal program, you are taking a risk,
because the code you are downloading might contain a virus, Trojan horse, or other harmful
code. At the core of the problem is the fact that malicious code can cause its damage because it
has gained unauthorized access to system resources. In order for Java to enable applets to be
downloaded and executed on the client computer safely, it was necessary to prevent an applet
from launching such an attack.

PROPERTIES OF OBJECTS:1. IDENTITY


2. STATE
3. BEHAVIOR

An object's state is defined by the attributes of the object and by the values these have.

An attribute is a feature of an object, which distinguishes it from other kinds of objects.


For example, one of the attributes of any car object is that it is capable of movement it
has a speed.

The ways in which an object behaves are determined by its operations. So when an object
needs to act on another object to retrieve data, for instance it uses an operation.

9|Page

An operation occurs when a message is passed between two objects, allowing some
function to be performed.

For security reasons, some operations and attributes in a class or object are not visible to
other classes. This protects a program against malicious damage. And it prevents data
being accidentally deleted or overwritten by other parts of the computer program.

The hidden parts of a class can be accessed only indirectly, through the visible parts of
the class.

Objects are representations of abstract or real things. Their use in object-oriented


programming is to allow designers to model the world accurately.

Objects represent particular instances of things, and classes represent types of object.
Different classes are used for different problem domains.

States are the conditions in which objects exist. An object's state is defined by its
attributes. An object's attributes are usually static, and the values of the attributes are
usually dynamic.

The term "behavior" refers to how objects interact with each other, and it is defined by
the operations an object can perform. There are five kinds of operations: modifiers,
selectors, iterators, constructors, and destructors. No matter what its attributes and
operations are, an object is always uniquely itself. It retains its identity regardless of
changes to its state or behavior.

SIMPLE JAVA PROGRAM EXAMPLE:class First


{
public static void main(String[] arguments)
{
System.out.println("Lets do something using Java technology.");
}
}

OUTPUT:-

10 | P a g e

Fig. 1
DATATYPES, VARIABLES:DATATYPES:1. INTEGER

Byte

Short

Int

long

2. FLOATING POINT

Float

double

3. CHARACTER

char

4. BOOLEAN
VARIABLES:DECLARATION OF VARIABLE:In Java, all variables must be declared before they can be used. The basic form of a variable
declaration is shown here:
type identifier [ = value ][, identifier [= value ] ];
Here are several examples of variable declarations of various types. Note that some include an
initialization.
int a, b, c;

11 | P a g e

// declares three int variables, a, b, and c.

int d = 3, e, f = 5;

// declares three more int varibles, initializing


// d and f.

byte z = 22;

// initializes z.

double pi = 3.14159;

// declares an approximation of pi.

char x = 'x';

// the variable x has the value 'x'.

TYPE CONVERSION:-

Fig.2

CLASS FUNDAMENTALS:Perhaps the most important thing to understand about a class is that it defines a new data type.
Once defined, this new type can be used to create objects of that type. Thus, a class is a template

12 | P a g e

for an object, and an object is an instance of a class. Because an object is an instance of a class,
you will often see the two words object and instance used interchangeably.
GENERAL FORM OF A CLASS:-

Fig.3
A SIMPLE CLASS:class Box{
double width;
double height;
double depth;
}
DECLARING OBJECTS AND THEIR EFFECT:-

13 | P a g e

Fig.4
EXAMPLE

14 | P a g e

OF

METHOD:-

Fig.5

INHERITENCE:
Java Inheritance defines an is-a relationship between a superclass and its subclasses. This means
that an object of a subclass can be used wherever an object of the superclass can be used. Class
Inheritance in java mechanism is used to build new classes from existing classes. The inheritance
relationship is transitive: if class x extends class y, then a class z, which extends class x, will also
inherit from class y. For example a car class can inherit some properties from a General vehicle
class. Here we find that the base class is the vehicle class and the subclass is the more specific
car class. A subclass must use the extends clause to derive from a super class which must be
written in the header of the subclass definition. The subclass inherits members of the superclass
and hence promotes code reuse. The subclass itself can add its own new behavior and properties.
The java.lang.Object class is always at the top of any Class inheritance hierarchy.
TYPES OF INHERITENCE:-

Fig.6
INHERITANCE EXAMPLE:class Box
{
double width; double height; double depth;
Box()
{
}

15 | P a g e

Box(double w, double h, double d)


{ width = w; height = h; depth = d;
}
void getVolume()
{ System.out.println("Volume is : " + width * height * depth);
}
}
public class MatchBox extends Box
{
double weight;
MatchBox() { }
MatchBox(double w, double h, double d, double m)
{ super(w, h, d);
weight = m;
}
public static void main(String args[])
{ MatchBox mb1 = new MatchBox(10, 10, 10,

10);

mb1.getVolume();

System.out.println("width of MatchBox 1 is " + mb1.width); System.out.println("height of


MatchBox 1 is " + mb1.height);
System.out.println("depth of MatchBox 1 is " + mb1.depth); System.out.println("weight of
MatchBox 1 is " + mb1.weight); }
}

CASTING IN INHERITANCE:-

Fig.7
FINAL KEYWORD:USES:-

16 | P a g e

Used to prevent Inheritance.


Used to prevent Overriding.
Used to declare constant field and variables.

PACKAGES AND INTERFACES:DEFINING A PACKAGE:To create a package is quite easy: simply include a package command as the first statement in a
Java source file. Any classes declared within that file will belong to the specified package. The
package statement defines a name space in which classes are stored. If you omit the package
statement, the class names are put into the default package, which has no name. (This is why you
havent had to worry about packages before now.)
This is the general form of the package statement:
package pkg;

//Here, pkg is the name of the package.

Java uses file system directories to store packages. For example, the .class files for any classes
you declare to be part of MyPackage must be stored in a directory called MyPackage. Remember
that case is significant, and the directory name must match the package name exactly. More than
one file can include the same package statement. The package statement simply specifies to
which package the classes defined in a file belong. It does not exclude other classes in other files
from being part of that same package. Most real-world packages are spread across many files.
You can create a hierarchy of packages. To do so, simply separate each package name from the
one above it by use of a period. The general form of a multileveled package statement is shown
here:
package pkg1[.pkg2[.pkg3]];

IMPORTING PACKAGES:Given that packages exist and are a good mechanism for compartmentalizing diverse classes
from each other, it is easy to see why all of the built-in Java classes are stored in packages. There

17 | P a g e

are no core Java classes in the unnamed default package; all of the standard classes are stored in
some named package. Since classes within packages must be fully qualified with their package
name or names, it could become tedious to type in the long dot-separated package path name for
every class you want to use. For this reason, Java includes the import statement to bring certain
classes, or entire packages, into visibility. Once imported, a class can be referred to directly,
using only its name. The import statement is a convenience to the programmer and is not
technically needed to write a complete Java program. If you are going to refer to a few dozen
classes in your application, however, the import statement will save a lot of typing. In a Java
source file, import statements occur immediately following the package statement (if it exists)
and before any class definitions. This is the general form of the import statement:
import pkg1 [.pkg2].(classname | *);

ACCESS SPECIFIER:1. Public


2. Private
3. Protected
4. Default(friendly or no modifier)
ACCESSIBILITY OF CLASS MEMBERS IN PACKAGES:-

Fig.8

INTERFACES:

18 | P a g e

An interface is defined much like a class. This is a simplified general form of an interface:
access modifier interface name {
return-type method-name1(parameter-list);
return-type method-name2(parameter-list);
type final-varname1 = value;
type final-varname2 = value;
//
return-type method-nameN(parameter-list);
type final-varnameN = value;
}
IMPLEMENTING INTERFACES:Once an interface has been defined, one or more classes can implement that interface. To
implement an interface, include the implements clause in a class definition, and then create the
methods defined by the interface. The general form of a class that includes the implements
clause looks like this:
class classname [extends superclass] [implements interface [,interface]] {
// class-body
}

EXCEPTION HANDLING:EXCEPTION-HANDLING FUNDAMENTALS:A Java exception is an object that describes an exceptional (that is, error) condition that has
occurred in a piece of code. When an exceptional condition arises, an object representing that
exception is created and thrown in the method that caused the error. That method may choose to
handle the exception itself, or pass it on. Either way, at some point, the exception is caught and
processed.
Java exception handling is managed via five keywords: try, catch, throw, throws, and finally.
EXCEPTION CLASSES:-

19 | P a g e

Fig.9
EXCEPTION EXAMPLE:class Exc {
public static void main(String args[]) {
int d, a;
try { // monitor a block of code.
d = 0;
a = 42 / d;
System.out.println("This will not be printed.");
} catch (ArithmeticException e) { // catch divide-by-zero error
System.out.println("Division by zero.");
}
System.out.println("After catch statement.");
}
}
This program generates the following output:
Division by zero. After catch statement.

20 | P a g e

THROWS KEYWORD:-

Fig.10
EXCEPTION MECHANISM:-

Fig.11

FINALLY KEYWORD:The finally block is a block that is always executed. It is mainly used to perform some important
tasks such as closing connection, stream etc.

21 | P a g e

FINALLY MECHANISM DIAGRAM:

Fig.12

MULTITHREADED PROGRAMMING:Multithreading is a process of executing multiple threads simultaneously. Thread is basically a


lightweight subprocess, a smallest unit of processing. Multiprocessing and multithreading, both
are used to achieve multitasking. But we use multithreading than mulitprocessing because
threads share a common memory area. They don't allocate separate memory area so save
memory, and context-switching between the threads takes less time than processes.
Multithreading is mostly used in games, animation etc.
LIFE CYCLE OF A THREAD (THREAD STATES):-

22 | P a g e

Fig.13

TWO WAYS OF CREATING THREADS:1. BY EXTENDING THREAD CLASS


2. BY IMPLEMENTING RUNNABLE INTERFACE
1. class Multi extends Thread{
public void run(){
System.out.println("thread is running...");
}
public static void main(String args[]){
Multi t1=new Multi();
t1.start();
}
}
2. class Multi3 implements Runnable{
public void run(){
System.out.println("thread is running...");
}
public static void main(String args[]){
Multi3 m1=new Multi3();

23 | P a g e

Thread t1 =new Thread(m1);


t1.start();
}
}

GARBAGE COLLECTION:
In java, garbage means unreferenced objects. Garbage Collection is process of reclaiming the
runtime unused memory automatically.
ADVANTAGE OF GARBAGE COLLECTION:
1. It makes java memory efficient because garbage collector removes the unreferenced
objects from heap memory.
2. It is automatically done by the garbage collector so we don't need to make extra efforts.
EXAMPLE OF GARBAGE COLLECTION:class Simple{
public void finalize(){
System.out.println("object is garbage collected");
}
public static void main(String args[]){
Simple s1=new Simple();
Simple s2=new Simple();
s1=null;
s2=null;
System.gc();
}
}

GENERIC CLASSES:
A generic class declaration looks like a non-generic class declaration, except that the class name
is followed by a type parameter section. As with generic methods, the type parameter section of a
generic class can have one or more type parameters separated by commas. These classes are
known as parameterized classes or parameterized types because they accept one or more
parameters.

24 | P a g e

GENERIC EXAMPLE:public class Box<T>


{
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
public static void main(String[] args){
Box<Integer> integerBox = new Box<Integer>();
Box<String> stringBox = new Box<String>();
integerBox.add(new Integer(10));
stringBox.add(new String("Hello World"));
System.out.print integerBox.get());
System.out.print( stringBox.get());
}
}

FILE INPUT OUTPUT SYSTEM:The java.io package contains nearly every class you might ever need to perform input and output
(I/O) in Java. All these streams represent an input source and an output destination. The stream in
the java.io package supports many data such as primitives, Object, etc.
A stream can be defined as a sequence of data. The InputStream is used to read data from a
source and the OutputStream is used for writing data to a destination.
Java provides strong but flexible support for I/O related to Files.
I/O:

Usual Purpose: storing data to nonvolatile devices, e.g. harddisk

Classes provided by package java.io

25 | P a g e

Data is transferred to devices by streams.

Program

Device

STREAMS:Streams in JAVA are Objects, of course !Having

2 types of streams (text / binary) and

2 directions (input / output)

RESULTS IN 4 BASE-CLASSES DEALING WITH I/O:


1. Reader: text-input
2. Writer: text-output
3. InputStream: byte-input
4. OutputStream: byte-output
I/O STREAMS:
A stream is a sequence of bytes (or data or objects) that flow from a source to a destination.
In a program, we read information from an input stream and write information to an output
stream

Fig.14

26 | P a g e

Fig.15
JAVA.IO.INPUTSTREAM AND ITS SUBCLASSES:

Fig.16
THE JAVA.IO.OUTPUTSTREAM AND ITS SUBCLASSES:

Fig.17

27 | P a g e

JAVA.IO.READER AND ITS SUBCLASSES:

Fig.18
JAVA.IO.WRITER AND ITS SUBCLASSES:

Fig.19
CHARACTER STREAMS:
Java Byte streams are used to perform input and output of 8-bit bytes, where as Java Character
streams are used to perform input and output for 16-bit unicode. Though there are many classes
related to character streams but the most frequently used classes are , FileReader and FileWriter..
Though internally FileReader uses FileInputStream and FileWriter uses FileOutputStream but
here major difference is that FileReader reads two bytes at a time and FileWriter writes two bytes
at a time.

28 | P a g e

STANDARD STREAMS:

All the programming languages provide support for standard I/O where user's program
can take input from a keyboard and then produce output on the computer screen. If you
are aware if C or C++ programming languages, then you must be aware of three standard

devices STDIN, STDOUT and STDERR. Similar way Java provides following three
standard streams

Standard Input: This is used to feed the data to user's program and usually a keyboard is
used as standard input stream and represented as System.in.

Standard Output: This is used to output the data produced by the user's program and
usually a computer screen is used to standard output stream and represented as
System.out.

Standard Error: This is used to output the error data produced by the user's program and
usually a computer screen is used to standard error stream and represented as System.err.

THE DELEGATION EVENT MODEL:


The modern approach to handling events is based on the delegation event model, which defines
standard and consistent mechanisms to generate and process events. Its concept is quite simple: a
source generates an event and sends it to one or more listeners. In this scheme, the listener
simply waits until it receives an event. Once an event is received, the listener processes the event
and then returns. The advantage of this design is that the application logic that processes events
is cleanly separated from the user interface logic that generates those events. A user interface
element is able to delegate the processing of an event to a separate piece of code.
EVENTS:An event is an object that describes a state change in a source.
-It can be generated as a consequence of a person interacting with the elements in a graphical
user interface.
EXAMPLES:

29 | P a g e

Pressing a button, entering a character via the keyboard, selecting an item in a list, and clicking
the mouse, timer expires, counter, h/w or s/w failure.
EVENT SOURCES:

A source is an object that generates an event. This occurs when the internal state of that
object changes in some way. Sources may generate more than one type of event.

A source must register listeners in order for the listeners to receive notifications about a
specific type of event. Each type of event has its own registration method. Here is the
general form:

public void add Type Listener (Type Listener el)

Here, Type is the name of the event, and el is a reference to the event listener. For
example, the method that registers a keyboard event listener is called addKeyListener( ).
The method that registers a mouse motion listener is called addMouseMotionListener( ).
When an event occurs, all registered listeners are notified and receive a copy of the event
object. This is known as multicasting the event. In all cases, notifications are sent only to
listeners that register to receive them.

Some sources may allow only one listener to register. The general form of such a method
is this:

public void add Type Listener (Type Listener el)

throws java.util.TooManyListenersException

Here, Type is the name of the event, and el is a reference to the event listener. When such
an event occurs, the registered listener is notified. This is known as unicasting the event.

A source must also provide a method that allows a listener to unregister an interest in a
specific type of event. The general form of such a method is this:

public void remove Type Listener (Type Listener el)

Here, Type is the name of the event, and el is a reference to the event listener. For
example, to remove a keyboard listener, you would call removeKeyListener( ).The
methods that add or remove listeners are provided by the source that generates events.

30 | P a g e

For example, the Component class provides methods to add and remove keyboard and
mouse event listeners.
EVENT LISTENERS:

A listener is an object that is notified when an event occurs.

It must register with one or more sources.

It must implement methods to receive and process these notifications.

The methods that receive and process events are defined in a set of interfaces found in
java.awt.event.

BASIC EVENT HANDLING:The GUI is responsible for constructing the user interface and for connecting (registering)
widgets to listeners.
The listener part implements the appropriate interface for the type of event(s) of interest.
The code (in the action handler) that performs the programs action associated with the event(s).
EVENT CLASS HIERARCHY:-

Fig.20

31 | P a g e

EVENT CLASSES:-

Fig.21

32 | P a g e

EVENT SOURCES:-

Fig.22

33 | P a g e

EVENT

Fig.23

GUI CLASSES HIERARCHY:-

34 | P a g e

INTERFACES:

Fig.24

LAYOUT MANAGERS:

35 | P a g e

The Layout Managers are a set of classes that implements the java.awt.LayoutManager interface
and shelf to position the components in a container. The interface takes a task of laying out the
child components in the container. The task is achieved by resizing and moving the child
components. The advantage of this type of mechanism is that when the container is resized the
layout manager automatically updates the interface.
TYPES OF LAYOUT MANAGERS:
1. Flow Layout (arranges components from Left to Right and from Top to Bottom)
2. Border Layout (arranges components across the borders i.e. NORTH, SOUTH, EAST,
WEST & CENTER)
3. Grid Layout (arranges components in the form of Grids i.e. rows and columns)
4. Card Layout (arranges components in the form of stack)
TYPES OF PANE:
1. Root Pane
2. Layered Pane
3. Content Pane
4. Glass Pane
ARRANGEMENT OF PANES:-

Fig.25

36 | P a g e

CONCLUSION
The aim of the summer training on the java programming language is to introduce the
application on java in todays modern world. This summer training provide very solid start to the
understanding of various aspect of java. As the knowledge of java has become a very important
aspect of computer science students. Java has significant advantage not only as a commercial
language but also a teaching language. It allows to students to learn object oriented programming
without exposing them to the complexity of C++. It provides the kind of rigorous compile time
error checking and also run time error checking. It allows instructors to introduce students to
GUI programming, networking, threads, and other important concepts used in modern days
softwares. So certainly this training will boost up our career in software field.

37 | P a g e

Вам также может понравиться