JAVA Programming

www.alljntuworld.
in JNTU World
ld
Introduction
to the
or
Java Programming Language
W
TU
JN
Downloaded From JNTU World (http://www.alljntuworld.in)

www.alljntuworld.in JNTU World
Contents
Day 1
● Basics of the Java Language
● Object-oriented Principles with Java
ld
● Encapsulation
● Inheritance
● Polymorphism
● Exception Handling
or
Day 2
● Java API
● Some design patterns that are useful to understand the Java API
Iterator Design Pattern
W
●
● Adapter Design Pattern

● Decorator Design Pattern
● Observer Design Pattern
● Strategy Design Pattern
● Composite Design Pattern
TU
● Abstract Factory Design Pattern
● Singleton Design Pattern
● Java Collections Framework
● Data structures
● Algorithms
JN
Day 3
Input/Output Operations in Java
●
● Multi-threaded Programming in Java

● GUI Design in Java
● Using an external library
● XML processing in JavaDownloaded From JNTU World (http://www.alljntuworld.in)
Java Programming Language

● Simple
ld
● Architecture neutral
● Object oriented
● Portable
Distributed
or
●
● High performance (!)

● Multi-threaded
● Robust
● Dynamic
W
● Secure
● Open source
Java Platform
● Java API
TU
● JVM
JN

Java Virtual Machine

Java is compiled into bytecodes
ld
●
● Bytecodes are high-level, machine-independent instructions for

a hypothetical machine, the Java Virtual Machine (JVM)
or
● The Java run-time system provides the JVM
● The JVM interprets the bytecodes during program execution
W
● Since the bytecodes are interpreted, the performance of Java
programs slower than comparable C/C++ programs
● But the JVM is continually being improved and new techniques

TU
are achieving speeds comparable to native C++ code
JN

Major Java Technologies

J2SE (Java applications, applets)
ld
●
● J2EE (servlets)
or
● J2ME (MIDlets)
W
They have different runtime environments but they are all programmed with the
Java language.
TU
JN

Keywords of Java
ld
Abstract double int static
Boolean Else interface super
Break extends long switch
Byte Final native synchronized
or
Case Finally new this
Catch Float null throw
Char For package throws
Class Goto private transient
W
Const if protected try
Continue implements public void
Default import return volatile
Do instanceof short
TU
Not much different from C/C++
Most of the time doing things the C++ way works

JN
BNF Index of JAVA language grammar:

http://cui.unige.ch/db-research/Enseignement/analyseinfo/JAVA/
Difference of Java from C++

● No typedefs, defines or preprocessor
ld
● No header files
No structures or unions
or
●
● No enums
No functions - only methods in classes
W
●
● No multiple inheritance
● No operator overloading (except “+” for string concatenation)

TU
● No automatic type conversions (except for primitive types)
● No pointers
JN


Naming Conventions
ld
Identifier type Convention Examples
Class names Capitalize each word within identifier ConnectionManager
or
Method names Capitalize each word except the first connectPhone
Variable names Capitalize each word except the first phoneNumber
W
Constant Capitalize each word with underscores
MAX_CONNECTIONS btw words
TU
If you comply with these conventions, you make everyone's life easier.
JN


Structure of a Java Source File

Source file should have the same name as the class it declares
ld
// AnExample.java
package ch.alari.javatutoring; AnExample.java needs to reside in ch/alari/javatutoring

import java.io.*; Imported classes need to be in the classpath at compile-time
or
class AnExample
{
private int x; Variable declarations
W
public AnExample(int x) Constructor
{
this.x = x;
}
/* Interface of the class

TU
to other classes.
*/
public int getX() Method declarations
{
return x;
}
JN
public void setX(int x)

{
this.x = x;
}
}

Information on Exercises
ld
● These slides are accompanied with a lab-skeletons.tar.gz file
where all the exercises that will be done during the class are put in
a directory structure along with
● a test driver class for the classes you are expected to write,
or
● Makefiles and
● text files that show the correct output of programs.
W
● make to compile
● make run to run
● make check to see if your implementation is correct
● make clean to remove *.class files
TU
● See the README file in lab-skeletons.tar.gz for more information
JN

HelloWorld Example (ex.1)
ld
// HelloWorld.java
class HelloWorld
{
or
public HelloWorld()
{
}
public static void main(String[] args)

{
W
System.out.println(“Hello World!”);
}
}
TU
export PATH=$PATH:/opt/java/bin
Compiling
javac HelloWorld.java
java HelloWorld
Running
JN


HelloWorld Example using packages (ex.2)

// HelloWorld.java
ld
package ch.alari.javatutoring.examples;
class HelloWorld
or
{
public HelloWorld()
{
}
W
{
System.out.println(“Hello World!”);
}
}
TU
javac
Compiling
ch/alari/javatutoring/examples/HelloWorld.java
java ch.alari.javatutoring.examples.HelloWorld
Running
JN
These commands are issued from within the

directory that contains the directory named “ch”!!!
If you import 3rd party classes,
you need to
include them with “-classpath” argument.
Some Java features
ld
● Garbage collection
● Primitive types: int, double, long, float, boolean
or
● Anything else is derived from java.lang.Object
(as if public class MyExampleClass extends Object)
● Every variable in Java (except primitives) is like a reference in C++
W
● Arguments in method calls are passed always by value. (value of reference)
TU
JN


Pass-by-value(-of-reference) (ex.3)
public class Main {
ld
public Main() {
}
or
{
Point p1 = new Point(1,2);
W
translateBy5(p1);
System.out.println(p1.x + " " + p1.y); Outputs p1.x=6, p1.y=7

}
TU
public static void translateBy5(Point p)
{
p.x += 5;
p.y += 5;
}
JN
}

- Analyze JavaValueReference.java
Lab exercise (ex.4)
ld
● Write a swap function that swaps two integers.
or
● Compile and run your program.
● Check if it works.
W
Hint:
Sol.1) Use an array
Sol.2) Define a MyInteger class
TU
JN


Lab exercise (ex.5)
ld
● Convert one of the C++ exercises you have written last week into Java.
or
● Or convert bubblesort.cpp to BubbleSort.java
● Compile and run your program.
W
● Check if it works.
TU
JN


Object-Oriented Principles with Java
ld
● Encapsulation: provided by private-protected-public identifiers
in class members
● Inheritance:
or
● provided by extends keyword
● abstract keyword declares methods and classes as abstract
● super(): explicit call for constructing parent
W
● Polymorphism:
● Method overloading: same method name with different signatures
● Interfaces: interface and implements keyword

TU
JN


Encapsulation
ld
● provided by private-protected-public identifiers in class members
public class Guardian

{
or
private Key prisonKey;
public Key getPrisonKey(Person requester)
{
if(requester.getType() == Person.PRISON_STAFF)
W
return prisonKey;
else
return null;
}
}
TU
JN

Encapsulation
ld
or
W
For members of Alpha class:
Visibility Modifier Alpha Beta AlphaSub Gamma

TU
public Y Y Y Y
protected Y Y Y N
no modifier Y Y N N
JN
private Y N N N
See http://www.uni-bonn.de/~manfear/javaprotection.php
for a nice example
Inheritance
ld
● Inheritance:
● provided by extends keyword
● abstract keyword declares methods and classes as abstract
● super(): explicit call for constructing parent
or
● public abstract class Shape
{
protected double area;
protected String name;
W
public abstract double getArea();
public Shape(String name){ this.name = name; }
}
● public class Rectangle extends Shape Only single inheritance allowed

{
TU
private double a = 5, b = 6;
public Rectangle(String name){ super(name); }
public double getArea()

{
area = a*b;
JN
return area;
}
}
● Shape s = new Rectangle(“Rectangle A”); // up-casting done implicitly.
● s.getArea();
Polymorphism
ld
● Method overloading: same method name with different signatures
public class Matrix

{
or
public Matrix(){ ... }
public Matrix multiply(Matrix m){ ... }
public Matrix multiply(double scalar){ ... }
}
Interfaces: interface and implements keyword
W
●
public interface Swimmer

{
public static final int a = 10; Seems like multiple inheritance
public void swim();
TU
}
public class Triathlete implements Swimmer, Runner, Cyclist

{
public class Triathlete(){...} Triathlete t = new Triathlete();
JN
public void swim(){...} Swimmer s = t;

Runner r = t;
public void run(){...} Cyclist c = t;
public void cycle(){...} if ( s instanceof Triathlete)

} Triathlete t1 = (Triathlete) s;
An Example: Bondus
ld
● Bondus is a program that bonds people together by informing each other
on their current status (Available, Busy, Out of office etc.)
● http://www.alari.ch/~derino/bondus
● Interested students are welcome to join
or
Class Hierarchy
● public interface Publisher
● public boolean publish(String status);
W
● public class FTPPublisher implements Publisher
● public boolean publish(String status)
{
// connect to FTP server and send the status file
TU
}
● public class SSHPublisher implements Publisher

● public boolean publish(String status)
{
JN
// connect to SSH server and send the status file

}


Lab Exercise (ex.6)

● Given a two dimensional point class (Point.java), extend it to a
ld
three dimensional point class (Point3D.java)
or
W
TU
JN


Lab Exercise (ex.7)

● Create the Java code corresponding to the following UML class diagram
ld
or
W
TU
JN


Lab Exercise
● Operations of subclasses shown
ld
or
W
TU
JN


Exception Handling (ex.8)

● try, catch, finally, throw, throws, Exception class
ld
public void methodName () throws Aexception, BException
{
...
or
throw new AException();
...
throw new Bexception();
...
W
}
try{
methodName(); // a code block that can throw an exception.
} catch(AException ex)
TU
{
// handle the exception of type AException
} catch(BException ex)
{
// handle the exception of type BException
JN
} finally
{
// this code block is executed whether there is an exception or not.
}

Exception Handling
ld
● Define exceptions by extending from Exception class
public class UnauthorizedKeyAccessEx extends Exception

{
or
}
W
TU
JN


Java API
ld
● All classes contained under the package java and javax.
● import java.* or import javax.*
or
● Provides a lot of useful classes (Containers, Enumerators, ...)
● Hard to list them all
W
● Before trying to write a class, first check the Java API.
● Java API is open-source.

TU
● Javadoc documentation of all these classes are available on http://java.sun.com
● Provides a good example of Java programming, useful for self-teaching
● Extensive use of design patterns

JN
3rd Party API’s
●
A lot of 3rd party APIs are available as open
source projects

Iterator Pattern
● Provides a way to access the elements of a collection sequentially without
ld
exposing its underlying representation
● Supports multiple, concurrent traversals of collections
● Provides a uniform interface for traversing different collections
(that is, supports polymorphic iteration)
or
● Appears in Java API as
● java.util.Iterator: boolean hasNext(), Object next(), remove()
W
for(Iterator i = v.iterator(); i.hasNext(); )
System.out.println(i.next());
● java.util.Enumeration: boolean hasMoreElements(), Object nextElement()

TU
for (Enumeration e = v.elements(); e.hasMoreElements(); )
System.out.println(e.nextElement());
JN


Adapter Pattern
● Convert the interface of a class into another interface clients expect.
ld
● Adapter lets classes work together that couldn't otherwise because of
incompatible interfaces.
or
● Also known as Wrapper
● You want to use an existing class, and its interface does not match the one
you need
Client
W
TargetInterface
targetMethod()
TU
adaptee
Adapter Adaptee
JN
targetMethod() aMethod()

Decorator Pattern
● A flexible alternative to subclassing for extending functionality
ld
● Also known as Wrapper
or
W
Decorator2
aMethod() Decorator1
aMethod() Component
TU
aMethod()
JN


Observer Pattern
ld
● Define a one-to-many dependency between objects so that when one object
changes state, all its dependants are notified and updated automatically
● Maintains consistency between related objects without making
or
classes tightly coupled
● Corresponds to callbacks/signals in C/C++
W
Subject Observer
observers
addObserver() notify()
TU
removeObserver()
notify()
JN

Strategy Pattern
ld
● Define variants of algorithms, encapsulate each one, and make them
interchangeable Clients can use different algorithms when needed.
● Provides an alternative to sub-classing to get a variety of algorithms.
or
SortArray SortStrategy
W
sortStrategy
sort() sort()
TU
BubbleSort QuickSort
sort() sort()
JN


Composite Pattern
ld
● Compose objects into three structures
● Individual objects and compositions of objects can be treated uniformly
or
Component
W
operation()
TU
Leaf Composite
children
operation() operation()
JN


Abstract Factory Pattern
ld
● In the case when
● A system should be independent of how its products are created,
composed and represented
or
● A family of related product objects is designed to be used together
and you need to enforce this constraint
● e.g. Consider a VLSI design tool. The class to instantiate an AND gate may
W
vary depending on the configuration set by the designer.
AbstractFactory -> GateFactory (has createAND(), createOR() etc. methods)

ConcreteFactory -> SiliconGateFactory (Silicon as the underlying substrate)
ConcreteFactory -> TechnologyGateFactory (45, 60, 90nm technologies)
TU
AbstractProduct -> ANDGate
ConcreteProduct -> SiliconBasedANDGate
ConcreteProduct -> 45nmANDGate
JN


Singleton Pattern
ld
● To make sure there is only one instance of a class and it is accessible globally
Singleton
or
static instance()
class Singleton {
W
private static Singleton uniqueInstance = new Singleton();
...
private Singleton(){
...
}
TU
public static Singleton instance() {
return uniqueInstance;
}
...
JN
To access to the singleton

Singleton s = Singleton.instance();
Java Collections Framework
ld
● A collection is an object that represents a group of objects
● Using this framework

● Reduces programming effort
or
● Increases performance
● Provides interoperability between unrelated APIs
● Reduces the effort required to learn APIs
● Reduces the effort required to design and implement APIs
W
● Fosters software reuse
● It consists of
● Collection interfaces (Collection, Set, List, Map, Queue, ... )
● Set: No duplicate elements permitted. May or may not be ordered.

TU
● List: A sequence. Duplicates are generally permitted. Allows positional
access.
● Map: A mapping from keys to values. Each key can map to at most one
value.
● Several implementations which differ in abstraction and performance
JN
criteria
● Algorithms that perform useful functions on collections

● Infrastructure interfaces (Iterator and Enumeration)
java.util.Vector
ld
● Is a List
● implements a growable array of objects.
● Like an array, it contains components that can be accessed using an integer
index.
or
● However, the size of a Vector can grow or shrink as needed to accommodate
adding and removing items after the Vector has been created.
Ex.9
W
Vector fruits = new Vector();
fruits.add(“apple”);
fruits.add(“orange”);
fruits.add(“potato”); Run this code
fruits.remove(“potato”); and change it to use
TU
fruits.contains(“potato”); generics
fruits.size();
fruits.elementAt(0);
for(java.util.Enumeration e= fruits.elements(); e.hasMoreElements(); )

JN
{
}


Vector exercise (ex.10)
ld
●Using java.util.Vector class and Adapter pattern, write a SortedVector class
that implements a SortedCollection interface that has methods:
● void addSorted(Comparable obj)
or
● Object elementAt(int index)
● Enumeration elements()
● int size()
W
● public class SortedVectorTest {
public SortedVectorTest() {}
public static void main(String[] args) Should output:

{ a
SortedCollection sv = new SortedVector();
sv.addSorted("g"); b
TU
sv.addSorted("k"); c
sv.addSorted("b");
sv.addSorted("c");
g
sv.addSorted("l"); k
sv.addSorted("p");
sv.addSorted("a");
l
sv.addSorted("z"); p
sv.addSorted("s");
s
JN
for(Enumeration e = sv.elements(); e.hasMoreElements();) z

}
}

java.util.Stack
● represents a last-in-first-out (LIFO) stack of objects.
ld
● extends class Vector with five operations that allow a vector to be treated
as a stack.
● The usual push and pop operations are provided,
● as well as a method to peek at the top item on the stack,
or
● a method to test for whether the stack is empty,
● a method to search the stack for an item and
discover how far it is from the top.

● When a stack is first created, it contains no items.
W
Ex.11
Stack fruits = new Stack();
fruits.push(“apple”);
TU
fruits.push(“orange”); Run this code
fruits.push(“potato”); and change it to use
fruits.pop(); generics
fruits.search(“potato”);
fruits.isEmpty();
JN
for(Enumeration e= fruits.elements(); e.hasMoreElements(); )

{

}
Stack Exercise (ex.12)
ld
Use java.util.Stack class for the following exercise.
Write a class that converts a String given in prefix notation form into infix notation
form.
or
Prefix Notation Infix Notation
- / +*abcde ((((a*b)+c)/ d)- e)
W
/ - ab*c+de ((a- b)/ (c*(d+e)))
/ a+b*c- de (a/ (b+(c*(d- e))))

TU
JN

java.util.Hashtable
● This class implements a hashtable, which maps keys to values.
ld
● Any non-null object can be used as a key or as a value.
or
Ex.13
Hashtable phoneBook = new Hashtable();
phoneBook.put("A", "+41111111111"); Run this code and
W
phoneBook.put("B", "+41222222222"); change it to use
phoneBook.put("C", "+41333333333"); generics
if(phoneBook.containsKey("D"))
phoneBook.remove("D");
TU
for(java.util.Enumeration e= phoneBook.keys(); e.hasMoreElements(); )
{
Object key = e.nextElement();
System.out.println(key + ": " + phoneBook.get(key) );
JN


Hashtable Exercises
ld
Ex.14
● Write a Dictionary class by which you can
● Add words and their definitions
or
● Retrieve a specified word
● Print all words in the dictionary
W
Ex.15
● Using java.util.Hashtable class, write a HashtableAdapter class that
implements the OrderedHashtable interface that has methods

TU
● void put(Object key, Object value)
● Object get(Object key)

JN
● Enumeration keysInPutOrder()


Algorithms for Collection classes
ld
● java.util.Collections class provides static methods that operate on collections.
● For example,
or
● static void sort(List list)
● Sorts the specified list into ascending order, according to the natural
ordering of its elements.

● static void sort(List list, Comparator c)
W
● Sorts the specified list according to the order induced by the specified
comparator.
● Strategy pattern
TU
● Similar to sorting, you can use other algorithms (like shuffle, search) of
Collections class.
JN


Sort exercise (ex.16)

class SortTest {
private Vector list = new Vector();
ld
public SortTest() {
list.addElement(new String("grape"));
or
list.addElement(new String("apple"));
list.addElement(new String("orange"));
list.addElement(new String("cherry"));
}
W
public void sort() {
Collections.sort(list);
} Run this code!
TU
public void print() {
System.out.println(list);
}
public static void main(String [] args) {

SortTest s = new SortTest();
JN
s.sort();
s.print();

}
}
Sort exercise (ex.17)

● Create a Person class with name, age, height fields.
ld
● Using Strategy pattern write AgeComparator, HeightComparator classes
deriving from Comparator interface.
or
● Make a test to sort people according to their age and their height.
W
TU
JN

Input/Output Operations
● Fundamental concept is a stream.
ld
● Stream: flow of data from a source to a destination.
or
Source Destination
W
● Java provides two fundamental classes that abstracts this phenomenon.
● java.io.InputStream
● java.io.OutputStream
These two classes are byte-oriented.
TU
●
● Similarly there are
● java.io.Reader
● java.io.Writer
JN
● These are character-oriented.

java.io.InputStream
● Is an abstract class
ld
● Has abstract int read()
● When read is implemented, be careful if it is blocking.
● Provides int available() to see how many bytes are ready to be read.
or
Source Program
java.io.OutputStream
W
TU
● Is an abstract class
● Has abstract write(int)
JN
Destination Program

File I/O
ld
● java.io.FileInputStream
● java.io.FileOutputStream
● Ex. 18
or
Understand the code in Copy.java, compile and run the application.
● As you have noticed, for every byte of the file, there is a function call to read
W
which accesses the disk every time it is called.
● Similarly for write.
● How to avoid this?

● java.io.BufferedInputStream
TU
● java.io.BufferedOutputStream
JN


java.io.BufferedInputStream
ld
● Constructed from an InputStream object.
BufferedInputStream
● Holds inside a buffer as an array.
read()
or
● Acts as a decorator (remember previous lecture)
InputStream
● Supports marking and reseting
java.io.BufferedOutputStream
W
TU
● Constructed from an OutputStream object.
BufferedOutputStream
● Holds inside a buffer as an array.
write()
JN
● Acts as an decorator (remember previous lecture)

OutputStream
● write() is called when buffer is full.

Buffered File I/O
ld
● Ex. 19
● Understand the code in BufferedCopy.java
(Note constructions of the Buffered IO stream objects!)

● Compile and run the application.
or
● Test results for a file ~4.5Mb
[onur@karga src]$ time java Copy test.mp3 test2.mp3
W
real 0m51.405s
user 0m11.245s
sys 0m35.818s
[onur@karga src]$ time java BufferedCopy test.mp3 test3.mp3

TU
real 0m0.837s
user 0m0.620s
sys 0m0.052s
JN


java.io.DataInputStream
● Constructed from an InputStream object.
ld
● Allows reading primitive Java data types from the underlying InputStream
object.
● Works in a machine-independent way.
● Acts as a decorator
or
DataInputStream
read()
W
InputStream
java.io.DataOutputStream
TU
● Constructed from an OutputStream object.
● Allows writing primitive Java data types to the underlying OutputStream
object.
● Machine-independent, DataInputStream can be used to read what has been
written
Acts as a decorator DataOutputStream
JN
write()

OutputStream
Data IO (ex.20)
● Using DataInputStream, DataOutputStream, FileInputStream, FileOutputStream
ld
classes,
● Write an application in which you write an integer, a double and a String

in a file.
or
● Write an application in which you retrieve what you have written from the file.
W
TU
JN


A Short Introduction to
Multi-threaded Programming in Java
ld
● Thread: is a thread of execution in a program.
● There are two ways two make a class run as a Thread.
or
1) Extending from Thread class and overriding the run() method.
public class MyClass extends Thread {
W
...
public void run()
{
...
}
TU
}
Somewhereelse in your code
MyClass m = new MyClass();

JN
m.start();

A Short Introduction to
Multi-threaded Programming in Java
ld
2) Implementing Runnable interface and providing the Runnable
object as an argument to the constructor of Thread.
or
public class MyClass implements Runnable {
...
public void run()
{
W
...
}
}
TU
Somewherelse in your code
MyClass m = new MyClass();

Thread t = new Thread(m);
t.start();
JN


Piped I/O Streams
ld
● java.io.PipedInputStream
● java.io.PipedOutputStream
● A way for inter-thread communication
or
Pipe
Thread Thread
W
TU
● Ex.21
● Understand the code in PipeTest.java,
● compile and run the application.

JN


GUI Design in Java
ld
● Extensive use of design patterns
● Strategy
● Container's layout manager (FlowLayout, BorderLayout, GridbagLayout)
or
● TextComponent's validator (Numeric, AlphaNumeric, TelNumber)
● Composite
● See java.awt.Container extends java.awt.Component. Attention to paint()
W
method.
● Observer
● See java.util.EventListener and all of its subclasses
TU
● Abstract Factory
● See java.awt.Toolkit and all of its create methods
● Singleton
● e.g. Toolkit instance is never created by the programmers, see
JN
java.awt.Component's getToolkit() method


GUI Design in Java (ex.22)
ld
● Let's see things in action and create a simple calculator
or
W
TU
JN


Using external libraries (ex.23)

“XML processing with dom4j”
import java.io.FileWriter;
ld
import org.dom4j.*;
import org.dom4j.io.*;
import java.util.List;
or
public class XMLTest {
Element modelRoot;
public XMLTest() {}
W
public static void main(String[] args){
Document document = DocumentHelper.createDocument();
Element projectRoot = document.addElement( "Automata");
Element automataRoot = projectRoot.addElement("Automaton")
.addAttribute("name", "preg1");
TU
Element eventsElement = automataRoot.addElement("Events");
String[] events = {"e0", "e1", "e2"};

Element modelElement = null;
JN
for(int i = 0; i<events.length; i++){

modelElement = eventsElement.addElement("Event");
modelElement.addAttribute("id", events[i] );
}
}
Using external libraries

// lets write to a file
ld
try
{
XMLWriter writer = new XMLWriter( new FileWriter("test1.xml") );
writer.write( document );
or
writer.close();
}
catch(Exception e)
{
W
System.out.println("exception");
}
TU
JN


Using external libraries

Element newElement = (Element)modelElement.clone();
ld
newElement.addAttribute("id", "e3");
List eventsList = eventsElement.content();
eventsList.add(3, newElement);
or
// lets write to a file
try
{
W
XMLWriter writer = new XMLWriter( new FileWriter("test2.xml") );
writer.write( document );
writer.close();
}
catch(Exception e)
TU
{
System.out.println("exception");
}
}
JN
Compiling: javac -classpath ./dom4j-1.6.1.jar XMLTest.java

Running: java -classpath ./dom4j-1.6.1.jar:. XMLTest

You can obtain dom4j.jar from www.dom4j.org
Writing an intelligent Pishti player (ex. 24)
ld
● To see the assignment, visit:
http://www.alari.ch/people/derino/Teaching/Java/Pishti/index.php
or
W
TU
JN

ALaRI CfP tracker monthly timeline (ex.25)
ld
● ALaRI CfP tracker lists open and closed call for papers at the following address:
http://www.alari.ch/NewsAndEvents/cfp
● Using the ALaRI call for papers XML files
or
● wget http://www.alari.ch/NewsAndEvents/cfp/es/cfp.xml
● wget http://www.alari.ch/NewsAndEvents/cfp/es/cfp-past.xml
W
write a program that lists the CfPs grouped by month in a single year
timeline according to their submission due dates.
e.g.
January
ABC'08
TU
XYZ'10
ABC'09
ABC'10
DEF'09
ABC'11
JN
February
...

ALaRI CfP tracker in webcal format (ex.26)
ld
● ALaRI CfP tracker lists open and closed call for papers at the following address:
http://www.alari.ch/NewsAndEvents/cfp
● Using the ALaRI open call for papers XML file
or
● wget http://www.alari.ch/NewsAndEvents/cfp/es/cfp.xml
write a program that creates a file in the webcal format listing the upcoming
W
CfPs according to their submission due dates.
TU
JN

Propose your own assignment (ex. 27)
ld
● Tell me about your own idea, once approved, do it as your final assignment!
or
W
TU
JN

References
ld
● Thinking in Java by Bruce Eckel (available online)
● Sun’s Java Homepage: http://java.sun.com
● Bob Tarr’s Design Patterns Homepage:
http://research.umbc.edu/~tarr/dp/dp.html
or
● Jeff Friesen’s Book: Java 2 By Example, Second Edition
W
TU
JN

JAVA Programming

Uploaded by

Copyright:

Available Formats

JAVA Programming

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

JAVA Programming

Uploaded by

Copyright:

Available Formats

www.alljntuworld.

Downloaded From JNTU World (http://www.alljntuworld.in)

● Adapter Design Pattern

● Multi-threaded Programming in Java