Utttaranchal Institute of Technology

(Session 2020-2024)

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

INDUSTRIAL TRAINING REPORT IN JAVA

Submitted in partial fulfillment of the award of Degree of Bachelor of

Technology in Computer Science Engineering

UTTARANCHAL UNIVERSITY
PREMNAGAR, DEHRADUN
UTTARAKHAND 248007

Submitted to Submitted by
Dr. RB Singh Ayush Kumar
Assistant Professor Enroll no-
UU2001010041
 Acknowledgement

The completion of this training work could have been possible with continued & dedicated
efforts & guidance of large number of faculty & staff members of the institute I acknowledge
our gratitude to all of them. The acknowledgement however will be incomplete without
specific mention as follows:
I wish to acknowledge my deep gratitude to our trainer at Oceana Tech for his Cooperation
and guidance. I am also thankful to director Mr. Sudarshan Virman that provided staunch
support Throughout this training and helped me to complete the training successfully
Furthermore I would also like to acknowledge with much appreciation the crucial role of our
HOD Dr. Sumit Chaudhary for this encouragement & providing all the facilities in the
department
Finally, I would like to say that I am indebted to my parents for everything that they have
done for me. All of this would have been impossible without their constant support.
Without their support and suggestions, this industrial training report would not have been
completed

Ayush Kumar
Certificate
 DECLARATION

I Ayush Kumar, a student of Bachelor of Technology in Computer Science Engineering,

Utttaranchal Institute of Technology , Premnagar, Dehradun, Uttarakhand, hereby
declare that the work in this Industrial Training Report entitle “ Industrial Training in Java
“ from Oceana Tech, is the outcome of my own work, is correct to the best of my
knowledge. The work presented does not infringe any patented work and has not been
submitted to any other university or anywhere else for the award of any degree or any
diploma program.

Ayush Kumar
2001010041
 INDEX

S.NO. CONTENT PAGE NO. SIGN

1. Company Profile 6

2. Introduction to Java 8

3. Basics of Java 11

4. The Java Platform 11

5. Installation of Java 12

6. Configuring Variables 14

7. Write, Compile and Run a 16

Java Program
8. Package, Class and Object 18

9. Inheritance 18

10. Variable and Method 19

11. Modifiers and Import 21

Statement
12. Interface 23

13. Working with Classes 24

14. IDE 26

15. History of Java 31

16. Conclusion 33
Company profile:

Ecomoceana Technologies Private Limited is a Private incorporated on 12 November 2018. It

is classified as Non-govt company and is registered at Registrar of Companies, Delhi. Its
authorized share capital is Rs. 1,000,000 and its paid up capital is Rs. 250,000. It is inolved in
Other computer related activities [for example maintenance of websites of other firms/
creation of multimedia presentations for other firms etc.]

Ecomoceana Technologies Private Limited's Annual General Meeting (AGM) was last held
on N/A and as per records from Ministry of Corporate Affairs (MCA), its balance sheet was
last filed on 31 March 2021.

Directors of Ecomoceana Technologies Private Limited are Pawan Kumar and Sudarshan
Kumar Virmani.

Ecomoceana Technologies Private Limited's Corporate Identification Number is (CIN)

U72900HR2018PTC076861 and its registration number is 76861.Its Email address is
[email protected] and its registered address is C/O SUMAN BALA ,W/O PARDEEP
KUMAR 5, AMAR NAGAR, AMBALA CANTT AMBALA Ambala HR 133001 IN.

Current status of Ecomoceana Technologies Private Limited is - Active

INTRODUCTION TO JAVA

With the invention of microprocessors, the world is scientifically developed with sophisticated
equipment, systems, and devices. Microprocessors are used in computers, televisions, and fax.
Machines. Even the hand-held devices such as pagers, PDAs (Personal Digital Assistant), and
cell phones make use of microprocessors. All these electronic devices are helpful because of
their communication capabilities. With the increasing capabilities and decreasing cost of
information processing and networking technologies, the network is growing rapidly for
transmitting information through electronic systems.
Internet is the network of networks between different types of computers located at different
places to transmit information, Information can reach to any place in the world quickly at a
cheaper rate through the Internet. Thus, the Internet has made the world a global village for
information exchange. The emerging infrastructure of electronic devices and interconnected
computer networks create an environment that presents new challenges to software industries.
For this emerging computing environment, Java process to be a well suited programming
language, it is found suitable for networked environments involving a great variety of computer
and devices.

Java has many characteristics that have contributed to as popularity:

 Platform independence : Many languages are compatible with only one platform
Java was specifically designed so that it would ran on any computer, regardless if it
was running Windows, Linux, Mac, Unix or any of the other operating systems.
 Simple and easy to me - Java’s creators tried to design it so code could be written
Efficiently and easily.
 Multi-functional - Java can produce many applications from command-line programs
to applets to Swing windows (basically, sophisticated graphical user interfaces).
Java does have some drawbacks : Since it has automated garbage collection, à can tend to use
more memory than other similar languages. There are often implementation differences on
different platforms, which have led to Java being described as a “write once, test everywhere”
system Lastly, since it uses an abstract “Virtual machine”, a generic Java program doesn’t
have access to the Native APIs on a system directly. None of these issues are fatal, but it can
mean that Java isn’t an appropriate choice for a particular piece of software.
Java is one of the programming language or technology used for developing web
applications. Java language developed at SUN Micro Systems in the year 1995 under the
guidance of James Gosling and there team. Originally SUN Micro Systems is one of the
Academic university (Stanford University Network)
Whatever the software developed in the year 1990, SUN Micro Systems has released on the
name of oak, which is original name of java (scientifically oak is one of the tree name). The
OAK has taken 18 months to develop. The oak is unable to fulfill all requirements of the
industry. So James Gosling again reviews this oak and released with the name of java in the
year 1995. Scientifically. Java is one of the coffee seed name.. Java divided into three
categories, they are :
 J2SE (Java 2 Standard Edition)
 J2EE (Java 2 Enterprise Edition)
 J2ME (Java 2 Micro or Mobile Edition)
J2SE
J2SE is used for developing client side applications.
J2EE
J2EE is used for developing server side applications.
J2ME
J2ME is used for developing mobile or wireless application by making use of a predefined
protocol called WAP (wireless Access/Application protocol).

BASICS OF JAVA
Overview Of Java
Java is a platform independent, more powerful, secure, high performance, multithreaded
programming language. Here we discuss some points related to java.

Define JRE
The Java Runtime Environment (JRE) is part of the Java Development Kit (JDK). It contains
set of libraries and tools for developing java application. The Java Runtime Environment
provides the minimum requirements for executing a Java application.

Define JVM
JVM is set of programs developed by sun Micro System and supplied as a part of jdk for
reading line by line of byte code and it converts into native understanding form of operating
system. Java language is one of the compiled and interpreted programming language.

Garbage Collector
Garbage Collector is the system Java program which runs in the background along with
regular Java program to collect un-Referenced (unused) memory space for improving the
performance of our applications.
Define an API
An API (Application Programming Interface) is a collection of packages, a package is the
collection of classes, interfaces and sub-packages. A sub-package is a collection of classes
interfaces and sub sub packages etc. Java programming is containing user friendly syntax so
that we can develop effective application s. in other words if any language is providing user
friendly syntax, we can develop error free applications.

Definition of JIT
JIT is the set of programs developed by SUN Micro System and added as a part of JVM, to
speed up the interpretation phase

Features OF JAVA
Features of a language are nothing but the set of services or facilities provided by the
language vendors to the industry programmers. Some important features are,

Java Classpath Setting

Path Variable
Path variable is set for providing path for all java tools like java, javac, javap, javah, jar,
applet viewer which are use in java programming. These all tools are available in bin folders
so we set path up to bin folders.

Classpath Variable
Classpath variable is set for providing path for predefined java classes which is used in our
application. All classes are available in lib/rt.jar so we set classpath upto lib/rt.jar.

Steps For Compiling And Executing Programs

The following sequence of steps represented in the diagram use compiling the java program
and executing the java programs

Difference Between JDK.JRE AND JVM

Jvm, Jre, Jdk these all the backbone of java language. Each components have separate works.
Jdk and Jre physically exists but Jvm are abstract machine it means it not physically exists.
JVM: JVM (Java Virtual Machine) is a software. It is a specification that provides runtime
environment in which java bytecode can be executed. It not physically exists. JVMs are not
same for all hardware and software, for example for window OS JVM is different and for
Linux VIM is different. JVM, JRE and JDK are platform dependent because configuration of
each OS differs. But, Java is platform independent.
JRE: The Java Runtime Environment (JRE) is part of the Java Development Kit (JDK). It
contains set of libraries and tools for developing java application. The Java Runtime
Environment provides the minimum requirements for executing a Java application. It
physically exists. It contains set of libraries + other files that JVM uses at runtime.
JDK: The Java Development Kit (JDK) is primary components. It physically exists. It is
collection of programming tools and JRE, JVM.

The Java Platform

One thing that distinguished Java from some other languages is its ability to run the same
compiled code across multiple operating systems. In other languages, the source code (code
that is written by the programmer), is compiled by a compiler into an executable file. This file
is in machine language, and is intended for a single operating system/processor combination,
so the programmer would have to re-compile the program separately for each new operating
system processor combination. Java is different in that is does not compile the code directly
into machine language code. Compilation creates bytecode out of the source code. Bytecode
generally looks something like this:
a7 f3 5a 1b 92 7d
When the code is run by the user, it is processed by something called the Java Virtual
Machine (JVM). The JVM is essentially an interpreter for the bytecode. It goes through the
bytecode and nans it. There are different versions of the JVM that are compatible with each
OS and can run the same code. There is virtually no difference for the end-user, but this
makes à a lot easier for programmers doing software development.

Java and Open Source:-

 In 2006 Sun started to make Java available under the GNU General Public License
(GPL). Oracle continues this project called Open JDK.

Java Virtual machine :-

 The Java virtual machine JVM) is a software implementation of a computer that
executes programs like a real machine.
 The Java virtual machine is written specifically for a specific operating system, e.g.
for Linux a special implementation is required as well as for Windows.
 Java programs are compiled by the Java compiler into bytecode. The Java virtual
machine interprets this bytecode and executes the Java program.

Java Runtime Environment vs. Java Development Kit

 A Java distribution comes typically in two flavors, the Java Runtime Environment
(JRE) and the Java Development Kit (JDK).
 The Java runtime environment (JRE) consists of the JVM and the Java class libraries
and contains the necessary functionality to start Java programs.
 The JDK contains in addition the development tools necessary to create Java
programs. The JDK consists therefore of a Java compiler, the Java virtual machine,
and the Java class libraries.

Installation of Java
 Check installation

 Java might already be installed on your machine. You can test this by opening a
console (if you are using Windows: Win+R, enter cmd and press Enter) and by typing
in the following command:
 Java -version
  If Java is correctly installed, you should see some information about your Java
installation. If the command line returns the information that the program could not be
found, you have to install Java .

Installing the Java Development Kit

 Before installing the Java Development Kit (JDK), you should probably know what it
is It is distributed by Oracle. It contains the core libraries and compiler required to
develop Java. The JDK should not be confused with the JRE (Java Runtime
Environment). The JRE is a JVM for running, as opposed to compiling, Java
programs.

Downloading and Installing

 To Download the JDK, go to
http://www.oracle.com/technetwork/java/javase/downkoads/index.html. Click on IDK
with NetBeans Bundle”. Follow the instructions for downloading the JDK installation.
Windows: If you are running Windows, simply run the executable file and follow
the installation instructions.
Unix, Solaris, or Linux: For Linux and Unix, download the jdk1 6.0” for Linux
systems. Save the downloaded file in any drive. Once you have saved the file, extract
it to a pace that you can remember, by using Terminal or by double clicking on the
file. When you have finished extracting the file, copy the JDK 1.6.0 folder and paste it
in the usr/local To paste to the usr/local directory, you have to be in root) so that
every user can use the java files. You can delete the downloaded zip file so that it
doesn’t take up space on your drive
Macintosh: The latest available JDK is automatically installed by the operating
system. Because Java for Macintosh is developed and maintained by Apple, in
coordination with Sun, the current version on the Macintosh may not be the current
version that is available

Note on Editions
o The JDK comes in three editions :

 Java Standard Edition (JSE)This version is the basic platform for Java. The
course will focus on this edition.

 Java Enterprise Edition (JEE) This edition is mainly for developing and
running distributed multitier architecture Java applications, based largely on
modular software components running on an application server. We will not be
covering this version in the course.

 Java Micro Edition (JME) This edition is primarily for developing programs to
run on consumer appliances, such as PDAs and cell phones.
 Configuring Variables

 Before writing code, it is recommended that you set the Path variable on your
system so you can compile your code more easily.

 For Windows Users

 From the Control Panel, double click System" (System and Maintenance in
Vista)

 For Windows 7 or Vista, click on "System," "Advanced System Settings" on

the left, and then on "Environment Variables."

 For XP and 2000, click on the "Advanced" tab and click on "Environment
Variables For NT. click on the "Environment" tab.

 Select the Path variable and click Ede"

 Add the path to the bin directory of where Java is installed on your hard drive.
It should probably be: C:Program Files Java/jdk1.6.0 20 bin unless you
changed during installation.

 Click OK

 For Linux and UNIX

 One way to set your path in Linux/Unix is to add a path export to your bash
profile.
 In order to do this, first open your bash profile in a text editor. For example,

 pico-bash profile

 Then add this line:

 export PATH-SPATH/usr/local/jdk/bin

 Note that the path to the java directory "usr/local/jdk/bin" may be different on
your machine.

 Restart your shell

 For Macintosh

 Apple sets everything up for you. Sit back and relax.

  The only drawback is that because Apple handles development and maintenance of
Java on the Mac, there is usually a delay from the time that a new version is released
by Sun and the time that the new version is released on the Mac. Also, getting the
latest version sometimes requires an operating system upgrade.
 Oh well, you can’t have everything

Validate installation

 Switch again to the command line and run the following command.
 Java -version
 The output should be similar to the following output.
 Java version “1.7.0 25”
 OpenJDK Runtime Environment (Iced Tea 2.3.10) (7u25-2.3.10-1ubuntu0.13.04.2)
 OpenJDK 64-Bè Server VM (build 23.7-b01, mixed mode)

Development Process with Java

 Java source files are written as plain text documents. The programmer typically writes
Java source code in an Integrated Development Environment (IDE) for programming.
An IDE supports the programmer in the task of writing code, e.g. it provides auto-
formatting of the source code, highlighting of the important keywords, etc.
 At some point the programmer (or the IDE) calls the Java compiler (javac). The Java
compiler creates the bytecode instructions. These instructions are stored in class files
and can be executed by the Java Virtual Machine.

Garbage collector
 The JVM automatically re-collects the memory which is not referred to by other
objects. The java garbage collector checks all object references and find the objects
which can be automatically released.
 While the garbage collector releases the programmer from the need to explicitly
manage memory the programmer still need to ensure that he does not keep unneeded
object references otherwise the garbage collector cannot release the associated
memory. Keeping unneeded object references are typically called memory leaks.
 Write, compile and run a Java program
 Write source code
 The following Java program is developed under Linux using a test editor and the
command line. The process on other operating system should be similar and but is not
covered in this description.
 Select or create a new directory which will be used for your Java development. In this
description the path \home\vogella\javastarter is used. On Microsoft Windows your
might want to use c:\temp\javastarter. This path is called javadir in the following
description. Open a text editor which supports plain text, e.g. gedit under Linux or
Notepad under windows and write the following source code .

Save the source code in your javadir directory with the HelloWorld.java filename. The name
of a Java source file must always equal the class name (within the source code) and end with
the .java extension. In this example the filename must be HelloWorld.java, because the class
is called HelloWorld.

 Compile and Run your Java Program

 Open a shell for command line access.
Switch to the javadir directory with the command cd javadir, for example, in the
above example via the cd \home\vogella\javastarter command. Use the ls command
(dir under Microsoft Windows) to verify that the source file is in the directory.
Compile your Java source file into a class file with the following command.
javac HelloWorld.java
Afterwards list again the content of the directory with the ls or dir command. The directory
contains now a file HelloWorld.class. If you see this file, you have successfully compiled your
first Java source code into bytecode. You can now start your compiled Java program. Ensure
that you are still in the jardir directory and enter the following command to start your Java
program. The system should write “Hello World” on the command line.

Using the classpath

 You can use the classpath to run the program from another place in your directory.
 Switch to the command line, e.g., under Windows Start Run cmd. Switch to any
directory you want. Type:
java HelloWorld
 If you are not in the directory in which the compiled class is stored, then the system
will show an error message: Exception in thread “main”
java.lang.NoClassDefFoundError: test/TestClass
 To use the class, type the following command. Replace “mydirectory” with the
directory which contains the test directory. You should again see the “HelloWorld”
output.
java -classpath “mydirectory” HelloWorld

Java Basic Terms

 Basics : Class, Objects, and Package
It is important to understand the base terminology of java in terms of packages,
classes and objects. This section gives an overview of these terms.

 Class
Def : A class is a template that describes the data and behavior associated with an
instance of that class.
A class is defined by the class keyword and must start with a capital letter. The body
of a class is surrounded by {}.
package test;
class Myclass {}
The data associated with a class is stored in variables ; the behavior associated to a class or
object is implemented with methods. A class is contained in a text file with the same name as
the class plus the .java extension. It is also possible to define inner classes, these are classes
defined within another class, in this case you do not need a separate file for this class.
  Object
Def : An object is an instance of a class.
The object is the real element which has data and can perform actions. Each object is created
based on the class definition. The class can be seen as the blueprint of an object, i.e., it
describes how an object is created.

 Package
Def : Java groups classes into functional packages.
Packages are typically used to group classes into logical units. For example, all graphical
views of an application might be placed in the same package called
com.vogella.webapplication.views..
It is common practice to use the reverse domain name of the company as top level package.
For example, the company might own the domain, vogella.com and in this example the Java
packages of this company starts with com.vogella. Other main reason for the usage of
packages is to avoid name collisions of classes. A name collision occurs if two programmers
give the same fully qualified name to a class. The fully qualified name of a class in Java
consists of the package name followed by a dot (.) and the class name.. Without packages, a
programmer may create a Java class called Test. Another programmer may create a class with
the same name. With the usage of packages you can tell the system which class to call. For
example, if the first programmer puts the Test class into package report and the second
programmer puts his class into package xmlreader you can distinguish between these classes
by using the fully qualified name, e.g, xmlreader.Test or report.Test.

Inheritance
A class can be derived from another class. In this case this class is called a subclass. Another
common phrase is that a class extends another class. The class from which the subclass is
derived is called a superclass. Inheritance allows a class to inherit the behavior and data
definitions of another class.
The following codes demonstrates how a class can extend another class. In Java a class can
only extend a maximum of one class.
package com.vogella.javaintro.base;
class MyBaseClass {
public void hello() {
System.out.println(“Hello from MyBaseClass”);
}}
package com.vogella.javaintro.base;
class MyExtensionClass extends MyBaseClass {}
  Override methods and the @Override annotation
If a class extends another class, it inherits the methods from its superclass. If it wants to
change these methods, it can override these methods, i.e., redeclare the methods. This is
necessary for an abstract method unless the class itself is defined as abstract. The @Override
annotation can be added to such a method. It is used by the Java compiler to check if the
annotated method really overrides a method of an interface or the extended class.
To override a method, you use the same method signature in the source code of the subclass.
To indicate to the reader of the source code and the Java compiler that you have the intention
to override a method, you can use the @Override annotation.
The following code demonstrates how you can override a method from a superclass.
package com.vogella.javaintro.base;
class MyBaseClass {
public void hello() {
System.out.println(“Hello from MyBaseClass”);
}}
package com.vogella.javaintro.base;
class MyExtensionClass2 extends MyBaseClass {
@Override
public void hello() {
System.out.println(“Hello from MyExtensionClass2”);
}
}

Object as superclass
Every object in Java implicitly extends the Object class. The class defines the following
methods for every Java object:
 equals(o1) allows checking if the current object is equal to o1
 getClass() returns the class of the object
 hashCode() returns an identifier of the current object
 toString() gives a string representation of the current object

Variables and methods

 Variable
Variables allow the Java programmer to store values during the runtime of the
program.
 Variables allow the Java program to store values during the runtime of the program. A
variable can either be a: * primitive variable * reference variable. A primitive variable
contains the value. A reference variable contains a reference (pointer) to the object.
Hence, if you compare two reference variables, you compare if both point to the same
object. To identify if objects contain the same data, use the object1.equals(object2)
method calls.

 Instance variable
Instance variable is associated with an instance of the class (also called object). Access
works over these objects. Instance variables can have any access control and can be
marked final or transient. Instance variables marked as final cannot be changed after a
value has been assigned to them.
 Local variable
Local (stack) variable declarations cannot have access modifiers.
Local variables do not get default values, so they must be initialized before they can
be used.
final is the only modifier available to local variables. This modifier defines that the
variable cannot be changed after the first assignment.
 Methods
A method is a block of code with parameters and a return value. It can be called on
the object.
package com.vogella.javaintro.base;
public class MyMethodExample {
void tester(String s) {
System.out.println(“Hello World”);
}
}
Methods can be declared with var-args. In this case the method declares a parameter
which accepts everything from zero to many arguments (syntax: type … name;) A
method can only have one var-args parameter and this must be the last parameter in
the method.
Overwrite of a superclass method: A method must be of the exact same return
parameter and the same arguments. Also the return parameter must be the same.
Overload methods: An overloaded method is a method with the same name, but
different arguments. The return type can not be used to overload a method.

 Main method
A public static method with the following signature can be used to start a Java
application. Such a method is typically called main method.
public static void main(String[] args) {}

Constructor
A class contains constructors that are invoked by the Java runtime to create objects based on
the class definition.
Constructor declarations look like method declarations except that they use the name of the
class and have no return type. In the following example the constructor of the class expects a
parameter.
package com.vogella.javaintro.base;
public class MyConstructorExample2 {
String s;
public MyConstructorExample2(String s) {
this.s = s; }
}
Each class must define at least one constructor. If no explicit constructor is defined in the
Java source file, the compiler implicitly adds a constructor. If the class is sub-classed, then
the constructor of the super class is always called implicitly in this case.
In the following example the definition of the constructor without parameters (also known as
the empty constructor) is unnecessary. If not specified, the compiler would create one.
package com.vogella.javaintro.base;
public class MyConstructorExample {
// unnecessary: would be created by the compiler if left out
public MyConstructorExample() {
}}
The naming convention for creating a constructor is the following: classname (Parameter p1,
…) { }. Every object is created based on a constructor. This constructor method is the first
statement called before anything else can be done with the object.

Modifiers
 Access modifiers
There are three access modifiers keywords available in Java: public, protected, private. There
are four access levels: public, protected, default and private. They define how the
corresponding element is visible to other components. If something is declared public, e.g.,
classes or methods can be freely created or called by other Java objects. If something is
declared private, e.g., a method, it can only be accessed within the class in which it is
declared. The following table describes the visibility :
Table 1. Access level
Modifier Class Package Subclass World

public Y Y Y Y
 Modifier Class Package Subclass World
protected Y Y Y N
no Y Y N N
modifier
private Y N N N

Other modifiers
 final methods: cannot be overwritten in a subclass abstract method: no method body
 Synchronized method: thread safe, can be final and have any access control
 Native methods: platform dependent code, apply only to methods
 Strictfp: class or method

Import statements
 Usage of import statements
You have to access a Java class always via its full-qualified name, i.e., the package
name followed by the class name. You can add import statements into your class file.
These allow you to use the related classes in your code without the package qualifier.

 Static imports
Static import allows public static members (fields and methods) of another class to be
used in Java code without a class reference. The feature provides a typesafe
mechanism to include constants into code. It also improves code readability and
allows Java API designers to write a concise API.

Interface
Interfaces are contracts for what a class can do but they say nothing about the way in which
the class must do it. An interface is a type similar to a class. Like a class an interface defines
methods. An interface can have only abstract methods, no concrete methods are allowed.
Methods defined in interfaces are by default public and abstract- explicit declaration of these
modifiers is optional. Interfaces can have constants which are always implicitly public, static
and final. A class can implement an interface. In this case it must provide concrete
implementations of the interface methods. If you override a method defined by an interface
you can also use the @override annotation. The following code shows an example
implementation of an interface and its usage within a class.
package com.vogella.javaintro.base:
public interface MyDefinition {
String URL-http://www.vogelia.com // constant definition
// define several method stubs
void test ();
void write(String s) }
package com.vogella.javaintro.basez
public class MyClassImplementation implementa MyDefinition |
@override
public void test() {
// TODO Auto-generated method stun
@override
public void write(String s){// TODO Auto-generated methad atu}
}

Class methods and class variables

Class methods and class variables are associated with the class and not an instance of the
class, i.e., objects. To refer to these elements, you can use the classname and a dot (“.”)
followed by the class method or class variable name. Class methods and class variables are
declared with the static keyword. Class methods are also called static methods and class
variables are also called static variables or static fields.
An example for the usage of a static field is println of the following statement:
System.out.println(“Hello World”). Hereby out is a static field, an object of type PrintStream
and you call the println() method on this object. If you define a static variable, the Java
runtime environment associates one class variable for a class no matter how many instances
(objects) exist. The static variable can therefore be seen as a global variable.
The following code demonstrates the usage of static fields.
package com.vogella.javaintro.base;
public class MyStaticExample {
static String PLACEHOLDER = “TEST”;
static void test() {
System.out.println(“Hello”);
}}
package com.vogella.javaintro.base;
public class tester {
public static void main(String[] args) {
System.out.println(MyStaticExample.PLACEHOLDER);
MyStaticExample.test(); }
}
If a variable should be defined as constant, you declare it with the static and the final
keyword. The static method runs without any instance of the class, it cannot directly access
non-static variables or methods.

Abstract class and methods

A class and method can be declared as abstract. An abstract class can not be directly
instantiated. If a class has at least one method, which only contains the declaration of the
method, but not the implementation, then this class is abstract and can not be instantiated.
Sub-classes need then to define the methods except if they are also declared as abstract. If a
class contains an abstract method, it also needs to get defined with the abstract keyword.
The following example shows an abstract class.
package com.vogella.javaintro.base;
public abstract class MyAbstractClass {
abstract double returnDouble();
}

Working with classes

While programming Java you have to create several classes, methods, instance variables. The
following uses the package test.
Table 2
What to do How to do it
Create a new class called MyNewClass. package test;
public class MyNewClass {
}
Create a new attribute (instance variable) package test;
called var1 of type String in the public class MyNewClass {
MyNewClass class private String var1;
}

Create a Constructor for your MyNewClass package test;

class which has a String parameter and public class MyNewClass {
assigns the value of it to the var1 instance private String var1;
variable. public MyNewClass(String para1) {
var1 = para1;
// or this.var1= para1;
}}
Create a new method called doSomeThing package test;
in your class which does not return a value public class MyNewClass {
and has no parameters. private String var1;
public MyNewClass(String para1) {
var1 = para1;
// or this.var1= para1;
 }
public void doSomeThing() {
}}
Create a new method called package test;
doSomeThing2 in your class which does public class MyNewClass {
not return a value and has two parameters, private String var1;
an int and a Person public MyNewClass(String para1) {
var1 = para1;
// or this.var1= para1;
}
public void doSomeThing() {
}
public void doSomeThing2(int a,
Person person) {
}}
Create a class called MyOtherClass with package test;
two instance variables. One will store a public class MyOtherClass {
String, the other will store a Dog. Create String myvalue;
getter and setter for these variables. Dog dog;
public String getMyvalue() {
return myvalue;
}
public void setMyvalue(String
myvalue) {
this.myvalue = myvalue;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}}
Working with local variable
Table 3.
What to do How to do it
Declare a (local) variable of type String. String variable1;

Declare a (local) variable of type String and String variable2 = “Test”;

assign “Test” to it.

Declare a (local) variable of type Person Person person;

Declare a (local) variable of type Person, Person person = new Person();

create a new Object and assign the variable
to this object
Declare an array of type String String array[];
 Declare an array of type Person and create Person array[]= new Person[5];
an array for this variable which can hold 5
persons.
Assign 5 to the int variable var1 (which Var1 = 5;
was already declared);
Assign the existing variable pers2 to the Pers1 = pers2;
existing variable pers1;
Declare an ArrayList variable which can ArrayList<Person> persons
hold objects of type Person
Create a new ArrayList with objects of type Persons = new ArrayList<Person>();
Person and assign it to the existing variable
persons.
Declare an ArrayList variable which can ArrayList<Person> persons = new
hold objects of type Person and create a ArrayList<Person>();
new Object for it.

Integrated Development Environment

The previous chapter explained how to create and compile a Java program on the command
line. A Java Integrated Development Environment (IDE) provides lots of ease of use
functionality for creating Java programs. There are other very powerful IDEs available, for
example, the Eclipse IDE. For an introduction on how to use the Eclipse IDE please see
Eclipse IDE Tutorial. The remaining description uses the phrase: “Create a Java project
called…”.This refers to creating a Java project in Eclipse. If you are using a different IDE,
please follow the required steps in that IDE.

Creating Java objects and methods

Create a Person class and instantiate it
The following is the expected result after the creation of a Person class and it gets
instantiated.
package exercises.exercise04;
class Person {
String firstname = “Jim”;
String lastname = “Knopf”;
int age = 12;
void writeName(){
System.out.println(firstname);
public String toString() {
return firstName + “ “ + lastName; }
}
package exercises.exercise04;
public class Main {
public static void main(String[] args) {
Person person = new Person(); // this calls the toString method on the pers object
System.out.println(pers);
}}

Use constructor
package com.vogella.javastarter.exercises1;
class Person {
String firstName;
String lastName;
int age;
public Person(String a, String b, int value) {
firstName = a;
lastName = b;
age=value;
}
public String toString() {
return firstName + “ “ + lastName;
}}
package com.vogella.javastarter.exercises1;
public class Main {
public static void main(String[] args) {
Person p1 = new Person(“Jim”, “Knopf” , 12 );
System.out.println(p1);
Person p2 = new Person(“Henry”, “Ford”, 104);
System.out.println(p2);
}}

Define getter and setter methods

package com.vogella.javastarter.exercises1;
class Person {
String firstName;
String lastName;
int age;
public Person(String a, String b, int value) {
firstName = a;
lastName = b;
age = value;}
public String getFirstName() {
return firstName; }
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName; }
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age; }
@Override
public String toString() {
return firstName + “ “ + lastName;
}}
package com.vogella.javastarter.exercises1;
public class Main {
public static void main(String[] args) {
 Person person = new Person(“Jim”, “Knopf”, 21);
Person p2 = new Person(“Jill”, “Sanders”, 20);
// Jill gets married to Jim and takes his name
P2.setLastName(“Knopf”);
System.out.println(p2); }}

Create an Address object

package com.vogella.javastarter.exercises1;
public class Address {
private String street;
private String number;
private String postalCode;
private String city;
private String country;
public String getStreet() {
return street;
}
public void setStreet(String street) {
this.street = street;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
This.number = number;
}
public String getPostalCode() {
return postalCode;
}
public void setPostalCode(String postalCode) {
this.postalCode = postalCode; }
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getCountry() {
return country;
}
public String toString() {
return street + “ “ + number + “ “ + postalCode + “ “ + city + “ “ + country;
}}
package com.vogella.javastarter.exercises1;
class Person {
String firstName;
String lastName;
int age;
private Address address;
public Person(String a, String b, int value) {
firstName = a;
lastName = b;
age=value;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
}
 HISTORY OF JAVA
It is quite interesting to know the development of Java technology, which is widely accepted
in the area of networked/distributed computing Java evolved from a project developing a
language for programming consumer electronic devices at Sun Microsystems, USA.
Sun’s Stealth Project in 1990 was aimed to do research in the area of application of
computers in the consumer electronics market. Bill Joy, James Gosling, Mike Sheridan,
Patrick Naughton (formerly the project leader of Sun’s Open Windows user environment),
and several other individuals discussed the ideas for the Stealth Project in January 1991. The
vision of this project was to develop smart consumer electronic devices that could all be
centrally controlled and programmed from a handheld-remote-control-like device. The
Stealth group began to work to achieve this goal. It was realized that a platform-independent
development-environment was needed. Green Project was initiated by Patrick Naughton,
Mike Sheridan, and James Gosling of Sun Microsystems in 1991 (Members of the Stealth
Project, which later became known as the Green Project) The tasks of the project were
divided amongst the members of Green Project. Mike Sheridan concentrated on business
development, Patrick Naughton worked on the graphics system, and James Gosling was to
identify the appropriate programming language for the Green Project. Even though creating a
new language was not the aim of Green Project, a new language was created as a
programming tool in this project since C++ was found unsuitable for the project.
An intelligent remote control called *7 (Star Seven) was delivered as the first product of
Green Project in 1992. It is a PDA- like device comprising of a new language oak, an
operating system called GreenOS, user interface, and hardware. This device was quite
impressive to Sun Executives. But no customer was interested in this project. The market was
not conducive to this type of device in the consumer electronics industry.
The new language Oak was created b” James Gosling, a Green Team member, specifically for
7. Gosling named the new language Oak because that name was struck while looking at an
oak three outside of his office window. The name Oak was later renamed to Java in order to
avoid legal issues since Oak was the name of an existing language.
WebRunner (named after the movie Blade Runner). Later WevRunner was officially
announced as the HotJava browser in 1994. This was the turning point for Java. At that time
the World Wide Web changed the face of Internet and it was winning the race on Internet.
Arthur Ban Hoff implemented the Java compiler in Java itself whereas Gosling implemented
it in C. The Java compiler, written in Java made the people to accept Java as a full- featured
language.
Sun Microsystems officially announced Java environment at Sun World’95 on May 23, 1995.
Java entered into the mainstream of the Internet after a struggle for about four years.
Netscape Communications incorporated Java into its web browser Netscape Navigator.
Within a decade, Java was destined to be the most overreaching technology in the Internet.
Java was not restricted to the Internet alone. The initial goal of Sun was also achieved by
using Java. Technology in interactive set-top boxes, hand-held devices and other consumer
electronics products. Sun released the first version 1.0 of Java in 1996. Java is an object-
oriented programming language which evolved from C++. It is also a high-level
programming language.
Table 4
Year Java – Versions and features
1990 Sun Microsystems started Stealth project supporting application of computers in the
consumer electronics market.
1991 The Green project started with the members of Stealth project such as James Gosling.
Patrick Naughton, and Mike Sheridan. A new programming language, called Oak
wasCreated by Gosling.
1992 An intelligent remote control called StarSeven was delivered. The Green Project was
Incorporated was incorporated under the name FirstPerson.

1993 Mosaic Web browser was introduced in the world of Internet.

1994 HotJava Web browser was announced by Sun Microsystems.

1995 Oak was renamed as Java. Sun officially announced Java technology.

1996 Sun released the first version 1.0 of Java. Core Language features supporting: 10
facility, Utilities, Network Programming. User Interface Multithreading. AWT,
Applets, and multithreading.
1997 Sun released JDK1.1 by including new features such as addition of inner classes to
the language and capabilities such as JavaBeans, JDBC(Java Data Base
Connectivity), and RMI (Remote Method Invocation).
1998 Java 2 Platform, Standard Edition (J2SE)1.2, code named as Playground, was
released. It replaced JDK and distinguished the base platform from j2ee (Java 2
Platform, Enterprose Edition) and J2ME (Java 2Platform, Micro Edition). The key
features include Swing graphical API, Java IDL (Interface Definition Language) to
support CORBA interoperability. They also added Collections framework to support
various data structures. For the first time, JVM was equipped with a JIT (Just-in-
Time) compiler
2000 J2SE 1.3, code named as Kestrel, was released with key features such as JavaSound
API to support audio operations (e.g., audio playback and capture/recording, mixing,
sequencing, and synthesis), Java Naming and Directory Interface (JNDI), and Java
Platform Debugger Architecture (JPDA).
2002 H2SE 1.4, code named as Merlin, was released with key features such as (a) image
I/O API for manipulating images in formats like JPEG and PNG, (b) integrated XML.
Parser and XSLT processor (JAXP), integrated security and cryptography extensions,
(c) Java Web Start supporting deployment of Java software applications over the
network.
2004 J2SE 5.0, code named as Tiger, was released with enhancement of Java platform and
inclusion of a number of significant new language features such as Generics,
Enhanced for Loop, Autoboxing/Unboxing, Typesafe Enums, Varags, Static Import,
and Metadata supporting declarative style programming annotation of source code
2006 Java SE 6.0, code named as Mustang, was released with enhancement of performance
in Swing, JDBC 4.0 support, Java Compiler API, Upgrade of JAXB to version 2.0,
including integration of a StAX parser, support for pluggable annotations, and many
GUI improvements.
2008 Java SE 7.0, code named as Dolphin, with native support for XML recognizing its
foundation for Web services
Conclusion :

In concluding the industrial Java training program, it's evident that this intensive and
comprehensive learning experience has been invaluable for all participants. Throughout the
duration of this program, we have delved deep into the intricacies of Java programming,
exploring its applications in industrial contexts and honing our skills to meet industry
standards.

The program has provided a robust foundation in Java development, covering key concepts
such as object-oriented programming, data structures, multithreading, GUI development, and
more. The hands-on approach through practical exercises, projects, and industry-relevant case
studies has significantly enhanced our understanding and proficiency in Java programming.

Furthermore, the exposure to real-world scenarios and challenges faced in industries

employing Java has been instrumental in bridging the gap between theoretical knowledge and
practical implementation. Collaborative projects and interactions with industry experts have
offered invaluable insights into best practices, emerging trends, and the importance of Java in
modern software development.

As participants, we acknowledge the immense value of this training program in equipping us

with relevant skills sought after by the industry. The acquired knowledge and practical
experience have not only boosted our confidence but also widened our career prospects in
Java development roles across various industrial sectors.

Moving forward, the onus is on us to continue building upon the foundation laid during this
training. We must remain updated with the evolving Java ecosystem, embrace continuous
learning, and apply the acquired skills creatively in solving real-world problems.

We extend our gratitude to the trainers, mentors, and the organizing team for their
unwavering support, guidance, and expertise throughout this journey. Their dedication has
been pivotal in making this training program a resounding success.

In conclusion, this industrial Java training program has been a transformative experience,
empowering us with the necessary tools and knowledge to excel in the dynamic field of Java
development within industrial settings.