JAVA TRAINING REPORT
A report submitted in partial fulfillment of the requirements for the
Award of Degree of
BACHELOR OF
TECHNOLOGY
in
COMPUTER SCIENCE AND ENGINEERING
Roll no. :
Ms. Diksha Tiwari
(2020-21)
COMPUTER SCIENCE & ENGINEERING
DEPARTMENT
KRISHNA INSTITUTE OF TECHNOLOGY, KANPUR
(Affiliated to Dr. A.P.J Abdul Kalam Technical University,
Lucknow)
December ,
2021
INDEX
|
S. No |
TOPIC NAME |
PAGE NO. |
SIGN. |
|
1 |
Company Profile |
7 |
|
|
2 |
Introduction To Java |
8 |
|
|
3 |
The Java Platform |
9 |
|
|
4 |
Installation Of Java |
10 |
|
|
5 |
Configuring Variable |
11 |
|
|
6 |
Write, Compile And Run a Java Program |
13 |
|
|
7 |
Package |
15 |
|
|
8 |
Class And Object |
16 |
|
|
9 |
Inheritance |
17 |
|
|
10 |
Variable And Method |
18 |
|
|
11 |
Modifiers And Import Statement |
20 |
|
|
12 |
Interface |
22 |
|
|
13 |
Working With Classes |
24 |
|
|
14 |
IDE |
27 |
|
|
15 |
History of Java |
40 |
|
|
16 |
Features of Java |
43 |
|
Acknowledgement
It is our privilege to express our sincerest
regards to our JAVA TRAINING REPORT coordinator, Ms. .......,
for their valuable inputs, able guidance, encouragement, whole-hearted
cooperation and constructive criticism throughout the duration of our JAVA TRAINING REPORT.
We
deeply express our sincere thanks to our Head of Department Mr. .............. for encouraging and allowing us to present the
project on the topic “JAVA TRAINING REPORT “at our department premises for the partial
fulfillment of the requirements leading to the award of B-Tech degree.
We
take this opportunity to thank all our lecturers who have directly or
indirectly helped our JAVA TRAINING REPORT. We pay our respects and love to our parents
and all other family members and friends for their love and encouragement
through out our career. Last but not the least we express our thanks to our
friends for their cooperation and support.
COMPANY PROFILES
 |
Centre for
Research and Industrial
Staff Performanc (CRISP), Bhopal
has
been established in
the year 1997 as a Society under the Indo
–German Technical Cooperation
agreement. Ministry of MSME, Government of India was the line ministry
for this project whereas the Department of Technical Education &
Skill Development, Government of Madhya Pradesh and German Technical Cooperation agency (GTZ) were the implementation partners. It is headquartered in Bhopal with national
& international operations dedicated to human resource
development &
organizational development. These activities are targeted at
Government, Industries, Academic Institutions, Developmental Organizations as well
as the Civil Society.
The organization has excellent
infrastructure in terms of sophisticated
laboratories in the field of Industrial
Automation, Mechatronics, Production Technology,
Information & Communication Technology (ICT), Multimedia Technology etc. CRISP is one of the most preferred service
providers in the areas of
Technical Vocational Education &
Training (TVET), Training
Institution Management and Entrepreneurship development.
FEATURES:-
Ø A nodal Centre for Department of Technical Education & Skill Development
Government of Madhya Pradesh for technical and management staff capacity building.
Ø More than 500 delighted clients from Industries, Central & State Government Organizations, Academia, Developmental Organizations etc.
Ø A role model
for German Technical Co-operation Agency (GTZ) for replicating
CRISP like successful
Project in India
and other countries.
Ø
Practicing professional & management principles in our operations.
Ø
Facilitating applications of e-Governance for State Govt.
of Madhya Pradesh.
Ø A strong team
of qualified & experienced employees (more than
150) capable of handling
technical and educational projects within India & overseas.
AREA OF SPECIALIZATIONS:-
Ø Manufacturing Technology (CNC Technology, CAD/CAM (Unigraphics, Pro-E, CATIA, Solid
Works & I-DEAS), AutoCAD.
Ø Industrial Automation (PLC, Variable Frequency
Drives, Field Instrumentation,
MMI, Hydraulics, Pneumatics).
Ø
Mechatronics: Mechanical, Electrical,
Electronics, Instrumentation, IT.
Ø
Car Mechatronics.
Ø Behavioral Sciences and Management (Leadership Development, Communication Skills, Team Building etc.).
Ø Information Technology (Application & Software Development, Hardware & Networking Training, Web
Designing etc.).
Ø Vocational Education & Training (Design & development of curriculum & study materials, Train The Trainers, Instructors
Training, Trade
identification
survey,
impact
study etc).
Ø
Fashion, Interior & Graphic Designing
Ø Multimedia
(3D Animation, Non-Linear video editing, show
reel development.
Introduction to Java
|
With the invention
of microprocessors, the world is
scientifically developed with sophisticated equipments, 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 its popularity:
Ø Platform independence - Many languages are compatible with
only one platform. Java was specifically
designed so that it would run on any computer, regardless if it was running
Windows, Linux, Mac, Unix or any of the other
operating systems.
Ø Simple and easy to use - 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,
it 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 API's
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.
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 seperately for each new operating
system/processor combination.Java is different in that
it 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 f4 73 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
runs 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 it 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 OpenJDK.
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
v 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/downloads/index.html. Click on "JDK with NetBeans Bundle". Follow the instructions
for downloading the JDK installation file.
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 place 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
Ø 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 applicances, 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.
v 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 "Edit"
Ø 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 it during installation.
Ø Click OK
v
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=$PATH:/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.
v
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 (IcedTea 2.3.10) (7u25-2.3.10-1ubuntu0.13.04.2)
Ø OpenJDK
64-Bit 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-formating
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.
Classpath
Ø The classpath defines where the Java compiler and
Java runtime look for .class files to load. This instructions
can be used in the Java program.
Ø For example if
you want to use an
external Java library you have to add
this
library to your classpath
to use it in your program.
Write, compile and run a Java program
v Write source code
Ø The following Java program is developed under Linux using a
text 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 equals 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.
v 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.
java HelloWorld
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 should result 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
v Basics: Package, Class and
Object
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.
v Package
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 out 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.
v Class
Def.: Template that describes the data and behavior
associated with an instance of that class.
In Java source
code 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 Java source file with the same name as the class plus the .java
extension.
v 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.
v 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 extend a maximum of one class.
package
com.vogella.javaintro.base;
class MyBaseClass {
void hello(){
System.out.println("Hello from MyBaseClass");
}
}
package
com.vogella.javaintro.base;
class
MyExtensionClass extends MyBaseClass {
}
v 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. 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 {
void hello(){ System.out.println("Hello from MyBaseClass");
}
}
package
com.vogella.javaintro.base;
class MyExtensionClass2 extends MyBaseClass {
}
Object has superclass
Every
object in Java implicitly extends the Object class. The class defines
the following methods for every Java object:
Ø
equals(o1)
allows to check if the current
object is equal
to o1
Ø
getClass()
returns the class of the object
Ø hashCode() returns
an identifier of the current object
Ø toString() Give a string representation of
the current object
Variables and methods
v Variable
Variables allow the Java program to store values during the runtime
of the program.
A variable
can either be a primitive variable or
a reference variable. A primitive
variable contains value while the 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 compare objects use the
object1.equals(object2) method call.
v 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 can not be changed after assigned to a
value.
v Local variable
Local (stack) variable
declarations cannot have access modifiers.
final is
the only modifier available to local variables. This modifier defines that the variable can not
be changed after first assignment.
Local variables do not get
default values, so they must be initialized before use.
v 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");
}
}
Method can be declared with var-args. In this case the
method declares a parameter
which accepts 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.
v 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){
}
v Constructor
A class contains
constructors that are
invoked 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. A class
can have several constructors
with different parameters. Each class must
define at least one
constructor.
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;
}
}
If no explicit constructor
is defined the compiler adds
implicitly
a constructor. If
the
class is sub-classed
then the constructor
of the super
class
is always implicitly called 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
conversion 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
v Access modifiers
There are
three access modifiers keywords available
in Java. public, protected and 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.
protected and default
are similar. A protected class can be accessed from the package and
sub-classes outside the package while a
default class can get
only accessed via the
same package. The following table
describes the visibility:
Table 1. Access Level
|
Modifier |
Class |
Package |
Subclass |
World |
|
Public |
Y |
Y |
Y |
Y |
|
protected |
Y |
Y |
Y |
N |
|
Modifier |
Class |
Package |
Subclass |
World |
|
no
modifier |
Y |
Y |
N |
N |
|
Private |
Y |
N |
N |
N |
Other
modifiers
Ø
final methods: cannot be overwritten in a subclass
Ø abstract
method: no method body
Ø synchronized
method: threat safe, can be final and have
any access control
Ø native
methods: platform dependent code, apply only to methods
Ø
strictfp: class or method
Import statements
v Usage of import statements
In Java
you have to access
a class always via
its full-qualified name, e.g.
the
package name and
the class name. You can add import
statements for classes or packages into your class
file, which allow you to use the related
classes in your code
without
the package qualifier.
v Static imports
Static
import is a feature
that allows members (fields and methods) which are
defined in a class
with the public static access
modifier to be
used in Java code
without
specifying the class
in which the member is defined.
The
feature provides a typesafe mechanism to include constants
into code without having
to reference the class that originally defined the
field.
More Java language constructs
v 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 {
// constant definition
String URL="http://www.vogella.com";
// define several method
stubs
void test();
void write(String
s);
}
package
com.vogella.javaintro.base;
public class
MyClassImplementation implements MyDefinition {
@Override
public void test()
{
// TODO Auto-generated method stub
}
@Override
public void
write(String s) {
// TODO Auto-generated method stub
}
}
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 element 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"). 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) exists.
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.
v 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 contain 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 keyword
abstract. The following
example shows an abstract class.
package
com.vogella.javaintro.base;
public abstract class MyAbstractClass {
abstract double returnDouble();
}
Working With Classes
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)
called var1 of type String
in the MyNewClass class |
package
test; public class
MyNewClass { private String var1; } |
|
Create a Constructor for your MyNewClass class
which has a String parameter and assigns the value
of it to the
var1 instance variable. |
package
test; public class
MyNewClass { private String var1; public
MyNewClass(String para1) { var1 = para1; // or this.var1= para1; } } |
|
Create a new method called doSomeThing in your class
which does not return
a value and has no parameters |
package
test; public class
MyNewClass { private String var1; public
MyNewClass(String para1) { var1
= para1; // or this.var1= para1; } public
void doSomeThing() { } } |
|
Create a new method called
doSomeThing2 in your
class which does not return a value and
has two parameters, a int and
a Person |
package
test; public class
MyNewClass { private String var1; public
MyNewClass(String para1) { var1 = para1; // or this.var1= para1; } public void doSomeThing() |
|
What to do |
How to do it |
|
|
{ } public void
doSomeThing2(int a, Person person) { } } |
|
Create a new method called
doSomeThing2 in your
class which returns
an int value and
has three parameters, two Strings and a
Person |
package
test; public class
MyNewClass { private String var1; public
MyNewClass(String para1) { var1 = para1; // or this.var1= para1; } public
void doSomeThing() { } public void
doSomeThing2(int a, Person person) { } public int doSomeThing3(String
a, String b, Person person) { return 5; // Any value
will do for this example } } |
|
Create
a class called
MyOtherClass with two
instance variables. One will store a String,
the other will store a Dog.
Create getter and setter for these variables. |
package
test; public class
MyOtherClass { String myvalue; Dog dog; public String
getMyvalue() { return
myvalue; } public void setMyvalue(String myvalue) |
|
What to do |
How to do it |
|
|
{ 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 assign "Test" to it. |
String variable2 = "Test"; |
|
Declare a (local) variable of type Person |
Person person; |
|
Declare a
(local) variable of type Person, create a new Object and assign the variable
to this object. |
Person person = new Person(); |
|
Declare a array of type String |
String array[]; |
|
Declare a
array of type Person and create an array for this variable which can hold 5
Persons. |
Person array[]= new Person[5]; |
|
Assign 5
to the int variable var1 (which was already declared); |
var1 = 5; |
|
Assign the
existing variable pers2 to the exiting variable pers1; |
pers1 = pers2; |
|
Declare a
ArrayList variable which can hold objects of type Person |
ArrayList<Person> persons; |
|
Create a
new ArrayList with objects of type Person and assign it to the existing
variable persons |
persons =
new ArrayList<Person>(); |
|
Declare a ArrayList
variable which can hold objects of type Person and create a new Object for |
ArrayList<Person>
persons = new ArrayList<Person>(); |
|
What to do |
How to do it |
|
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 IDE's 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 this IDE. Exercises - Creating
Java objects and methods Create
a Person class and instantiate it Create a new Java project called
com.vogella.javastarter.exercises1 and a package with the same name. Create a
class called Person. Add three
instance variables to
it, one for storing the first name of the person,
on for storing the last name and one for
storing the age of the
Person. Use the
constructor of the Person object to set the values
to some default value. Write a public method called
writeName() which uses the System.out.println( method to print the first name
of the person to the console. Create a new class called Main with a public static
void main(String[] args). In this
method create an instance of the Person
class.
v Use constructor
Add a constructor to your Person class which takes the first name, last name and
the
age as parameter. Assign the values to your instance variables. Create in your main method two
objects of type Person and call the writeName method on it.
v Define getter and setter methods
Define methods
which allow you to read the
values of the instance variables and to set
them. These methods are called setter
and getter. Getters should start with get followed by
the variable name whereby the
first letter of the variable is
capitized. Setter should
start with set followed by the variable name whereby
the first letter of the variable is capitized. `
For example the variable called firstName would have
the getFirstName() getter method and
the setFirstName(String s) setter method.
Change your main method so that you create one person
object and use the
setter method to change the
last name.
v Create
an Address object
Create a new
object called Address. The
Address should allow you to store the address of
a person. Add a new instance variable of this type in the Person
object. Also create a
getter and setter for
the Address object in the Person
object.
Solution - Creating Java objects and methods Create a Person class and instantiate it
The following
is a potential solution for
Section 11.1, “Create a Person class and instantiate it”.
package
exercises.exercise04;
class Person {
String firstname = "Jim"; String lastname = "Knopf";
int age = 12;
voi d
writeName() {
// Writes the firstname System.out.println(firstname);
// Alternatively you can combine
strings with + System.out.println(firstname + " " + lastname + "" +
age);
}
}
package exercises.exercise04;
public
class Main {
public static void main(String[] args) { Person person = new Person();
}
person.writeName();
}
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;
}
void writeName() {
// Writes the firstname
System.out.println(firstName);
//
Alternatively you can combine strings with + System.out.println(firstName +
" " + lastName + "" + age);
}
}
package
com.vogella.javastarter.exercises1;
public class Main {
void main(String[] args) {
Person person
= new Person("Jim", "Knopf" , 12); person.writeName();
// Reuse the same variable and assign new object to it person = new
Person("Henry", "Ford", 104); person.writeName();
}
}
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;
}
void writeName() {
// Writes the firstname System.out.println(firstName);
// Alternatively you can combine strings with +
System.out.println(firstName + " " + lastName + "" + age);
}
}
package
com.vogella.javastarter.exercises1;
public class Main {
public static void
main(String[] args) {
Person person = new Person("Jim", "Knopf", 21);
Person person2 = new Person("Jill", "Sanders", 20);
// Jill get married
to Jim person2.setLastName("K
nopf"); person2.writeName();
}
}
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;
}
PostalCode(String
postalCode) { this.postalCode = postalCode;
}
public String getCity() {
return
city;
}
public void setCity(String city) { this.city = city;
}
public String getCountry() { return
country;
}
public void setCountry(String country) { this.country = 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;
}
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;
}
public Address
getAddress() { return
address;
}
public void setAddress(Address address) { this.address = address;
}
void
writeName() {
// Writes the
firstname System.out.println(firstName);
// Alternatively you can combine strings with +
System.out.println(firstName + " " + lastName + "" + age);
}
}
package
com.vogella.javastarter.exercises1;
public class Main {
public static void
main(String[] args) {
// I create a person
Person pers = new
Person("Jim", "Knopf", 31);
// I set the age of the
person to 32
// Just for testing I write this to the console
System.out.println(pers.toString());
/*
* Actually System.out.println calls
always toString, if you do not
*
specify it so you could also have written System.out.println(pers);
*/
// I create an address
Address address = new
Address();
// I set the values for the address
address.setCity("Heidelberg"); address.setCountry("Germany");
address.setNumber("104"); address.setPostalCode("69214");
address.setStreet("Musterstr."); address = null;
// person is moving to the next house in the same street
pers.getAddress().setNumber("105");
}
}
HISTORYOF 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
by 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.
In November
1992, the Green Project
was incorporated under the name FirstPerson. In
1993. Time-Warner was demanding
for proposals for set-top
box operating systems and
video- on-demand technology with an objective
of sending the data
to consumer all over the country for display
on the television sets. At the same time
(1993(, NCSA released the first graphical web
browser Mosaic 1.0, an easy-to-use front end to the World
Wide Web.
When FirstPerson was bidding on the Time-Warner
TV trial based on video-on-demand
technology, Time-Warner chose Silicon Graphics,
Inc.
(SGI) over Sun. Hence, half of the
members of FirstPerson left for
SGI and the remaining members continued to work at
Sun.
Mosaic web browser revolutionized
people’s perceptions.
The remaining member of FirstPerson returned to work on Java (Oak was
renamed Java) to
develop Java-based web
browser. FirstPerson was dissolved
gradually. Naughton
and
Jonathan Payne developed WebRunner (named after the movie Blade Runner). Later WevRunner was officially announced as the HotJavaTM 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 official y 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. The
different forms of Java versions are
discussed in the next section.
History of Java
|
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 was
created 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: I/O |
|
|
facility, Utilities, Network Programming, User
Interface – 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. |
FEATURES
OF JAVA
 |
According to Sun, Java
is defined as a simple, object-oriented,
distributed, interpreted, robust,
secure, architecture –neutral, portable, high performance, multithreaded, and dynamic
programming language and platform.
Java is
simple because the syntax of well-known languages such as C and C++ are
used with modifications meant for
simplification and
improvement. It
is
easy to read and
write Java code if
the reader is familiar
with C/C++.
Almost everything in Java is centered
on creating objects, manipulating
the objects and making
objects work together.
Only the primitive operations and data types are at the sub-object level. Hence Java is an object-oriented programming language.
An application
can be distributed in many
systems which are connected together. Since
networking capability is incorporated
in Java, the data/file
can be sent across
many
systems to run the application.
Java is
robust because it is more reliable. It ensures the reliability by providing early checking
for possible errors. It
eliminates error-prone constructs such as pointer. It eliminates
error-prone constructs such as
pointer. It also supports runtime
error handling.
Java programs
are compiled to a byte code format that can be read and run by interpreters on many
platforms including Windows,
Linux, etc. Hence, it is architecture
neutral. Because of this feature
it is portable to new hardware and operating systems.
Although the
speed of execution of Java programs is slower compared to C/C++
programs,
Java is meant
for distributed applications.
Whenever the file/data is
transmitted from one system
to another, the
performance is not affected. Hence, it is having high performance.
Java supports
multithreaded programming to perform several tasks simultaneously. Any code can be loaded without recompilation at runtime. Hence it is dynamic.
0 Comments