Download Java Crash Course

yes no Was this document useful for you?
   Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Document related concepts
no text concepts found
A Tutorial Introduction for C++ Programmers
So what the heck is Java (besides coffee,
that is)?
A programming language.
Syntax and constructs are very similar to C++
A virtual platform
Java Virtual Machine is a software “machine” or
“hypothetical chip”
 Since it’s “virtual”, it can be implemented on any hardware
 Cross-platform distribution achieved via .class binary file
of bytecodes (instead of machine-dependent machine
code)  Write Once, Run Anywhere
A class library
Standard APIs for GUI, data storage, processing, I/O, and
Getting Java Brewing…
1. Download the latest Java SDK from
The SDK is a command-line based set of tools
2. A Text Editor: our choice is, of course, Emacs! 
3. Web-browser that’s java-enabled (optional)
4. IDE like BlueJ from or JCreator from (optional)
5. Some introductory links/guides/tutorials:
Mechanics of Writing Java Programs
 Create a Java source file. Must have the .java extension and
contain only one public class.
 Compile the source file into a bytecode file. The Java
compiler, javac, takes your source file and translates its text into
instructions that the Java Virtual Machine (Java VM) can understand.
The compiler puts these instructions into a .class bytecode file.
 Run the program contained in the bytecode file. The
Java VM is implemented by a Java interpreter, java. This interpreter
takes your bytecode file and carries out the instructions by translating
them into instructions that your computer can understand.
Putting it all together
public class Hello {
public static void main(String args[]) {
System.out.println(“Hello, world!”);
1. Put in:
2. Compile with: javac
 Creates Hello.class
3. Run with: java Hello
Applications vs. Applets
A Java application:
 Is a standalone program
 Is interpreted by the Java Virtual Machine and run using the java
 Contains a main() method.
A Java applet:
 Runs within a Java-enabled Web browser
 extends the Applet or JApplet class (Inheritance)
 Contains an init() or a paint() method (or both).
To create an applet, you'll perform the same basic steps:
1. Create a Java source file ( and an HTML
file (NameOfHTMLFile.html)
2. Compile the source file (NameOfProgram.class)
3. Run the program (either using java NameOfProgram
(application) or appletviewer NameOfHTMLFile.html
Java notes for C++ programmers
Everything’s an object
No code outside of the class definition!
No global variables (use static variables instead)
Single inheritance only
Every object inherits from java.lang.Object
Instead, implement interfaces
All classes are defined in .java files
One top level public class per file
The file has to have the same name as the public class!
Syntax is similar (control structures are very similar).
Primitive data types are similar
 But a bool is not an int
 To print to stdout, use System.out.println()
Requisite First Program (Application
Put in
public class HelloWorld {
public static void main(String args[]) {
System.out.println("Hello World");
Compiling and Running
source code
java HelloWorld
So what’s going on?
The Java bytecode and interpreter at work!
Bytecode is an intermediate representation of the
program (the class file)
 Think
of it as the machine-code for the Java Virtual
The Java interpreter (java) starts up a new
“Virtual Machine”
The VM starts executing the user’s class by
running its main() method
Requisite First Program (Applet Version)
Put in
import java.awt.Graphics;
public class HelloWorld extends java.applet.Applet {
public void paint(Graphics g) {
g.drawString("Hello World“, 35, 15);
Put in test.html:
<title>Test the applet</title>
<h3>Test the applet</h3>
<applet code=“HelloWorld.class” height=“200”
Cool Applet Methods
Basic methods on Applet
 init(): called once for your applet
 start(): called every time you enter the page
 stop(): called every time you leave the page
 destroy(): called when your page is discarded
Funky methods on Applet
 AudioClip getAudioClip(URL url): gets audioClip object (play
 Image getImage(URL url): starts asynchronous image loading
 constructor takes normal string argument (used to
store URLs)
 void showDocument(URL url): tells browser to load new
 void showStatus(String msg): writes to browser status line
Applet repainting
 paint(): defaults to nothing
 update(): clears screen, calls paint()
 repaint(): passes events to Motif/Win32  don’t override/change this
Java Language Basics
Data types same as in C++ (except bool)
double,string, etc.
Operators (same as C++)
Assignment: =, +=, -=, *=, …
 Numeric: +, -, *, /, %, ++, --, …
 Relational: ==. !=, <, >, <=, >=, …
 Boolean: &&, ||, !
 Bitwise: &, |, ^, ~, <<, >>, …
Control Structures  more of what you expect:
conditional: if, if else, switch
2. loop: while, for, do
3. break and continue
Classes, References, & Packages
Classes and Objects
 “All Java statements appear within methods, and all methods are
defined within classes”.
 Java classes are very similar to C++ classes (same concepts).
 Instead of a “standard library”, Java provides a lot of Class
implementations or packages
What are packages?
 You can organize a bunch of classes and interfaces into a package
(or library of classes)
Use the import keyword to include the packages you need
import java.applet.*;
You need to use some java packages in your programs
defines a namespace that contains all the classes.
java.awt (Abstract Windowing Toolkit), (for Files, etc.), java.util
(for Vectors, etc.)
 No pointers  everything’s a reference!
 classes
 arrays
Type Conversions (Skip)
conversion between integer types and
floating point types.
 this
includes char
No automatic conversion from or to the type
You can force conversions with a cast – same
syntax as C/C++.
int i = (int) 1.345;
When a program carries out an illegal action, an
exception is generated.
 throw
an exception: signal (in the method header)
that some condition or error has occurred but we
want to pass the buck and not deal with it.
 catch an exception: deal with the error (or whatever)
ourselves inside the function/method.
 Catch it using a try/catch block (next slide).
In Java, exception handling is necessary (forced by
the compiler  compilation errors!)
 Except
for RunTimeExceptions
try {
// code that can throw an exception
} catch (ExceptionType1 e1) {
// code to handle the exception
} catch (ExceptionType2 e2) {
// code to handle the exception
} catch (Exception e) {
// code to handle other exceptions
} finally {
// code to run after try or any catch
This block is always run
Exception Handling
Exceptions take care of handling errors
 instead
of returning an error, some method calls will
throw an exception.
Can be dealt with at any point in the method
invocation stack.
 But
if no method in the hierarchy handles it, results
in an unchecked exception which generates a
compiler error (unless it’s a RunTimeException)
Forces the programmer to be aware of what errors
can occur and to deal with them.
Defining a Class
One top level public class per .java file.
end up with many .java files for a single
program with at least one containing a static
public main() method (if they’re applications).
 Typically
Class name must match the file name!
 The
compiler/interpreter use class names to figure out
what the file name is.
Classes have these three features:
that’s used to allocate memory for the
object, initiailize its elements, and return a reference
to the object
 Methods (function members)
 Fields (data members)
 A constructor
A Sample Class
public class Point {
public Point(double x, double y) {
this.x = x; this.y=y;
public double distanceFromOrigin(){
return Math.sqrt(x*x+y*y);
private double x,y;
Objects and new
You can declare a variable that can hold an object:
Point p;
But this doesn’t create the object! You have to use
Point p = new Point(3.1,2.4);
new allocates memory and the garbage collector
reclaims unused memory
Using Java objects
Just like C++:
 object.method()
BUT, never like this (no pointers!)
 object->method()
or object.field
or object->field
Event driven model:
 Objects
“register” to receive (and respond to) certain
messages like button presses, mouse clicks, etc.
(e.g., mouseUp(), mouseDown(), keyUp(),
Strings are special
You can initialize Strings like this:
String blah = "I am a literal ";
Or this ( + String operator):
String foo = "I love " + “CET375";
Or this ( new operator):
String foo = new String(“Yummy FooBars!”);
Arrays are supported as a second kind of reference type
(objects are the other reference type).
Although the way the language supports arrays is different
than with C++, much of the syntax is compatible.
Index starts at 0.
Arrays can’t shrink or grow.
e.g., use Vector instead.
Each element is initialized.
Array bounds checking (no overflow!)
however, creating an array requires new
Arrays have a .length
Array Examples
int x[] = new int[1000];
byte[] buff = new byte[256];
float[][] mvals = new float[10][10];
int[] values;
int total=0;
for (int i=0;i<value.length;i++) {
total += values[i];
Array Literals
You can use array literals like
C/C++ (no need for new keyword):
int[] foo = {1,2,3,4,5};
String[] names = {“Joe”, “Sam”};
Reference Types
Objects and Arrays are reference types
Primitive types are stored as values
Reference type variables are stored as references
(pointers that we can’t mess with)
Primitive vs. Reference Types
int x=3;
int y=x;
There are two copies of
the value 3 in memory
Point p = new Point(2.3,4.2);
Point t = p;
There is only one Point
object in memory!
Passing arguments to methods
Primitive types: the method gets a copy of the
value. Changes won’t show up in the caller
 Pass by value
Reference types: the method gets a copy of the
reference, the method accesses the same object
 Pass by reference
There is no pass by pointers!
Comparing Reference Types
Comparison using == means:
 “Are
the references the same?”
 Do
they refer to the same object?
Sometimes you just want to know if two
objects/arrays are identical copies.
 Use
the .equals() method
 You
need to write this for your own classes!
All objects and arrays are references!
Use the extends keyword to inherit from a super
(or parent) class
No multiple inheritance
implements to implement multiple interfaces
(abstract, virtual classes)
 Use
Use import instead of #include (not exactly
the same but pretty close) to include packages
Using Documentation Comments
Documentation comments are delimited by /**
and */
javadoc automatically generates documentation
 Copies
the first sentence of each documentation
comment to a summary table
 Write
the first sentence with some care!
For each method/class, supply:
 @param
followed by the parameter name and a short
 @return followed by a description of the return
 @author for author info, etc.
 Need
to use “javadoc –author” for this…
Must come immediately
before the class, method,
The Java Standard calls for every class, every
method, every parameter, and every return value to
have a comment
Write the method comments first!
 If
you can’t explain what a class or method does, you
aren’t ready to implement it!
How to create HTML documentation:
javadoc *.java in the directory containing
your source code
 This produces one HTML file for each class and an
index.html file
 Documenation is together with code!
 Type:
A Gooey GUI!
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
What does an applet with multiple buttons and a text field look
like? We’ll develop this in more detail in lab but let’s just
see it (in all its gory detail) here in
public class ClickMe extends Applet implements ActionListener {
private TextField text1;
private Button button1;
Add GUI elements in init()
public void init() {
Add components to the
text1 = new TextField(20);
current frame (AWT)
button1 = new Button (“Click me please!”);
Register a class (this one) to
listen for button events
public void actionPerformed(ActionEvent e) {
String msg = new String (“Hello, world!”);
if (e.getSource() == button1) {
It don’t mean a thing…
Adding Swing to GUI applets/applications is easy:
Add import javax.swing.*; or import
Use JApplet instead of Applet, JButton instead of Button,
JTextField instead of TextField, etc.
These are from the JFC (hence, all the “J” prefixes)
In addition, you need to add components to the correct
ContentPane by doing the following in the init() fxn:
Use JPanel contentPane; to declare it and
contentPane = new JPanel(); to initialize a new
 Could also have used Container contentPane =
getContentPane() if our class extends JFrame
add everything to that contentPane using a statement like
Finally, do a setContentPane(contentPane); (all in the
init() function) to make this the active contentPane
Instead of the default FlowLayout (left-to-right), use
the GridLayout or GridBagLayout to add buttons
and other GUI elements along the grid
To call GridLayout, just use:
 setLayout(new
GridLayout(9,3)); for AWT
or contentPane.setLayout(new
GridLayout(9,3)); for Swing
GridLayout’s first argument is the number of rows
(0 for unlimited) and the second argument is the
number of columns
An example of a Swing-based GridLayout applet:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class ButtonsArray extends JApplet implements ActionListener {
private JTextField text[] = new JTextField[3];
private JButton button[]
= new JButton[3];
private JPanel contentPane = new JPanel();
public void init() {
contentPane.setLayout(new GridLayout(3,2));
for (int i=0; i<3; i++) {
text[i] = new JTextField(20);
button[i] = new JButton(String.valueOf(i));
public void actionPerformed(ActionEvent e) {
for (int i=0; i<3; i++) {
if (e.getSource() == button[i]) {
text[i].setText("Clicked Button #" + i);
Concurrent Multi-threaded Programming
Java is multithreaded!
Threads are easy to use.
Two ways to create new threads:
Extend java.lang.Thread
Implement Runnable interface
Override “run()” method.
Include a “run()” method in your class.
Usually, you’ll implement the Runnable interface
How to implement the Runnable interface:
Add a public void start() function:
Add a public void stop() function:
This is where you’ll initialize the thread and start() it
This is where you’ll set the boolean stopFlag to true
Add a public void run() function:
This is where you’ll call repaint() to paint each new frame
and handle any synchronized variables or methods
The synchronized Statement
Instead of mutex (a binary semaphore), use
synchronized ( object ) {
// critical code here
Also, declare a method as synchronized:
synchronized int blah(String x) {
// blah blah blah
Can also use wait() and notify() to put
threads on hold and wake them up again (e.g., to
implement a pause or suspend feature)
 Must
be called within a synchronized block
Composing an image off-screen to avoid flickering
Not needed with Swing objects (already double-buffered!)
Create an offscreen graphics image and context:
Image offscreen;
Graphics offgraphics;
Dimension offdim;
Set them in init() method:
offdim = getSize();
offscreen = createImage(offdim.width,offdim.height);
offgraphics = offscreen.getGraphics();
// Create offscreen image of same size:
// Setup offscreen graphics context
Add an update() method that simply calls paint():
// Get size of applet first:
Overriding update() prevents the OS from wiping off the applet’s previous
drawings and, instead, immediately repaints (since wiping off causes flickering,
too). Called automatically when repaint() is called.
Do all drawing to offscreen graphics context in the paint() method:
Erase the previous image (with a big blank rectangle)
Do all new drawing to the offscreen graphics context
Finally, draw the offscreen image to the screen like a normal image:
gr.drawImage(offscreen,0,0,this); //offscreen is width of screen, so start at 0,0
Some Random Links