Java Tutorials
Java programming Language with syntax
What will this talk cover?
l Will discuss
– History of Language
– What is Java
• Language
• Libraries
– What is it good for
– Why you should (perhaps) use it
– How does it compare with other
languages, particularly C, C++
– Future of Language
• Lawsuits etc.
– Conclusion
l Not a tutorial on how to program in
Java
– There are a number of example
programs, but intent is to give a feel
for the language rather than go into
too many details.
– If there is sufficient interest it may be
possible to arrange tutorial-like
session(s) at a future date.
l Appendix (left over slides)
– Gives a brief introduction to
language syntax and features.
What is Java?
l History
– Originally designed (1991) as a small
language for consumer electronics
(cable boxes, toasters etc.)
– Eventually someone wrote HotJava
Browser, which could run Java
Applets
– At height of internet craze, adopted by
Netscape, Microsoft, Sun etc. as Web
Programming Language.
l More than just a Web Tool
– Java is a fully functional, platform
independent, programming language
– Powerful set of machine independent
libraries, including windowing (GUI)
libraries.
l Past Year
– Sun has released several new versions
of language + libraries
– >1,000,000 copies of Java
Development kit downloaded
– Java available for MAC, Win 95/NT,
HP, SUN, SGI, Digital Unix, Linux,
Amiga, OS/2, BEOS, VMS, and even
AIX
– Microsoft <---Sues---> Sun
l Next Year
– Should see many real Java applications
emerge
How does Java work?
l Java source code is compiled into
machine independent “bytecodes”
l The bytecodes can be run directly by an
interpreter
l The bytecodes can be converted to
machine code and executed (“Just in
Time (JIT)” compilation).
l An optimizing interpreter can
dynamically identify program
“hotspots” and create code optimized
for the specific machine/environment.
– Optimizing interpreter coming soon
from SUN.
Java Source code
Java “Bytecodes”
Compiler
Mac Unix PC
Bytecode
Interpreter
JIT
Compiler
Machine Code
Java Buzzwords
l Simple
– well, simpler than C++
l Object Orientated
– more so than C++
l Distributed
– Built in support for Internet
protocols, URL’s, HTTP etc.
– Support for distributed objects, RMI,
CORBA etc.
l Robust
– Difficult to create memory leaks, go
beyond the end of an array, corrupt
stack or code
l Secure
– Bytecode “verifier”, padded cell
l Architecture Neural, Portable
– Runs on PC, MAC, Unix, VMS
l Interpreted
– “Compiler” converts code into
machine independent “bytecodes”
l High Performance
– With JIT compiler still several times
slower than native C++
– Coming soon! Optimizing interpreter
from Sun, faster (?!?) than C++
l Multithreaded
– Language has direct support for
multithreading (c.f. subprocesses)
l Dynamic
– Libraries can change without
recompiling programs that use them
Java Language Features
l Pure Object Oriented Language
– Can only write classes
l Syntax very similar to C/C++,
but without many of the rarely
used, overly complex features of
C++
– No history
– No operator overloading
– No multiple inheritance
– No Pointers
l Supports
– Inheritance
– Interfaces
– Nested Classes
– Automatic Garbage Collection
l Built in support for
– Threads
– Exception handling
– Object serialization
– Networking
– Reflection
Java Libraries (API’s)
l The usefulness of Java is greatly enhanced by the large range of
platform independent libraries available:
– AWT - Basic GUI toolkit - delegates to OS specific “Peers”
– SWING (a.k.a. JFC) Enhanced “Peerless” GUI toolkit (Beta)
– 2D - Transformations, stroked fonts, pattern fill, textures etc. (Beta)
– JDBC - Standard Interface between Java and SQL databases
– ODMG binding - Standard Interface to Object databases
– RMI + CORBA - Remote procedure calls between distributed Java
applications, and between Java and other languages
– BEANS - Java based components, plug commercial components into your
applications.
– Media (audio, video etc.), Share (e.g. whiteboards), Animation, Telephony,
3D (developed by SUN and SGI), cryptography, server. (Beta)
What is Java Good For?
l Web Applets
l Database programming
– SQL databases using JDBC
– Object databases using ODMG binding
l Java Servlets
l Stand Alone Applications
– GUI based applications
l Distributed client-server applications
– Using TCPIP + RMI + CORBA
l Graphics applications
– 2D and 3D
l Physics Analysis
Hello World in Java
Java Applets
l Java Applets are programs designed
to run inside a web browser.
l Instead of having a “main” method
they have a class derived from
“Applet” whose “init” method is
called when the applet is loaded.
l The applet class provides
capabilities for loading images,
sounds and animations from the
internet.
l Applets loaded from the internet are
run inside a “sandbox” which
restricts what they can do:
– No Access to local filesystem
– Can only open network connections
with the site they came from
l Problems
– Lack of network/filesystem access
can be restrictive
– Complex programs can be large and
hence slow to download
– Sun has been introducing new
releases far to fast for browser
manufacturers to keep up.
– Each browser has subtle differences.
l Solutions?
– Java activator from SUN
• Plug in for netscape/IE to ensure
latest SUN features always available.
– Signed applets can be granted more
privileges.
• Can download local copies of large
programs
Java SQL Database Access
l Java provides standard interface to SQL
databases, JDBC
– Most database vendors now have implementations
of JDBC for use with their database
– Oracle has pure Java JDBC driver (no need to
install SQLNet, SQLPlus etc. to be able to use it).
l Makes it possible to write database programs
which are independent of the underlying database.
l Automatic translation of database types to native
Java types:
– e.g. Date/time in database is extracted as Java Date
object, manipulation of dates straightforward.
Java SQL Database Access
Java Object Database Access
l Using JDBC to connect to databases is fine for accessing
legacy data in SQL databases.
– Using SQL and pulling columns out of tables is a little
inconvenient.
– Would be better to create a network of related objects in
Java and
• “stick them all in a database”
• “retrieve all or part of the network later”
– This is what object databases are for
• ODMG (Object Database Management Group) has defined a
standard binding between Java and OO databases.
• Several OO databases new support the ODMG Java binding
Java Object Database Access
Java Servlets
l A Java Servlet runs on a web server instead of a web browser
– Performs similar function to CGI scripts under Unix
– Works with many web servers
• Netscape, Microsoft IIS, Apache, Java Web Server, many more...
– Machine independent
– Much faster than CGI (no process forking)
– Gives full power of Java for database access, data manipulation etc.
Real Applications in Java?
l So far all examples have been fairly trivial.
l Is it possible to write real applications in Java? Yes! (at least I hope so)
Java for Physics Analysis?
l Java has good mix of power, simplicity, math, speed for physics analysis
– SLD has developed a set of hep.analysis classes for Histograming
– Networking support and mobility of code excellent for client server applications.
• Analysis routine goes to data instead of data coming to analysis routine.
How to get started with Java
l Download free Java Developer Kit (JDK) from SUN (www.javasoft.com)
– Available for Windows, Solaris.
– Contains line mode compiler+debugger+misc. tools
– Similar kits available for many other platforms (from vendors)
– Solaris/AIX JDK installed for Unix at SLAC in /afs/slac/packages/java
l For more serious work get hold of a Java Integrated Development Environment
– Symantec Café (the oldest and most popular IDE at present)
– Visual J++ from Microsoft (beware of assimilation)
– Visual Age for Java from IBM
– Java Workshop from SUN
• All contain integrated editor/debugger/source control
• None have really good WYSIWYG layout tools (yet).
Topics to be Covered
l Java Language Features
– Variables, Operators, Expressions
– Statements
– Classes + Objects
– Inheritance
– Packages
– Exceptions
– Multithreading
– Data Structures
– Standard Libraries
l Plenty of example programs
– Tutorial rather than real-world programs
Types, Variables, Operators, Expressions
l Primitive Types
int, short, long, byte
• all signed
• size is machine independent
float, double
char
• Stores single UNICODE character
boolean
l Variables and Expressions
int a, b;
double salary = 100000;
float slacRaise = 1.00002;
salary = salary * slacRaise;
salary *= slacRaise;
salary -= parkingFine;
l Operators
+ - * / % ^ ++ --
! ~ & | && || ? :
<< >> >>>
< <= > >= == !=
l Strings
– Java has nice UNICODE string type
that supports concatenation, substrings,
comparison etc.
String s = “Your raise is ” +
slacRaise;
l Notes:
– if (a = 3) { } is illegal!
– No operator overloading
– No pointers! (But surprisingly you
won’t miss them)
Statements
l Again, very C like
if (condition
1
) {block
1
}
else if (condition
2
) {block
2
}
else {block
3
}
for (int i=0 ; i<10 ; i++)
{block}
while (condition) {block}
do {block} while (condition);
l Unfortunately even the switch
statement is just like C
switch (choice)
{
case 1:
case 2:
…
break;
case 3:
…
break;
default:
…
break;
}
Introduction to OO Programming
l Java is an object oriented
programming language, so some
rudimentary knowledge of OO
terminology is required
– Classes (e.g. “Employee”, “Track”)
• Objects
– specific instances of a class (e.g.
“Tony Johnson”, “Track 5”)
• In Java all functions are contained
within classes
• For largely historical reasons functions
are often called methods or member
functions
– Inheritance (aka subclassing)
• e.g. “Associate Director”, “Drift
Chamber Track”
– Encapsulation
• Variables/Functions can be declared:
– private
• only functions within same class
or superclass can access them (c.f.
C++ protected)
– public
• any function can access them
• Java also implements
– static
• Applies to class not object
– final
• Cannot be overridden by subclass
Classes
class Employee
{
public Employee (String n, double s)
{
name = n;
salary = s;
}
public Employee (String n)
{
name = n;
salary = 0;
}
public void raiseSalary(double byPercent)
{
salary *= 1 + byPercent / 100;
}
public double getSalary()
{
return salary;
}
private String name;
private double salary;
}
Class Declaration
Private Member Variables
Constructor
Overloaded Constructor
Access Method
Objects
l Objects represent instances of classes
Employee javaExpert = new Employee(“Joe”,100000);
javaExpert.RaiseSalary(10); // Raise salary by 10%
system.out.println(“Salary is” + javaExpert.GetSalary());
l Note that Java uses the keyword new for creation of new objects.
l Unlike C++ there is no delete keyword for the deletion of objects.
– Java handles deletion of objects (and recovery of the memory they occupy)
automatically as soon as there are no longer any references to them.
– This makes writing code much easier, it is “impossible” to create a memory
leak in Java..
– The process of keeping track of when objects are unreferenced and deleting
them is called “garbage collection”. It does impose some processing overhead
which slows down Java programs compared to equivalent programs in C or
C++.
èAppl_1 Example + EmployeeTest Example
Inheritance
class Manager Extends Employee
{
public Manager (String n, double s, Employee e)
{
name = n;
salary = s;
secretary = e;
}
public String GetSecretary()
{
return secretary;
}
public void RaiseSalary(double byPercent)
{
double bonus = 10;
super.RaiseSalary(byPercent + bonus);
}
private Employee secretary;
}
èManagerTest Example
Class Declaration
New member variables
Constructor
New Access Method
Overridden Method
Interfaces
l Interfaces in Java are a replacement
for the concept of “multiple
inheritance” in C++.
l Suppose we want to sort managers by
the number of employees they have.
l Interfaces
– Objects can implement any number of
interfaces
– Can have hierarchies of interfaces
– Interfaces cannot have methods
– Cleaner but not quite as powerful as
multiple inheritance
– Only way to implement “callbacks” in
Java
l Enumeration Interface
– Can loop over all elements of any class
that implements the enumeration
interface
Enumeration e = thing.elements();
while (e.hasMoreElements())
{
Thing t = e.getNextElement();
}
Employee
Sortable
Manager
l In C++ both Employee and Sortable
can be classes
l In Java one (probably sortable) must
be an “interface”
èEmployee Sort Example
Arrays, Collections etc.
l C++
– “If you build it they will come”
– Standard Template Library
l Java has powerful built in objects
– String
– Arrays
• Arbitrary size but cannot be resized
– Vectors
• Full dynamic sizing
– Bit Sets
• Arbitrary size array of bits
– HashTables + HashSets
• Quick way to look up object in large
collection
l Built in objects continued…
– Property Sets
• Useful for storing program
parameters
– Linked Lists
– Queues
– Stacks
– Multi-Dimensional Arrays
– Full featured “Collections” coming in
JDK 1.2
èSieve Example (Benchmark)
– C++ 1.53 seconds
– Java 59.93 seconds
– Visual Basic 65.69 seconds
– Microsoft JIT compiler ?3 seconds
Threads
l Threads are similar to “fork” or
“spawn” but
– Threads run in same address space,
not separate process
• Very efficient
• Very dangerous
– All modern operating systems have
support for threads
l Java has built-in support for threads
– Just derive a class from thread
– Issue the start() method on the
object
èBouncing Ball Example
l Java Threads support
– Priorities
– Interrupts
– Thread groups
– Synchronization
• synchronized keyword can be
applied to classes or methods
– Timers
Java AWT Package
l AWT allows development of
platform independent GUI programs
– Java takes a “Lowest Common
Denominator” approach
• Supports only one mouse button
• Doesn’t “look as nice” as native
windows/MAC applications
• Available graphical layout tools are
quite limited.
– Moderate set of graphic objects
• Buttons, Labels, Text Input, Menus,
• Scroll Bars, Dialogs, Radio Buttons
– Mapped onto native GUI objects on
each platform.
l “Layouts” are used to compensate for
the fact that GUI objects may have
different sizes on different platforms
– Limited set of layouts are provided
• Flow Layout
• Border Layout
• Card Layout
• Grid (Bag) Layout
– User defined layouts needed for most
real programs
èHelloWorld Example
Java for Physics?
import physics.hep.*;
class MyAnalysis extends Analysis
{
public void init()
{
h = new Hist(“Energy”);
}
public void Evanal(Event e)
{
Enumeration x = e.getTracks();
while (x.hasMoreElements())
{
Track t = x.getNextElement();
h.Add(t.getEnergy());
}
}
private Histogram h;
}
Java
Compiler
Experiment
Extensions
(Event Display)
GUI
Network
Data
Analysis
Engine
Users
Java
Code
Experiment
Interface
