Download ppt - UMBC

The JAVA
API
UMBC CMSC 331 Java
A Tour of the Java API
• An API User’s Guide, in HTML, is bundled with
Java
• Much of the “learning curve” is in the API
• Let’s look at some packages
UMBC CMSC 331 Java
2
The Java API
• java.applet
– Applet class
• java.awt
– Windows, buttons, mouse,
etc.
• java.awt.image
– image processing
• java.awt.peer
– GUI toolkit
• java.io
– System.out.print
• java.lang
– length method for arrays;
exceptions
• java.net
– sockets
• java.util
– System.getProperty
See http://docs.oracle.com/javase/8/docs/api/
for the current APIs
UMBC CMSC 331 Java
3
The package java.lang
• The class Object
– The root class in Java
– Example methods: clone(), equals(),
toString()
– Subclasses may override these methods
• The class Class
– Example methods: getName(),
getSuperClass()
UMBC CMSC 331 Java
4
Observing an object’s class
void printClassName (Object obj) {
System.out.println("The class of " + obj +
" is " + obj.getClass().getName());
}
UMBC CMSC 331 Java
5
Strings in Java
• Strings are nt a primitive data type, but represented
as objects.
• Many methods defined in class java.lang:
– Several constructors
– Lots of methods: concat(), equals(), indexOf(), length()
– strings are concatenated with +
• Strings are constants (immutable)
– You can concatenate two strings to produce a new,
longer string, using the + operator, but you cannot add,
delete, insert into, or delete from any particular string.
UMBC CMSC 331 Java
6
StringBuffers in Java
• Several methods defined in class java.lang:
– Constructors can specify length or initial value
– append(), insertf(), length(), toString()
UMBC CMSC 331 Java
7
Java.lang.system
• Printstreams
– System.out.err(“Error message”);
• Inputstreams
– System.in.read(inputCharacter)
– System.in.read(inputBuffer, 0, maxChars)
UMBC CMSC 331 Java
8
The Cloneable Interface
• A class implements the cloneable interface by
overriding the Object method clone()
• For example, we could add a clone() method to
the FIFO class, if we wanted to be able to make
copies of queues.
UMBC CMSC 331 Java
9
The class java.util
• Interface to host OS
• Some basic functions and data structures
– BitSet, Dictionary (the superclass of Hashtable), Stack,
Vector
– Random number generation
UMBC CMSC 331 Java
10
System Properties
• System properties are like UNIX environment
variables, but platform independent
• The API class java.util has methods for
accessing the system properties
UMBC CMSC 331 Java
11
// determine environment variables
import java.util.*;
class envSnoop {
public static void main ( String args[] ) {
Properties p;
String s;
p = System.getProperties();
p.list(System.out);
s = System.getProperty("user.name");
System.out.println("user.name="+s);
s = System.getProperty("user.home");
System.out.println("user.home="+s);
}
}
Java GUI
• The awt class allows you to create
– frames
– buttons
– menus and menubars
– checkboxes
– text areas
– scrolling lists
UMBC CMSC 331 Java
13
Java.net
• Defines several useful objects:
– URLs
– Internet Addresses
– Sockets
– Datagrams
• packets
• sockets
UMBC CMSC 331 Java
14
Manipulating URLs
• A Web server can provide lots of information
about a file being sent back in response to an HTTP
request.
• A URL can be read
– into a string, using the getContent()
– or opened as a DataInputStream, and read using
readLine()
UMBC CMSC 331 Java
15
import java.net.*;
import java.io.*;
import java.util.*;
public class GetURLInfo {
// Create a URL from the specified address, open a connection
// to it, and then display information about the URL.
public static void main(String[] args)
throws MalformedURLException, IOException {
URL url = new URL(args[0]);
URLConnection connection = url.openConnection();
printinfo(connection);
}
public static void printinfo(URLConnection u)
throws IOException {
// Display the URL address, and information about it.
System.out.println(u.getURL().toExternalForm() + ":");
System.out.println(" Content Type: " + u.getContentType());
System.out.println(" Content Length: " + u.getContentLength())
System.out.println(" Last Modified: " +
new Date(u.getLastModified()));
System.out.println(" Expiration: " + u.getExpiration());
System.out.println(" Content Encoding: " +
u.getContentEncoding());
// Read and print out the first five lines of the URL.
System.out.println("First five lines:");
DataInputStream in = new DataInputStream(u.getInputStream());
for(int i = 0; i < 5; i++) {
String line = in.readLine();
if (line == null) break;
System.out.println(" " + line);
}
}
}
UDP Examples
• UDP - Unreliable datagram packet
• Examples from Flanagan
– Send a UDP packet
– Receive a UDP packet
UMBC CMSC 331 Java
18
//
//
//
//
//
//
//
This example is from the book _Java in a Nutshell_ by
David Flanagan.
Written by David Flanagan.
Copyright (c) 1996 O'Reilly & Associates.
You may study, use, modify, and distribute this example for
any purpose. This example is provided WITHOUT WARRANTY
either expressed or implied.
import java.io.*;
import java.net.*;
// This class sends the specified text as a datagram to
// port 6010 of the specified host.
public class UDPSend {
static final int port = 6010;
public static void main(String args[]) throws Exception {
if (args.length != 2) {
System.out.println(
"Usage: java UDPSend <hostname> <message>");
System.exit(0);
}
// Get the internet address of the specified host
InetAddress address = InetAddress.getByName(args[0]);
// Convert the message to an array of bytes
int msglen = args[1].length();
byte[] message = new byte[msglen];
args[1].getBytes(0, msglen, message, 0);
// Initilize the packet with data and address
DatagramPacket packet = new DatagramPacket(message,
msglen, address, port);
// Create a socket, and send the packet through it.
DatagramSocket socket = new DatagramSocket();
socket.send(packet);
}
}
import java.io.*;
import java.net.*;
// This program waits to receive datagrams sent to port 6010.
// When it receives one, it displays the sending host and port,
// and prints the contents of the datagram as a string.
public class UDPReceive {
static final int port = 6010;
public static void main(String args[]) throws Exception
{
byte[] buffer = new byte[1024];
String s;
// Create a packet with an empty buffer to receive data
DatagramPacket packet = new DatagramPacket(buffer,
buffer.length);
// Create a socket to listen on the port.
DatagramSocket socket = new DatagramSocket(port);
for(;;) {
// Wait to receive a datagram
socket.receive(packet);
// Convert the contents to a string
s = new String(buffer, 0, 0, packet.getLength());
// And display them
System.out.println("UDPReceive: received from " +
packet.getAddress().getHostName() +
":" + packet.getPort() + ": " + s);
} // close for
} // close main
}
// close class UDPReceive
Using Threads
• Thread objects are the basis for multi-threaded
programming.
• Multi-threaded programming allows a single
program to conduct concurrently running threads
that perform different tasks.
• Defined in java.lang.Thread
UMBC CMSC 331 Java
23
The Runnable Interface
• A class that implements this interface can provide
the “body” of a thread
• The run() method needs to be specified
UMBC CMSC 331 Java
24
Using a Single Thread
• The simpleThread class implements the
Runnable interface
– Implements run() method for Runnable interface
– Implements init(), start() and stop(),
extending Applet class
– Can’t just extend Thread class, since Thread.stop()
is final and can’t be overriden (why?)
UMBC CMSC 331 Java
25
// Simple Thread Example, based on "Neon Sign"
public class OneThread extends java.applet.Applet
implements Runnable {
Thread kicker;
public void init() { kicker = null; }
public void start() {
if(kicker == null) {
// If no thread is started yet
kicker=new Thread(this);
// then create one
kicker.start();
// and start it
}
}
public void stop() { kicker.stop(); kicker = null; }
public void run() {
long sleepTime;
System.out.println("Hello!");
sleepTime = 5000;
while(true) {
// Loop forever
// The sleep method below might be interrupted
// and cause an exception, so catch it.
try {
// Wait for some period of time
Thread.sleep( sleepTime );
sleepTime = (sleepTime == 3000 ? 4000 : 3000 );
} catch (Exception e){ return; }
System.out.println("Hello again after "+sleepTime+
" milliseconds");
}
}
}
Neon Sign Example
• Start a thread
• Load two GIF images
• Repeat forever
– Display first image
– Sleep a random period of time
– Display the other image
UMBC CMSC 331 Java
28
// Blinking Neon Light by Mattias Flodin
import java.awt.*;
public class BlinkItem extends java.applet.Applet implements Runnable {
Image imPic[];
// Array that holds the two images
int iPicIndex=0;
// Keeps track of which image is displayed
Thread kicker;
public void init() {
// *Always* resize, in case the HTML author forgot to
// include WIDTH and HEIGHT tags
resize(512,243);
}
public void Paint(Graphics g) { update(g); }
// Using the update method will get rid of some flickering
public void update(Graphics g) {
// Display an error message if something
// unexpected has happened to the images
if(imPic[iPicIndex]==null)
g.drawString("Error when loading picture", 0, 172);
// Draw the current image
g.drawImage(imPic[iPicIndex],0,0, this);
}
public void start() {
if(kicker == null) {
// If no thread is started yet
kicker=new Thread(this);
// then create one
kicker.start();
// and start it
}
}
public void stop() { kicker=null; }
public void run() {
imPic=new Image[2];
// Dimension the image array
// Load the two images in our 'animation'
imPic[0]=getImage(getCodeBase(), "images/Homepage1.gif");
imPic[1]=getImage(getCodeBase(), "images/Homepage2.gif");
for(;;) {
// Loop forever
repaint();
// Redraw the window
iPicIndex=iPicIndex==0 ? 1 : 0;
// Switch image
// The sleep method below might be interrupted
// and cause an InterruptedException, so we'll
// have to catch it.
try {
// Wait for a random amount of time
Thread.sleep( (int) (Math.random()*500));
} catch (InterruptedException e){}
}
}
}
Multiple Threads
• An applet that creates a pool of simple threads
• Each thread has an ID number, and may handle
different tasks
• Note separation of applet and thread classes
UMBC CMSC 331 Java
31
Multiple Threaded Example
public class ThreadExample extends java.applet.Applet {
public void init() {
simpleThread[] threadPool = new simpleThread[2];
threadPool[0] = new simpleThread(1);
threadPool[1] = new simpleThread(2);
}
}
UMBC CMSC 331 Java
32
public class simpleThread implements Runnable {
Thread thisThread;
int thisThreadID;
public simpleThread (int i) {
thisThreadID = i; this.start(); }
public void start() {
if(thisThread == null) {
// If thread isn’t started
thisThread = new Thread(this);
// create one
thisThread.start();
// and start it
}
}
public void stop() { thisThread.stop();
thisThread = null; }
public void run() {
long sleepTime;
System.out.println("Hello from simpleThread "+
thisThreadID);
while(true) {
// The sleep method below might be interrupted
// and cause an exception, so catch it.
try {
// Wait for a random amount of time
sleepTime = (long) ( Math.random()*4 );
Thread.sleep( sleepTime*1000 );
} catch (Exception e) {
return;
}
System.out.println("Hello again from simpleThread "+
thisThreadID+" after "+sleepTime+" seconds");
}
}
}
Other Ideas
• Patterns as an addition to the StringBuffer class
(ala Perl)
• One could easily write a better browser
– intelligent pre-fetching of URLs
– other ideas?
UMBC CMSC 331 Java
35
Where to get more information
• There are now many decent Java books
• Many other web resources
UMBC CMSC 331 Java
36