Summer training report on java se6 technology

SSUUMMMMEERR TTRRAAIINNIINNGG RREEPPOORRTT
OONN JJAAVVAA SSEE66 TTEECCHHNNOOLLOOGGYY
Mp3 music player
SUBMITTED BY SUBMITTED TO
SHAMSHER AHMED
UE113087

SUMMER TRAINING REPORT ON JAVA SE6 TECHNOLOGY 2
SHAMSHER AHMED | UE113087
2
ACKNOWLEDGEMENT
I wish to acknowledge my deep gratitude to Mr.Amrit Singh, teacher at SLR InfoTech
Pvt Ltd., for his cooperation and guidance. I am also thankful to his Lab assistant that
provided staunch support throughout this project and helped me to complete this
project.
Furthermore I would also like to acknowledge with much appreciation the crucial role
of my college Teacher Akashdeep and Mukesh Kumar, who have serious efforts in
guiding me towards programming.
And At Last I would thank my friends for helping me in this project .I have taken
serious efforts in my project efficient And if any bug and error happens, than I am
very very sorry.
SHAMSHER AHMED

3

4

5
1.1 Evolution of Programming Language
The main reason for inventing the computer was to use it for scientific applications. The main
characteristics of these applications are the usage of simple data structures (such as vectors and
matrices) and intensive floating-point arithmetic. ALGOL is representative for this type of
programming languages, being specifically created for scientific applications. The efficiency of
the language was such that, even if the domain required high-performance, ALGOL surpassed
the assembly language.The following are the main domains of software programming:
 Scientific applications
 Business applications
 Artificial intelligence
 System Application
 Domain Specific
 Scripting Language
Business applications developed during the second half of the 20th century used COBOL, a
language that was created in 1960. This is also the first high-level language for business
applications. The demands imposed upon languages used in business applications are: the
capacity of producing reports, precise mechanisms for describing and storing fixed-point
numbers and strings, the efficiency of fixed-point arithmetic.
The characteristic of artificial intelligence languages is that of working with symbols
represented by names. The most frequently used data structure is the linked list. There's also the
requirement of high flexibility for the languages in this domain, thus the dynamic execution of
source code is quite frequent. The functional language LISP, created in 1965, and also its
descendants were highly used in the AI domain. An alternative was the logical programming
language PROLOG, created in early '70s.
System applications consist of the operating system and various programming instruments. Due
to their continuous use, their efficiency is crucial. Another fundamental requirement is having
access to mechanisms for the device interfaces attached to the computer. In the '60s and '70s the
languages PL/S, PL/I, BLISS and Extended ALGOL were widely used in this domain, being
almost completely replaced by C once the UNIX operating system was created. The
requirements for system applications‘ programming languages are: a level close to the assembly
language, high efficiency of the generated binary code and not imposing automated checks (such
as vector limits).

6
Scripting languages have evolved during the last three decades. They are interpreted and
therefore highly flexible. Their evolution has started with the sh language, consisting of
commands that called system subroutines to carry out utilitarian tasks (mainly related to files).
The sh language has subsequently evolved into multiple variants such as ksh and bash. Other
examples of scripting languages are awk, tcl, Perl and JavaScript. The JavaScript language is
presently used on a large scale in dynamic Web pages.
Domain-specific languages (DSLs) were omnipresent during the last four decades. RPG used
for reporting activities, APT for programming industrial robots and GPSS for simulations are
quite representative for this domain. These languages have a restricted applicability that derives
precisely from their high degree of specialization.
The following figure depicts the evolution of the most important high-level languages, starting
with Plankalkül. It was originally presented in Concepts of Programming Languages by Robert
Sebesta and contains various enhancements based on other sources, including Computer
Languages History by Éric Lévénez .

7
Java
At first glance, it may appear that Java was developed specifically for the World Wide Web.
However, interestingly enough, Java was developed independently of the web, and went through
several stages of metamorphosis before reaching its current status of programming language for
the World Wide Web.
According to Java FAQ, Bill Joy, currently a vice president at Sun Microsystems, is widely
believed to have been the person to conceive of the idea of a programming language that later
became Java. In late 1970's, Joy wanted to design a language that combined the best features of
MESA and C.
In an attempt to re-write the UNIX operating system in 1980's, Joy decided that C++ was
inadequate for the job. A better tool was needed to write short and effective programs. It was this
desire to invent a better programming tool that swayed Joy, in 1991, in the direction of Sun's
"Stealth Project" - as named by Scott McNealy, Sun's president.
In January of 1991, Bill Joy, James Gosling, Mike Sheridan, Patrick Naughton (formerly the
project leader of Sun's Open Windows user environment), and several other individuals met in
Aspen, Colorado for the first time to discuss the ideas for the Stealth Project. The goal of the
Stealth Project was to do research in the area of application of computers in the consumer
electronics market. The project was also named "Green" and it was started to make
microprocessors run on different machines (i.e. different platforms). Firsly, it was called
"Greentalk" by James Gosling and file extenstion was .gt.
Initially, they started to develop the project in C++, but they faced many problems as they tried
to extend the C++ compiler. During that time, James Gosling started working on a new language
called Oak which was later in 1995 renamed as Java. Why Oak? Oak is a symbol of strength
and choosen as a national tree of many countries like U.S.A, Germany etc.
The vision of the project was to develop "smart" consumer electronic devices that could all be
centrally controlled and programmed from a handheld-remote control- like device. According to
Gosling, "the goal was ... to build a system that would let us do a large, distributed,
heterogeneous network of consumer electronic devices all talking to each other." With this goal
in mind, the stealth group began work.
There were several criteria that Oak had to meet in order to satisfy the project objective given the
consumer electronics target market. Given the wide array of manufacturers in the market, Oak
would have to be completely platform independent, and function seamlessly regardless of the
type of CPU in the device.

8
For this reason, Oak was designed to be an interpreted language, since it would be practically
impossible for a complied version to run on all available platforms. To facilitate the job of the
interpreter, Oak was to be converted to an intermediate "byte-code" format which is then passed
around across the network, and executed/interpreted dynamically.
Today, with technology such a part of our daily lives, we take it for granted that we can be
connected and access applications and content anywhere, anytime. Because of Java, we expect
digital devices to be smarter, more functional and more entertaining.
In the early 90s, extending the power of network computing to the activities of everyday life was
a radical vision. In 1991, a small group of Sun engineers called the Green Team believed that the
next wave in computing was the union of digital consumer devices and computers. Led by James
Gosling, the team worked around the clock and created the programming language that would
revolutionize our world – Java.
The Green Team demonstrated their new language with an interactive, handheld home-
entertainment controller that was originally targeted at the digital cable television industry.
Unfortunately, the concept was much too advanced for them at the time. But it was just right for
the Internet, which was just starting to take off. In 1995, the team announced that the Netscape
Navigator Internet browser would incorporate Java technology.
Today, Java not only permeates the Internet, but also is the invisible force behind many of the
applications and devices that power our day-to-day lives. From mobile phones to handheld
devises, games and navigation systems to e business solutions, Java is everywhere.
There have been significant changes to Java since the first version, called JDK 1.0, was released.
Newer versions of Java include 1.5 and 1.6 (also known as Java 5 and Java 6, respectively).
Many features in the original version are no longer used. The language has grown much bigger
as new features have been introduced in subsequent versions. Examples include the Swing and
Java 2D graphical toolkits introduced in Java 2, and the generics framework introduced in
Java 5.

9
1.3
Mostly all the previous languages are Structured or we can say that they were procedural
programming means in them processing is to be done in sequence manner and These are also
called the Top down or either they were bottom up Languages.
OOP concentrates more on data rather the procedure to be followed or the structure of the
program. It considers data as a crucial element and work towards its security. It ties data and
functions together under a single entity called class and prevents any modification to the data by
providing access specifies .
Concepts in OOPs
Data Abstraction is that in which A User Can use any of the data and Method from the Class
Without knowing about how this is created So in other words we can say that A user use all the
Functions without Knowing about its detail For Example When a User gives Race to Car The
Car will be Moved but a User doesn‘t know how its Engine Will Work
Inheritance is very popular Concept in OOP This provides the Capability to a user to use the
Predefined Code or the code that is not created by the user himself but if he may wants to use
that code then he can use that code This is Called Inheritance but Always Remember in
Inheritance a user only using the code but he will not be able to change the code that is
previously created he can only use that code
Data Encapsulation is also known as Data Hiding as we know with the inheritance concept of
opps user can use any code that is previously created but if a user wants to use that code then it is
must that previously code must be Public as the name suggests public means for other peoples
but if a code is Private then it will be known as Encapsulate and user will not be able to use that
code So With the help of OPPS we can alter or change the code means we can make the Code as
Private or public This allows us to make our code either as public or private
Polymorphism means many and morphism means many function The Concepts Introduces in
the form of Many behaviors of an object Like an Operator + is used for Addition of Two
Numbers and + is also used for Joining two names The Polymorphism in java Introduces in the
Form of Functions Overloading and in the Form of Constructor Overloading
Dynamic Binding: Binding is used when we call the Code of the Procedure in Binding all the
Code that is Linked with the single procedure is Called When a Call is Made to that Procedure
Then the Compiler will found the Entire code of the Single Procedure if A Compiler will Fond
all the Code of Single Procedure in Compile Time then it is Called as the Early Binding

10
Because Compiler Knows about the code at the time of Compilation but in the Late Binding
Compiler will understand all the Code at Run Time or at the Time of the Execution.
Message Communication is occurred when an object passes the Call to Method of Class for
Execution We Know for executing any method from the class First we have to create the object
of class when an object passes References to function of class then In Message Communication
First of all we have to Create the Object of the Class the we make Communication between the
Object and the Methods of the Class to the class.
1.4
 Write Once, Run Anywhere as the core value proposition of the Java platform.
Translated from business jargon, this means that the most important promise of
Java technology is that you only have to write your application once--for the Java
platform--and then you'll be able to run it anywhere.
Anywhere, that is, that supports the Java platform. Fortunately, Java support is
becoming ubiquitous. It is integrated, or being integrated, into practically all
major operating systems. It is built into the popular web browsers, which places it
on virtually every Internet-connected PC in the world. It is even being built into
consumer electronic devices, such as television set-top boxes, PDAs, and cell
phones.
 Security The Java platform allows users to download untrusted code over a
network and run it in a secure environment in which it cannot do any harm: it
cannot infect the host system with a virus, cannot read or write files from the hard
drive, and so forth. This capability alone makes the Java platform unique.
The Java 2 Platform takes the security model a step further. It makes security
levels and restrictions highly configurable and extends them beyond applets. As
of Java 1.2, any Java code, whether it is an applet, a servlet, a JavaBeans
component, or a complete Java application, can be run with restricted
permissions that prevent it from doing harm to the host system.
The security features of the Java language and platform have been subjected to
intense scrutiny by security experts around the world. Security-related bugs, some
of them potentially serious, have been found and promptly fixed. Because of the
security promises Java makes, it is big news when a new security bug is found.
Remember, however, that no other mainstream platform can make security
guarantees nearly as strong as those Java makes. If Java's security is not yet
perfect, it has been proven strong enough for practical day-to-day use and is
certainly better than any of the alternatives.

11
 Network-centric Programming The designers of the Java platform believed in
the importance of networking and designed the Java platform to be network-
centric. From a programmer's point of view, Java makes it unbelievably easy to
work with resources across a network and to create network-based applications
using client/server or multitier architectures. This means that Java programmers
have a serious head start in the emerging network economy.
 Dynamic, Extensible Programs Java is both dynamic and extensible. Java code
is organized in modular object-oriented units called classes. Classes are stored in
separate files and are loaded into the Java interpreter only when needed. This
means that an application can decide as it is running what classes it needs and can
load them when it needs them. It also means that a program can dynamically
extend itself by loading the classes it needs to expand its functionality.
The network-centric design of the Java platform means that a Java application can
dynamically extend itself by loading new classes over a network. An application
that takes advantage of these features ceases to be a monolithic block of code.
Instead, it becomes an interacting collection of independent software components.
Thus, Java enables a powerful new metaphor of application design and
development
 Internationalization The Java language and the Java platform were designed
from the start with the rest of the world in mind. Java is the only commonly used
programming language that has internationalization features at its very core,
rather than tacked on as an afterthought. While most programming languages use
8-bit characters that represent only the alphabets of English and Western
European languages, Java uses 16-bit Unicode characters that represent the
phonetic alphabets and ideographic character sets of the entire world. Java's
internationalization features are not restricted to just low-level character
representation, however. The features permeate the Java platform, making it
easier to write internationalized programs with Java than it is with any other
environment.
 Performance Java programs are compiled to a portable intermediate form known
as byte codes, rather than to native machine-language instructions. The Java
Virtual Machine runs a Java program by interpreting these portable byte-code
instructions. This architecture means that Java programs are faster than programs
or scripts written in purely interpreted languages, but they are typically slower
than C and C++ programs compiled to native machine language. Keep in mind,
however, that although Java programs are compiled to byte code, not all of the
Java platform is implemented with interpreted byte codes. For efficiency,
computationally intensive portions of the Java platform--such as the string-
manipulation methods--are implemented using native machine code.
Although early releases of Java suffered from performance problems, the speed of
the Java VM has improved dramatically with each new release. The VM has been

12
highly tuned and optimized in many significant ways. Furthermore, many
implementations include a just-in-time compiler, which converts Java byte
codes to native machine instructions on the fly. Using sophisticated JIT
compilers, Java programs can execute at speeds comparable to the speeds of
native C and C++ applications.
Java is a portable, interpreted language; Java programs run almost as fast as
native, non-portable C and C++ programs. Performance used to be an issue that
made some programmers avoid using Java. Now, with the improvements made in
Java 1.2, performance issues should no longer keep anyone away. In fact, the
winning combination of performance plus portability is a unique feature no other
language can offer
In every programming language we start with hello world program .Now let us see hello world
program in Java.
public class MyFirstJavaProgram {
public static void main(String []args) {
System.out.println("Hello World");
}
}

13
Some important points while designing a Java program
 Case Sensitivity Java is case sensitive which means identifier Hello and hello
would have different meaning in Java. Class Names - For all class names the first
letter should be in Upper Case. If several words are used to form a name of the
class each inner words first letter should be in Upper Case.
Example class MyFirstJavaClass
 Method Names All method names should start with a Lower Case letter. If
several words are used to form the name of the method, then each inner word's
first letter should be in Upper Case.
Example public void myMethodName ()
 Program File Name - Name of the program file should exactly match the class
name. When saving the file you should save it using the class name (Remember
java is case sensitive) and append '.java' to the end of the name. (if the file name
and the class name do not match your program will not compile).
Example- Assume 'MyFirstJavaProgram' is the class name. Then the file should
be saved as 'MyFirstJavaProgram.java'
 public static void main(String args[]) - java program processing starts from the
main() method which is a mandatory part of every java program..
All Java components require names. Names used for classes, variables and methods are called
identifiers. In java there are several points to remember about identifiers. They are as follows:
 All identifiers should begin with a letter (A to Z or a to z), currency character ($)
or an underscore (_).
 After the first character identifiers can have any combination of characters.
 A key word cannot be used as an identifier.
 Identifiers are case sensitive.
Examples of legal identifiers: age, $salary, _value, __1_value
Examples of illegal identifiers: 123abc, -salary
These reserved words may not be used as constant or variable or any other identifier names.Java
has about 49 keywords.

14
Java has very flexible three looping mechanisms. You can use one of the following three loops:
 while Loop
 do...while Loop
 for Loop
Syntax
 while loop
while(Boolean_expression){
//Statements
}
 for loop
for(initialization; Boolean_expression; update){
/ /Statements

15
}
The flow of control in a for loop:
 The initialization step is executed first, and only once. This step allows you to declare
and initialize any loop control variables. You are not required to put a statement here, as
long as a semicolon appears.
 Next, the Boolean expression is evaluated. If it is true, the body of the loop is executed. If
it is false, the body of the loop does not execute and flow of control jumps to the next
statement past the for loop.
 After the body of the for loop executes, the flow of control jumps back up to the update
statement. This statement allows you to update any loop control variables. This statement
can be left blank, as long as a semicolon appears after the Boolean expression.
 The Boolean expression is now evaluated again. If it is true, the loop executes and the
process repeats itself (body of loop, then update step, then Boolean expression). After the
Boolean expression is false, the for loop terminates.
 do while
do{
//Statements
}while(Boolean_expression);
There are two types of decision making statements in Java. They are:
 if statements
 switch statements
 The if Statement:
An if statement consists of a Boolean expression followed by one or more statements.

16
Syntax:
if(Boolean_expression){
//Statements will execute if the Boolean expression is true}
If the Boolean expression evaluates to true then the block of code inside the if statement will
beexecuted. If not the first set of code after the end of the if statement (after the closing curly
brace) will be executed.
 if...else Statement:
An if statement can be followed by an optional else statement, which executes when the Boolean
expression is false.
Syntax:
If (Boolean expression){
//Executes when the Boolean expression is true;}
else {
//Executes when the Boolean expression is false}
 if...else if...else Statement:
An if statement can be followed by an optional else if...else statement, which is very
useful to test various conditions using single if...else if statement.
When using if , else if , else statements there are few points to keep in mind.
An if can have zero or one else's and it must come after any else if's.
An if can have zero to many else if's and they must come before the else.
Once an else if succeeds, none of the remaining else if's or else's will be tested.Syntax:
if(Boolean_expression 1){
//Executes when the Boolean expression 1 is true
}else if(Boolean_expression 2){
}else if(Boolean_expression 3){
}else {
//Executes when the none of the above condition is true.
}
The switch Statement
A switch statement allows a variable to be tested for equality against a list of values. Each value
is called a case, and the variable being switched on is checked for each case.

17
Syntax:
switch(expression){
case value :
//Statements
break; //optional
case value :
//Statements
break; //optional
//You can have any number of case statements.
default : //Optional
//Statement}
The following rules apply to a switch statement:
 The variable used in a switch statement can only be a byte, short, int, or char.
 You can have any number of case statements within a switch. Each case is followed by
the value to be compared to and a colon.
 The value for a case must be the same data type as the variable in the switch and it must
be a constant or a literal.
 When the variable being switched on is equal to a case, the statements following that case
will execute until a break statement is reached.
 When a break statement is reached, the switch terminates, and the flow of control jumps
to the next line following the switch statement.
 Not every case needs to contain a break. If no break appears, the flow of control will fall
through to subsequent cases until a break is reached.
A switch statement can have an optional default case, which must appear at the end of the
switch. The default case can be used for performing a task when none of the cases is true. No
break is needed in the default case.
Example:
public class Test {
public static void main(String args[]){
char grade = 'C';
switch(grade)
{
case 'A' :
System.out.println("Excellent!");
break;
case 'B' :
case 'C' :
System.out.println("Well done");
break;
case 'D' :

18
System.out.println("You passed");
case 'F' :
System.out.println("Better try again");
break;
default :
System.out.println("Invalid grade");
}
System.out.println("Your grade is " + grade);
}
}
Compile and run
$ java Test
Well done
Your grade is a C
Strings, which are widely used in Java programming, are a sequence of characters. In the Java
programming language, strings are objects.
Creating Strings
The most direct way to create a string is to write:
String greeting = "Hello world!";
Whenever it encounters a string literal in your code, the compiler creates a String object with its
value in this case, "Hello world!'.As with any other object, you can create String objects by using
the new keyword and a constructor. The String class has eleven constructors that allow you to
provide the initial value of the string using different sources, such as an array of characters.
public class StringDemo{
public static void main(String args[]){
char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.'};
String helloString = new String(helloArray);
System.out.println( helloString );
}

19
Some Basic String class methods are
S No String class Methods
1
char charAt(int index)
Returns the character at the specified index.
2
int compareTo(Object o)
Compares this String to another Object.
3
int compareTo(String anotherString)
Compares two strings lexicographically.
4
int compareToIgnoreCase(String str)
Compares two strings lexicographically, ignoring case differences.
5
String concat(String str)
Concatenates the specified string to the end of this string.
6
boolean contentEquals(StringBuffer sb)
Returns true if and only if this String represents the same sequence of characters as the specified
StringBuffer.
7
static String copyValueOf(char[] data)
Returns a String that represents the character sequence in the array specified.
8
static String copyValueOf(char[] data, int offset, int count)
Returns a String that represents the character sequence in the array specified.
9
boolean endsWith(String suffix)
Tests if this string ends with the specified suffix.
10
boolean equals(Object anObject)
Compares this string to the specified object.
11
boolean equalsIgnoreCase(String anotherString)
Compares this String to another String, ignoring case considerations.
12
byte getBytes()
Encodes this String into a sequence of bytes using the platform's default charset, storing the result into a
new byte array.
13
byte[] getBytes(String charsetName
Encodes this String into a sequence of bytes using the named charset, storing the result into a new byte
array.
14
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
Copies characters from this string into the destination character array.
15
int hashCode()
Returns a hash code for this string.
16
int indexOf(int ch)
Returns the index within this string of the first occurrence of the specified character.
17
int indexOf(int ch, int fromIndex)
Returns the index within this string of the first occurrence of the specified character, starting the search at
the specified index.
18
int indexOf(String str)
Returns the index within this string of the first occurrence of the specified substring.
19
int indexOf(String str, int fromIndex)
Returns the index within this string of the first occurrence of the specified substring, starting at the
specified index.
A Java method is a collection of statements that are grouped together to perform an operation.
When you call the System.out.println method, for example, the system actually executes several
statements in order to display a message on the console.

20
Main difference between methods and function is method always declared and defined inside
the class while function may or may not declared inside the class.
Creating a Method
A method has the following syntax:
modifier returnValueType methodName(list of parameters) {
// Method body;
}
A method definition consists of a method header and a method body. Here are all the parts of a
method:
 The modifier, which is optional, tells the compiler how to call the method. This defines
the access type of the method.
 A method may return a value. The returnValueType is the data type of the value the
method returns. Some methods perform the desired operations without returning a value.
In this case, the returnValueType is the keyword void.
 This is the actual name of the method. The method name and the parameter list together
constitute the method signature.
 A parameter is like a placeholder. When a method is invoked, you pass a value to the
parameter. This value is referred to as actual parameter or argument. The parameter list
refers to the type, order, and number of the parameters of a method. Parameters are
optional; that is, a method may contain no parameters.
 Method Body: The method body contains a collection of statements that define what the
method does.

21
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, localized characters,
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 does provide strong, flexible support for I/O as it relates to files and networks .
Reading from Console
Java input console is accomplished by reading from System.in. To obtain a character-based
stream that is attached to the console, you wrap System.in in a BufferedReader object, to create a
character stream. Here is most common syntax to obtain BufferedReader:
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Reading char and String from console
Once BufferedReader is obtained, we can use read( ) method to reach a character or readLine( )
method to read a stri import java.io.*;
public class BRReadLines {
public static void main(String args[]) throws IOException {
// Create a BufferedReader using System.in
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str; char ch;
System.out.println("Enter lines of text.");
System.out.println("Enter 'end' to quit.");
ch=(char)br.read();
do {
str = br.readLine();

22
System.out.println(str);
} while(!str.equals("end"));System.out.println(―Input Character =‖+ch);
}
}
An exception is a problem that arises during the execution of a program. An exception can occur
for many different reasons, including the following:
 A user has entered invalid data.
 A file that needs to be opened cannot be found.
 A network connection has been lost in the middle of communications or the JVM has run
out of memory.
In java exception handling are three types
 A checked exception is an exception that is typically a user error or a problem that
cannot be foreseen by the programmer. For example, if a file is to be opened, but the
file cannot be found, an exception occurs. These exceptions cannot simply be ignored
at the time of compilation.
 A runtime exception is an exception that occurs that probably could have been
avoided by the programmer. As opposed to checked exceptions, runtime exceptions
are ignored at the time of compilation.
 These are not exceptions at all, but problems that arise beyond the control of the user
or the programmer. Errors are typically ignored in your code because you can rarely
do anything about an error. For example, if a stack overflow occurs, an error will
arise. They are also ignored at the time of compilation.
Exception Hierarchy
All exception classes are subtypes of the java.lang.Exception class. The exception class is a
subclass of the Throwable class. Other than the exception class there is another subclass
called Error which is derived from the Throwable class.
Errors are not normally trapped form the Java programs. These conditions normally happen
in case of severe failures, which are not handled by the java programs. Errors are generated
to indicate errors generated by the runtime environment. Example : JVM is out of Memory.
Normally programs cannot recover from errors.

23
The Exception class has two main subclasses: IOException class and RuntimeException
Class

24
Writing object-oriented programs involves creating classes, creating objects from those classes,
and creating applications, which are stand-alone executable programs that use those objects.
A class is a template, blueprint, or contract that defines what an object‘s data fields and methods
will be. An object is an instance of a class. So we can create many instances of a class. A Java
class uses variables to define data fields and methods to define actions. Additionally, a class
provides methods of a special type, known as constructors, which are invoked to create a new
object. A constructor can perform any action, but constructors are designed to perform
initializing actions, such as initializing the data fields of objects
Objects are key to understanding object-oriented technology. Look around right now and you'll
find many examples of real-world objects: your dog, your desk, your television set, your bicycle.
Real-world objects share two characteristics: They all have state and behavior. Dogs have state
(name, color, breed, hungry) and behavior (barking, fetching, wagging tail). Bicycles also have
state (current gear, current pedal cadence, current speed) and behavior (changing gear, changing
pedal cadence, applying brakes). Identifying the state and behavior for real-world objects is a
great way to begin thinking in terms of object-oriented programming.
Take a minute right now to observe the real-world objects that are in your immediate area. For
each object that you see, ask yourself two questions: "What possible states can this object be in?"
and "What possible behavior can this object perform?". Make sure to write down your
observations. As you do, you'll notice that real-world objects vary in complexity; your desktop
lamp may have only two possible states (on and off) and two possible behaviors (turn on, turn
off), but your desktop radio might have additional states (on, off, current volume, current station)
and behavior (turn on, turn off, increase volume, decrease volume, seek, scan, and tune). You
may also notice that some objects, in turn, will also contain other objects. These real-world
observations all translate into the world of object-oriented programming
Software Object

25
Software objects are conceptually similar to real-world objects: they too consist of state and
related behavior. An object stores its state in fields (variables in some programming languages)
and exposes its behavior through methods (functions in some programming languages). Methods
operate on an object's internal state and serve as the primary mechanism for object-to-object
communication. Hiding internal state and requiring all interaction to be performed through an
object's methods is known as data encapsulation — a fundamental principle of object-oriented
programming.
In the real world, you'll often find many individual objects all of the same kind. There may be
thousands of other bicycles in existence, all of the same make and model. Each bicycle was built
from the same set of blueprints and therefore contains the same components. In object-oriented
terms, we say that your bicycle is an instance of the class of objects known as bicycles. A class is
the blueprint from which individual objects are created.
The following Bicycle class is one possible implementation of a bicycle:
class Bicycle {
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}

26
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:" +cadence + " speed:" + speed + " gear:" + gear);
}
}
The fields cadence, speed, and gear represent the object's state, and the methods
(changeCadence, changeGear, speedUp etc.) define its interaction with the outside world.
Object-oriented programming allows classes to inherit commonly used state and behavior from
other classes. In this example, Bicycle now becomes the superclass of MountainBike, RoadBike,
and TandemBike. In the Java programming language, each class is allowed to have one direct
superclass, and each superclass has the potential for an unlimited
A hierarchy of Bicycle class
In the Java programming language, an interface is a reference type, similar to a class, that can
contain only constants, method signatures, and nested types. There are no method bodies.

27
Interfaces cannot be instantiated—they can only be implemented by classes or extended by other
interface.
Interfaces have another very important role in the Java programming language. Interfaces are not
part of the class hierarchy, although they work in combination with classes. The Java
programming language does not permit multiple inheritance (inheritance is discussed later in this
lesson), but interfaces provide an alternative.
In Java, a class can inherit from only one class but it can implement more than one interface.
Therefore, objects can have multiple types: the type of their own class and the types of all the
interfaces that they implement. This means that if a variable is declared to be the type of an
interface, its value can reference any object that is instantiated from any class that implements
the interfaces.
Encapsulation is a mechanism where the data and the code that acts on the data will bind
together.
For example ,if we take a class we write the variable and methods inside the class .Thus class is
binding them together .So class is an example of encapsulation.
The variable and methods of a class are called members of the class .Generally the variable in the
class are decided by using a keyword ‗private‘ .This means the variables are not directly
available to any other class .The class or method which are declared ‗public‘ can be used and
directly called from any where .
class Employee{
private int id=10;
String name=‖Shamsher‖
String Roll=‖UE113087‖
Void display(){
System.out.println(―Id of Student ‖+id);
}
}
class DEMO extends Employee {

28
void display(){
Employee ob1=new Employee();
System.out.println(―Roll no of Student‖+ob1.Roll);
System.out.println(―Name of Student‖+ob1.name);
ob1.display();
}
The polymorphism represents the ability to assume several forms. In Java we can use the single
variable to refer to objects of different types and thus using that variable we can all the methods
of the different objects .Thus a method call can perform different tasks depending upon the type
of objects.
Polymorphism provides flexibility in writing programs in such way that the programmer uses
same method call to perform different operation depending upon the requirements.
Class one{
int a;
int b;
void one(int in){
a=in;
b=9;
}
void one(int in,int ou){
a=in;
b=ou;
}
}

29
Abstraction refer to act of representing only those information which are necessary while hiding
details of the program.The main advantage of Abstraction is that every user will get view of data
according to his needs while hiding the details of the project ,which might confused him when
he see the whole data as whole
Mostly all object oriented language support Data Abstraction Like Java ,C++. support Data
Abstraction Like Java ,C++.

30
The JDBC API is a Java API that can access any kind of tabular data, especially data stored in a
Relational Database.
JDBC helps you to write Java applications that manage these three programming activities
 Connect to a data source, like a database
 Send queries and update statements to the database
 Retrieve and process the results received from the database in answer to your query
JDBC includes four components:
 The JDBC API — The JDBC™ API provides programmatic access to relational data
from the Java™ programming language. Using the JDBC API, applications can execute
SQL statements, retrieve results, and propagate changes back to an underlying data
source. The JDBC API can also interact with multiple data sources in a distributed,
heterogeneous environment. The JDBC API is part of the Java platform, which includes
the Java™ Standard Edition (Java™ SE ) and the Java™ Enterprise Edition (Java™ EE).
The JDBC 4.0 API is divided into two packages: java.sql and javax.sql. Both packages
are included in the Java SE and Java EE platforms.
 JDBC Driver Manager — The JDBC DriverManager class defines objects which can
connect Java applications to a JDBC driver. DriverManager has traditionally been the
backbone of the JDBC architecture. It is quite small and simple . The Standard Extension
packages javax.naming and javax.sql let you use a DataSource object registered with a
Java Naming and Directory Interface™ (JNDI) naming service to establish a connection
with a data source. You can use either connecting mechanism, but using a DataSource
object is recommended whenever possible.
 JDBC Test Suite — The JDBC driver test suite helps you to determine that JDBC drivers
will run your program. These tests are not comprehensive or exhaustive, but they do
exercise many of the important features in the JDBC API.
 JDBC-ODBC Bridge — The Java Software bridge provides JDBC access via ODBC
drivers. Note that you need to load ODBC binary code onto each client machine that uses
this driver. As a result, the ODBC driver is most appropriate on a corporate network
where client installations are not a major problem, or for application server code written
in Java in a three-tier architecture

31
5.1 Mp3 music player
Music player is mp3 player which is purely built in Java .And this project relies heavily on Java
Sound API .
5.1.1 Software Development life cycle
The software development life cycle (SDLC) is a conceptual model used in project management
that describes the stages involved in an information system development project, from an initial
feasibility study through maintenance of the completed application/product.
Understand the relationship between development, test activities and work products in the
Development life cycle and give examples based on project and product characteristics and
context.
Recognize the fact that software development models must be adapted to the context of project
and product characteristics.

32
Recall reasons for different levels of testing and characteristics of good testing in any life cycle
model.
5.1.2 Waterfall models
The waterfall model is a popular version of the systems development life cycle model for
software engineering. Often considered the classic approach to the systems development life
cycle, the waterfall model describes a development method that is linear and sequential.
Waterfall development has distinct goals for each phase of development. Imagine a waterfall on
the cliff of a steep mountain. Once the water has flowed over the edge of the cliff and has begun
its journey down the side of the mountain, it cannot turn back. It is the same with waterfall
development. Once a phase of development is completed, the development proceeds to the next
phase and there is no turning back.
History of Waterfall Model
In 1970 Royce proposed what is now popularly referred to as the waterfall model as an initial
concept, a model which he argued was flawed (Royce 1970). His paper then explored how the
initial model could be developed into an iterative model, with feedback from each phase
influencing previous phases, similar to many methods used widely and highly regarded by many
today.

33
Despite Royce's intentions for the waterfall model to be modified into an iterative model, use of
the "waterfall model" as a purely sequential process is still popular, and, for some, the phrase
"waterfall model" has since come to refer to any approach to software creation which is seen as
inflexible and non-iterative.
When to use the waterfall model:
 Requirements are very well known, clear and fixed.
 Product definition is stable.
 Technology is understood.
 There are no ambiguous requirements
Advantages of Waterfall Model
 Simple and easy to understand and use.
 Easy to manage due to the rigidity of the model – each phase has specific deliverables
and a review process.
 Phases are processed and completed one at a time.
 Works well for smaller projects where requirements are very well understood.
Disadvantages of Waterfall Model
 Once an application is in the testing stage, it is very difficult to go back and change
something that was not well-thought out in the concept stage.
 No working software is produced until late during the life cycle.
 High amounts of risk and uncertainty.

34
 Not a good model for complex and object-oriented projects.
 Poor model for long and ongoing projects.
 Not suitable for the projects where requirements are at a moderate to high risk of
changing.
5.1.3 Requirement of this Project
Hardware Requirement
 Pentium powered Processor- speed 2.1 Ghz
 RAM - 1GB
 Hard Disk - 20 GB
 Key Board -
 Standard Windows Keyboard Mouse
 Monitor - LED
Software Requirement
 Java Development Kit version 1.6
 Neatbeans version7.01
 Operating System type Windows 7/Debian 7
Library used In this Project
 JLayer1.0.1
 Java Sound Api
JLayer 1.0.1
JLayer is a library that decodes/plays/converts MPEG 1/2/2.5 Layer 1/2/3 (i.e. MP3) in real time
for the JAVA(tm) platform. This is a non-commercial project and is licensed under LGPL.
To play mp3 in through JLayer JLayer, Tritonus and MP3SPI librairies are available in your
CLASSPATH. It means that you have jl1.0.1.jar, tritonus_share.jar, mp3spi1.9.5.jar in your
CLASSPATH.
List of Classes Available in JLayer
 javazoom/jl/converter/Converter
 javazoom/jl/converter/RiffFile
 javazoom/jl/converter/WaveFile
 javazoom/jl/converter/WaveFileObuffer
 javazoom/jl/converter/jlc
 javazoom/jl/decoder/BitReserve
 javazoom/jl/decoder/Bitstream

35
 javazoom/jl/decoder/BitstreamErrors
 javazoom/jl/decoder/BitstreamException
 javazoom/jl/decoder/Control
 javazoom/jl/decoder/Crc16
 javazoom/jl/decoder/Decoder
 javazoom/jl/decoder/DecoderErrors
 javazoom/jl/decoder/DecoderException
 javazoom/jl/decoder/Equalizer
 javazoom/jl/decoder/FrameDecoder
 javazoom/jl/decoder/Header
 javazoom/jl/decoder/InputStreamSource
 javazoom/jl/decoder/JavaLayerError
 javazoom/jl/decoder/JavaLayerErrors
 javazoom/jl/decoder/JavaLayerException
 javazoom/jl/decoder/JavaLayerHook
 javazoom/jl/decoder/JavaLayerUtils
 javazoom/jl/decoder/LayerIDecoder
 javazoom/jl/decoder/LayerIIDecoder
 javazoom/jl/decoder/LayerIIIDecoder
 javazoom/jl/decoder/Manager
 javazoom/jl/decoder/Obuffer
 javazoom/jl/decoder/OutputChannels
 javazoom/jl/decoder/SampleBuffer
 javazoom/jl/decoder/Source
 javazoom/jl/decoder/SynthesisFilter
 javazoom/jl/decoder/huffcodetab
 javazoom/jl/player/AudioDevice
 javazoom/jl/player/AudioDeviceBase
 javazoom/jl/player/AudioDeviceFactory
 javazoom/jl/player/FactoryRegistry
 javazoom/jl/player/JavaSoundAudioDevice
 javazoom/jl/player/JavaSoundAudioDeviceFactory
 javazoom/jl/player/NullAudioDevice
 javazoom/jl/player/Player
 javazoom/jl/player/PlayerApplet
 javazoom/jl/player/advanced/AdvancedPlayer
 javazoom/jl/player/advanced/PlaybackEvent
 javazoom/jl/player/advanced/PlaybackListener
 javazoom/jl/player/advanced/jlap
 javazoom/jl/player/jlp

36
5.1.4 Design Of The Project
This music player project is divided into
 Organisation
 Player
 Playlist
 Utility
 Interface
5.1.5 Testing
Software testing is an investigation conducted to provide stakeholders with information about the
quality of the product or service under test.Software testing can also provide an objective,
independent view of the software to allow the business to appreciate and understand the risks of
software implementation. Test techniques include, but are not limited to the process of executing
a program or application with the intent of finding software bugs (errors or other defects).
Software testing can be stated as the process of validating and verifying that a computer
program/application/product:
 meets the requirements that guided its design and development,
 works as expected,
 can be implemented with the same characteristics,
 and satisfies the needs of stakeholders.

37
Testing methods
 Static vs. dynamic testing
There are many approaches to software testing. Reviews, walkthroughs, or inspections
are referred to as static testing, whereas actually executing programmed code with a
given set of test cases is referred to as dynamic testing. Static testing can be omitted, and
in practice often is. Dynamic testing takes place when the program itself is used.
Dynamic testing may begin before the program is 100% complete in order to test
particular sections of code and are applied to discrete functions or modules. Typical
techniques for this are either using stubs/drivers or execution from a debugger
environment.
Static testing involves verification whereas dynamic testing involves validation. Together
they help improve software quality.
 The box approach
Software testing methods are traditionally divided into white- and black-box testing.
These two approaches are used to describe the point of view that a test engineer takes
when designing test cases.
White Box
White-box testing (also known as clear box testing, glass box testing, transparent box
testing and structural testing) tests internal structures or workings of a program, as
opposed to the functionality exposed to the end-user. In white-box testing an internal
perspective of the system, as well as programming skills, are used to design test cases.
The tester chooses inputs to exercise paths through the code and determine the
appropriate outputs. This is analogous to testing nodes in a circuit, e.g. in-circuit testing
(ICT).
While white-box testing can be applied at the unit, integration and system levels of the
software testing process, it is usually done at the unit level. It can test paths within a unit,
paths between units during integration, and between subsystems during a system–level
test. Though this method of test design can uncover many errors or problems, it might not
detect unimplemented parts of the specification or missing requirements.
Techniques used in white-box testing include:
 API testing (application programming interface) – testing of the application using
public and private APIs
 Code coverage – creating tests to satisfy some criteria of code coverage (e.g., the
test designer can create tests to cause all statements in the program to be executed
at least once)
 Fault injection methods – intentionally introducing faults to gauge the efficacy of
testing strategies
 Mutation testing methods
 Static testing methods
 Code coverage tools can evaluate the completeness of a test suite that was created
with any method, including black-box testing. This allows the software team to
examine parts of a system that are rarely tested and ensures that the most

38
important function points have been tested.Code coverage as a software metric
can be reported as a percentage for:
Black Box
Black-box testing treats the software as a "black box", examining functionality
without any knowledge of internal implementation. The tester is only aware of
what the software is supposed to do, not how it does it. Black-box testing methods
include: equivalence partitioning, boundary value analysis, all-pairs testing, state
transition tables, decision table testing, fuzz testing, model-based testing, use case
testing, exploratory testing and specification-based testing.
Specification-based testing aims to test the functionality of software according to
the applicable requirements.This level of testing usually requires thorough test
cases to be provided to the tester, who then can simply verify that for a given
input, the output value (or behavior), either "is" or "is not" the same as the
expected value specified in the test case. Test cases are built around specifications
and requirements, i.e., what the application is supposed to do. It uses external
descriptions of the software, including specifications, requirements, and designs
to derive test cases. These tests can be functional or non-functional, though
usually functional.
Specification-based testing may be necessary to assure correct functionality, but it
is insufficient to guard against complex or high-risk situations.
One advantage of the black box technique is that no programming knowledge is
required. Whatever biases the programmers may have had, the tester likely has a
different set and may emphasize different areas of functionality. On the other
hand, black-box testing has been said to be "like a walk in a dark labyrinth
without a flashlight."Because they do not examine the source code, there are
situations when a tester writes many test cases to check something that could have
been tested by only one test case, or leaves some parts of the program untested.
This method of test can be applied to all levels of software testing: unit,
integration, system and acceptance. It typically comprises most if not all testing at
higher levels, but can also dominate unit testing as well.
The aim of visual testing is to provide developers with the ability to examine
what was happening at the point of software failure by presenting the data in such
a way that the developer can easily ﬁnd the information he or she requires, and the
information is expressed clearly.
At the core of visual testing is the idea that showing someone a problem (or a test
failure), rather than just describing it, greatly increases clarity and understanding.
Visual testing therefore requires the recording of the entire test process –
capturing everything that occurs on the test system in video format. Output videos

39
are supplemented by real-time tester input via picture-in-a-picture webcam and
audio commentary from microphones.
Visual testing provides a number of advantages. The quality of communication is
increased dramatically because testers can show the problem (and the events
leading up to it) to the developer as opposed to just describing it and the need to
replicate test failures will cease to exist in many cases. The developer will have
all the evidence he or she requires of a test failure and can instead focus on the
cause of the fault and how it should be fixed.
Visual testing is particularly well-suited for environments that deploy agile
methods in their development of software, since agile methods require greater
communication between testers and developers and collaboration within small
teams.
Ad hoc testing and exploratory testing are important methodologies for checking
software integrity, because they require less preparation time to implement, while
the important bugs can be found quickly. In ad hoc testing, where testing takes
place in an improvised, impromptu way, the ability of a test tool to visually record
everything that occurs on a system becomes very important.
Visual testing is gathering recognition in customer acceptance and usability
testing, because the test can be used by many individuals involved in the
development process. For the customer, it becomes easy to provide detailed bug
reports and feedback, and for program users, visual testing can record user actions
on screen, as well as their voice and image, to provide a complete picture at the
time of software failure for the developer.
Testing levels
 Unit testing, also known as component testing, refers to tests that verify the functionality
of a specific section of code, usually at the function level. In an object-oriented
environment, this is usually at the class level, and the minimal unit tests include the
constructors and destructors.
These types of tests are usually written by developers as they work on code (white-box
style), to ensure that the specific function is working as expected. One function might
have multiple tests, to catch corner cases or other branches in the code. Unit testing alone
cannot verify the functionality of a piece of software, but rather is used to assure that the
building blocks the software uses work independently of each other.
Unit testing is a software development process that involves synchronized application of
a broad spectrum of defect prevention and detection strategies in order to reduce software
development risks, time, and costs. It is performed by the software developer or engineer
during the construction phase of the software development lifecycle. Rather than replace
traditional QA focuses, it augments it. Unit testing aims to eliminate construction errors

40
before code is promoted to QA; this strategy is intended to increase the quality of the
resulting software as well as the efficiency of the overall development and QA process.
 Integration testing is any type of software testing that seeks to verify the interfaces
between components against a software design. Software components may be integrated
in an iterative way or all together ("big bang"). Normally the former is considered a better
practice since it allows interface issues to be located more quickly and fixed.Integration
testing works to expose defects in the interfaces and interaction between integrated
components (modules). Progressively larger groups of tested software components
corresponding to elements of the architectural design are integrated and tested until the
software works as a system
 System testing tests a completely integrated system to verify that it meets its
requirements.
In addition, the software testing should ensure that the program, as well as working as
expected, does not also destroy or partially corrupt its operating environment or cause
other processes within that environment to become inoperative (this includes not
corrupting shared memory, not consuming or locking up excessive resources and leaving
any parallel processes unharmed by its presence
 Acceptance testing can mean one of two things:
 A smoke test is used as an acceptance test prior to introducing a new build to the
main testing process, i.e. before integration or regression.
 Acceptance testing performed by the customer, often in their lab environment on
their own hardware, is known as user acceptance testing (UAT). Acceptance
testing may be performed as part of the hand-off process between any two phases
of development
Alpha testing is simulated or actual operational testing by potential users/customers
or an independent test team at the developers' site. Alpha testing is often employed
for off-the-shelf software as a form of internal acceptance testing, before the software
goes to beta testing
Beta testing comes after alpha testing and can be considered a form of external user
acceptance testing. Versions of the software, known as beta versions, are released to
a limited audience outside of the programming team. The software is released to
groups of people so that further testing can ensure the product has few faults or bugs.
Sometimes, beta versions are made available to the open public to increase the
feedback field to a maximal number of future users

41
5.1.4 Memory Analysis
Snapshots of Memory Usage In Java

42
5.2 Conclusion

Summer training report on java se6 technology

More Related Content

What's hot (20)

Similar to Summer training report on java se6 technology (20)

Recently uploaded (20)

Summer training report on java se6 technology