Java is a high-level programming language originally developed by Sun Microsystems and released in 1995. Java runs on a variety of platforms, such as Windows, Mac OS, and the various versions of UNIX. This tutorial gives a complete understanding on Java.
ples
for standard
programming tasks.
1. Introduction to Java
Java is a programming language created by James Gosling from
Sun Microsystems in 1991. The first publicly available version of
Java
(Java 1.0) was released in 1995.
Over time new enhanced versions of Java have been
released.
The current
version of Java is Java 1.7 which is also known
as
Java 7.
From the Java programming language the Java platform evolved.
The Java platform allows that the program code is written in other
languages than
the Java programming language and still runs on the
Java virtual
machine.
1.2. 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 so-called
bytecode. The Java virtual machine interprets this
bytecode
and
executes
the Java program.
1.3. Object Oriented Programming
Since Java is an object oriented programming language it has following features:
- Reusability of Code
- Emphasis on data rather than procedure
- Data is hidden and cannot be accessed by external functions
- Objects can communicate with each other through functions
- New data and functions can be easily addedJava has powerful features. The following are some of them:-
Simple
Reusable
Portable (Platform Independent)
Distributed
Robust
Secure
High Performance
Dynamic
Threaded
Interpreted
Object Oriented Programming is a method of
implementation in which programs are organized as cooperative
collection of objects, each of which represents an instance of a
class, and whose classes are all members of a hierarchy of
classes united via inheritance relationships.
OOP Concepts
Four principles of Object Oriented Programming are
Abstraction
Encapsulation
Inheritance
Polymorphism
Abstraction
Abstraction denotes the essential characteristics of an object
that distinguish it from all other kinds of objects and
thus provide crisply defined conceptual boundaries, relative to
the perspective of the viewer.
Encapsulation
Encapsulation is the process of compartmentalizing the elements
of an abstraction that constitute its structure and
behavior ; encapsulation serves to separate the contractual
interface of an abstraction and its implementation.
Encapsulation
* Hides the implementation details of a class.
* Forces the user to use an interface to access data
* Makes the code more maintainable.
Inheritance
Inheritance is the process by which one object acquires the properties of another object.
Polymorphism
Polymorphism is the existence of the classes or methods in different forms or single name denoting different
implementations.
Java is Distributed
With extensive set of routines to handle TCP/IP protocols like HTTP
and FTP java can open and access the objects across net via URLs.
Java is Multithreaded
One of the powerful aspects of the Java language is that it allows
multiple threads of execution to run concurrently within the same
program A single Java program can have many different threads executing
independently and continuously. Multiple Java applets can run on the
browser at the same time sharing the CPU time.
Java is Secure
Java was designed to allow secure execution of code across network.
To make Java secure many of the features of C and C++ were eliminated.
Java does not use Pointers. Java programs cannot access arbitrary
addresses in memory.
Garbage collection
Automatic garbage collection is another great feature of Java with
which it prevents inadvertent corruption of memory. Similar to C++, Java
has a new operator to allocate memory on the heap for a new object. But
it does not use delete operator to free the memory as it is done in C++
to free the memory if the object is no longer needed. It is done
automatically with garbage collector.
Java Applications
Java has evolved from a simple language providing interactive dynamic
content for web pages to a predominant enterprise-enabled programming
language suitable for developing significant and critical applications.
Today, It is used for many types of applications including Web based
applications, Financial applications, Gaming applications, embedded
systems, Distributed enterprise applications, mobile applications, Image
processors, desktop applications and many more.
1.4. Java Runtime Environment vs. Java Development Kit
Java comes 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.
Java was designed with a concept of ‘write once and run everywhere’.
Java Virtual Machine plays the central role in this concept. The JVM is
the environment in which Java programs execute. It is a software that is
implemented on top of real hardware and operating system. When the
source code (.java files) is compiled, it is translated into byte codes
and then placed into (.class) files. The JVM executes these bytecodes.
So Java byte codes can be thought of as the machine language of the JVM.
A JVM can either interpret the bytecode one instruction at a time or
the bytecode can be compiled further for the real microprocessor using
what is called a
just-in-time compiler. The JVM must be implemented on a particular platform before compiled programs can run on that platform.
1.5. Characteristics of Java
The target of Java is to write a program once and then run
this
program on multiple operating systems.
Java has the following properties:
-
Platform independent: Java programs use the Java virtual
machine
as
abstraction and do not access the operating system
directly. This makes Java programs highly portable. A Java
program
which is standard complaint and follows certain rules can
run
unmodified on all supported platforms, e.g. Windows or Linux.
-
Object-orientated programming language:
Except the primitive
data types, all elements in Java are objects.
-
Strongly-typed programming language: Java is
strongly-typed,
e.g. the types of the used variables must be pre-defined and
conversion to
other objects is relatively strict, e.g. must be done
in most cases by the programmer.
-
Interpreted and compiled language: Java source
code is
transferred into the bytecode format which does not depend on the
target
platform. These bytecode instructions will be interpreted by
the Java
Virtual
machine (JVM). The JVM contains a so called
Hotspot-Compiler which
translates performance critical bytecode
instructions
into native
code instructions.
-
Automatic memory management: Java manages the memory
allocation and de-allocation for creating new objects. The
program
does not have direct access to the memory. The so-called garbage
collector deletes automatically objects to which no active pointer
exists.
The Java syntax is similar to C++. Java is case sensitive,
e.g.
the variables myValue and myvalue will be treated as different
variables.
1.6. Development Process with Java
The programmer writes Java source code in a
text editor which
supports
plain text. Normally the
programmer uses 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.
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.
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. The central website for installing Java is the following URL:
http:
If you have problems installing Java on your system,
a Google search for
How to install JDK on
YOUR_OS
should result
in
helpful links. Replace
YOUR_OS
with your
operating
system, e.g.
Windows,
Ubuntu, Mac OS X, etc.
3. Your first Java program
The following Java program is developed under Microsoft
Windows.
The
process on other operating system should be similar but
is not
covered in this description.
Select a new directory which will contain
your Java code. I
will use
the
c:\temp\java
which will be called
javadir
in the following description.
Open a text editor which supports plain text, e.g.
Notepad
under Windows and write the following source code. You can start
Notepad
via
→ →
and by pressing enter.
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
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
.
3.2. Compile and run your Java program
Switch to the command line, e.g. under Windows Start-> Run ->
cmd.
Switch to the
javadir
directory with the command cd javadir,
for
example in my case cd
c:\temp\java. Use the command dir to see
that
the source file is in the
directory.
javac HelloWorld.java
Check the content of the directory with the command "dir". The
directory contains now a file "HelloWorld.class". If you see this
file you have successfully compiled your first Java source code into
bytecode.
By default, the compiler puts each class file in the same
directory as its source file. You can specify a separate destination
directory with the -d compiler flag.
Run -> cmd. Switch to the directory jardir.
To run your program type in the command line:
java HelloWorld
The system should write "Hello World" on the command line.
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
4. 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.
In the following I will say "Create a Java project SomeName".
This will refer to creating an Eclipse Java project. If you are using
a different IDE please follow the required steps in this IDE.
5. Your first graphical user interface application (GUI)
Using
Eclipse
create a new Java project "JavaIntroductionUI".
Create the following class MyFirstUI.java in package ui.
package ui;
import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
public class MyFirstUI extends JFrame {
private JCheckBox checkbox;
private JTextField firstName;
private JTextField lastName;
public MyFirstUI() {
setTitle("My First UI");
JPanel pane = new JPanel(new BorderLayout());
int numberOfRows = 3;
int numberOfColumns = 2;
pane.setLayout(new GridLayout
(numberOfRows, numberOfColumns));
JLabel firstNamelabel = new JLabel
(" Firstname: ");
pane.add(firstNamelabel);
firstName = new JTextField();
pane.add(firstName);
JLabel lastNamelabel = new JLabel(" Lastname: ");
pane.add(lastNamelabel);
lastName = new JTextField();
pane.add(lastName);
JButton sayHello = new JButton("Say something");
pane.add(sayHello);
checkbox = new JCheckBox("Nice");
pane.add(checkbox);
getContentPane().add(pane);
pack();
sayHello
.setToolTipText("This button will say something
really nice of something bad");
sayHello.addActionListener(new MyActionListener());
}
private class MyActionListener implements
ActionListener {
public void actionPerformed(ActionEvent e) {
if (!checkbox.isSelected()) {
JOptionPane.showMessageDialog(null,"I do not like
you,"
+firstName.getText() + " " + lastName.getText() +
"!");
} else {
JOptionPane.showMessageDialog(null, "How are
you, "
+firstName.getText() + " " + lastName.getText()
+ "?");
}
}
}
}
Create also the following class MainTester.java in package
test
and start this class.
package test;
import ui.MyFirstUI;
public class MainTester {
public static void main(String[] args) {
MyFirstUI view = new MyFirstUI();
view.setVisible(true);
}
}
You should see the following. A mesage dialog should be seen if
you press the button.
-
6. Statements
The following describes certain aspects of the software.
Use == to compare two primitives or to see if two references
refers to the same object. Use the equals() method to see if
two different objects are equal.
&& and || are both Short Circuit Methods which means that they
terminate once the result of an evaluation is already clear.
Example (true || ....) is always true while (false
&&
...) always false is. Usage:
(var !=null
&&
var.method1()..) ensures that var is not null before doing
the real check.
Table 1. Boolean
Operations |
Description |
== |
Is equal, in case of objects the system
checks if the reference variable point
to the same object, is will not compare
the content of the objects!
|
&&
|
And |
!= |
is not equal, similar to the "=="
|
a.equals(b) |
Checks if string a equals b |
a.equalsIgnoreCase(b) |
Checks if string a equals b while
ignoring lower cases
|
If (value ? false : true) {} |
Return true if value is not true.
Negotiation
|
The switch statement can be used to handle several
alternatives if they are based on the same constant value.
switch (expression) {
case constant1:
command;
break;
case constant2:
command;
break;
...
default:
}
Example:
switch (cat.getLevel()) {
case 0:
return true;
case 1:
if (cat.getLevel() == 1) {
if (cat.getName().equalsIgnoreCase(req.
getCategory())) {
return true;
}
}
case 2:
if (cat.getName().equalsIgnoreCase(req.
getSubCategory())) {
return true;
}
}
The following lists the most common string operations.
Table 2.
Command |
Description |
text1.equals("Testing"); |
return true if text1 is equal to "Testing". The test
is
case sensitive.
|
text1.equalsIgnoreCase("Testing"); |
return true if text1 is equal to "Testing". The
test is
not case sensitive. For example it would
also be true for
"testing"
|
StringBuffer str1 = new StringBuffer(); |
Define a new String with a variable length. |
str.charat(1); |
Return the character at position 1.
(Strings starting with
0)
|
str.substring(1); |
Removes the first characters. |
str.substring(1, 5); |
Gets the substring from the second to
the fifths
character.
|
str.indexOf(String) |
Find / Search for String Returns the index of
the first
occurrence of the specified string.
|
str.lastIndexOf(String) |
Returns the index of the last occurrence of
the specified
string. StringBuffer does not
support this method. Hence first
convert
the StringBuffer to String via method toString.
|
str.endsWith(String) |
Returns true if str ends with String |
str.startsWith(String) |
Returns true if str starts with String |
str.trim() |
Removes spaces |
str.replace(str1,str2) |
Replaces all occurrences of str1 by str2 |
str.concat(str1); |
Concatenates str1 at the end of str. |
str.toLowerCase() str.toUpperCase() |
Converts string to lower- or uppercase |
str1 + str2 |
Concatenate str1 and str2 |
String[] zeug = myString.split("-"); String[] zeug =
myString.split("\\.");
|
Spits myString at / into Strings.
Attention:
the split string is a regular expression,
so if you using special characters which
have a meaning in
regular expressions
you need to quote them. In the second
example the . is used and must be
quoted by two backslashes.
|
If you use variables of different types Java requires for certain
types an explicit conversion. The following gives examples for this conversion.
8.1. Conversion to String
Use the following to convert from other types to Strings
String s1 = String.valueOf (10);
String.valueOf (Math.PI);
String s3 = String.valueOf (1 < 2);
String s4 = String.valueOf (new Date());
8.2. Conversion from String to Number
int i = Integer.parseInt(String);
float f = Float.parseFloat(String);
double d = Double.parseDouble(String);
The conversion from string to number is independent from the
Locale settings, e.g. it is always using the English
notification for
number. In this notification a correct
number format is "8.20". The
German number "8,20" would
result in an error.
To convert from a German number you have to use the
NumberFormat
class. The challenges is that if the value is
for example 98.00 then
the NumberFormat class would create a
Long which cannot be casted to
Double. Hence the following
complex conversion class.
private Double convertStringToDouble(String s) {
Locale l = new Locale("de", "DE");
Locale.setDefault(l);
NumberFormat nf = NumberFormat.getInstance();
Double result = 0.0;
try {
if(Class.forName("java.lang.Long").
isInstance(nf.parse(s))) {
result = Double.parseDouble(String.
valueOf(nf.parse(s)));
} else {
result = (Double) nf.parse(new String(s));
}
} catch (ClassNotFoundException e1) {
e1.printStackTrace();
} catch (ParseException e1) {
e1.printStackTrace();
}
return result;
}
8.4. SQL Date conversions
Use the following to convert a Date to a SQL date
package test;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class ConvertDateToSQLDate {
private void convertDateToSQL(){
SimpleDateFormat template =
new SimpleDateFormat("yyyy-MM-dd");
java.util.Date enddate =
new java.util.Date("10/31/99");
java.sql.Date sqlDate =
java.sql.Date.valueOf(template.format(enddate));
}
public static void main(String[] args) {
ConvertDateToSQLDate date = new
ConvertDateToSQLDate();
date.convertDateToSQL();
}
}
The following can be used as a reference for certain task which
you have to do.
9.1. Working with classes
While programming Java you have to create several classes,
methods, instance variables.
The following uses the package test.
Table 3.
What to do |
How to do it |
Create a new class called MyNewClass.
|
package test;
public class MyNewClass {
}
|
Create a new attribute (instance variable) "var1"
in
MyNewClass with type String
|
package test;
public class MyNewClass {
private String var1;
}
|
Create a Constructor for
"MyNewClass 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;
}
}
|
Create a new method "doSomeThing" in class which do
not return a value and has no parameters
|
package test;
public class MyNewClass {
private String var1;
public MyNewClass(String para1)
{
var1 = para1;
}
public void doSomeThing() {
}
}
|
Create a new method "doSomeThing2" in class which do
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;
}
public void doSomeThing() {
}
public void doSomeThing2
(int a, Person person) {
}
}
|
Create a new method "doSomeThing2" in class which do
return 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;
}
public void doSomeThing() {
}
public void doSomeThing2(int a,
Person person) {
}
public int doSomeThing3
(String a, String b,
Person person) {
return 5;
}
}
|
Create a class "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) {
this.myvalue = myvalue;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
}
|
9.2. Working with local variable
A local variable must always be declared in a method.
Table 4.
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 it.
|
ArrayList<Person> persons = new ArrayList<Person>();
|