To main page

Introduction to JAVA Programming

Y. Daniel Liang, 7th ed.

Comprehensive edition This book exists in two formats, one short and one longer. You want the longer one.

ISBN-13: 978-0-13-605966-0

ISBN-10: 0-13-605966-0

Fredrik Kilander, DSV SU/KTH, 2009

General advice

The list of chapters are rated below in various degrees of interest to the course. For best results, read a chapter, and try to answer some of the review questions. Write down the numbers on the ones that caused you problems, and analyze what was difficult, and why.

After a few days, go back to the chapter and the tricky questions and look at them again. Are they still mysterious? Sample a few more questions from the same chapter and reivew the result.

For excercises and assignments, it is important that you have access to the Java 6 documentation. It can be found online, or if you have a your own, personal computer, downloaded (see Java 6 API). Also, when the text mentions a package or API of which you are not previously familiar, make the effort of locating it in the documentation set. Finding your way around the Java APIs is just as important as knowing the language itself. In a sense, the API is the language.

You should also verify that you can write, compile and run Java programs. Acquaint yourself with the follow tools:

I recommend that you avoid integrated development environments, at least initially, because you may find it difficult to separate the Java language from the actions of the IDE. IDE's are great when you know what they can do for you and what you can expect of them, but when learning a language like Java they mostly get in the way.

Technical remarks

In his example's, Liang prefers the use of StringBuilder over StringBuffer, because StringBuilder is faster. However, that extra speed comes with a price, and that is the absence of protection in a multi-threaded environment. StringBuilder is not thread-safe, but StringBuffer is.

Many Java programs are multi-threaded (many times implicitly, for example when using a GUI). This does not in itself pose a threat to the program, in the majority of cases the string operations are performed by a single thread anyway. But the programmer must be aware of the difference and not choose one or the other from sheer force of habit, or a dim view that one is always better than the other.

StringBuffer and StringBuilder are used in Java to perform string operations: mostly concatenation, replacement and deletions. While ordinary string expressions can do this too, the resulting string objects are immutable once created, and are often used only once. They consume memory until reclaimed by the garbage collector. A program that performs a lot of string manipulation (reading or creating several megabytes of text in its lifetime) is therefore more memory efficient when it uses mutable objects and reuses memory.

Threads are paths of execution in a program. All computer programs, Java programs included, have at least one thread of execution. Multi-threaded programs have two or more threads of execution running in the same program and memory (mostly in different parts of the code). Without careful planning and synchronization, threads may interfere with each other in unexpected ways. The most common problem is simultaneous write access to data structures that are designed to be updated by a single thread at a time. Thread-safe classes in Java are protected against such conflicts.

Book website

Also, do not forget to check out the book's website. Chapters 38-43 are found there, they are not in the printed book. In order to login on the site, you will need a code that is found on the very first page of the book.

Contents and reading tracks

Due to the massive amount of information in the book it has been divided into three tracks. These tracks are

All students are expected to read the general chapters and then focus on either the multimedia or Internet programming track. Participants in the ISE programme that expect to follow the course Programming of Interactive Systems are recommended to select the Internet programming track.

Three different levels of attention are used to indicate the importance of each chapter. The classification should be seen as a guide, and students are expected to at least be oriented on the contents of the chapters marked as as needed. That label does not mean that the chapter can be skipped without looking; it means that you should evaluate how relevant it is for you, and plan your time and effort based on that.

[Attention] [General] [Multimedia] [Internet programming]
High
Standard
As needed
Week 1
Chapter 1 - Introduction to Computers, Programs, and Java
Chapter 2 - Elementary Programming
Chapter 3 - Selections
Chapter 4 - Loops
Chapter 5 - Methods
Chapter 6 - Arrays
Chapter 7 - Objects and Classes
Week 2
Chapter 8 - Strings and Text I/O
Chapter 9 - Thinking in Objects
Chapter 10 - Inheritance and Polymorphism
Chapter 11 - Abstract Classes and Interfaces
Chapter 12 - Object-Oriented Design and Patterns
Chapter 13 - GUI Basics
Chapter 14 - Graphics
Week 3
Chapter 15 - Event-Driven Programming
Chapter 16 - Creating User Interfaces
Chapter 17 - Applets and Multimedia
Chapter 18 - Exception Handling
Chapter 19 - Binary I/O
Chapter 20 - Recursion
Chapter 21 - Generics
Week 4
Chapter 22 - Java Collections Framework
Chapter 23 - Algorithm Efficiency
Chapter 24 - Lists, Stacks, and Queues
Chapter 25 - Trees, Iterators, Heaps, and Priority Queues
Chapter 26 - Sorting
Chapter 27 - Graph Applications
Chapter 28 - Weighted Graphs Applications
Week 5
Chapter 29 - Multithreading
Chapter 30 - Networking
Chapter 31 - Internationalization
Chapter 32 - JavaBeans and Bean Events
Chapter 33 - Containers, Layout Managers, and Borders
Chapter 34 - Menus, Toolbars and Dialogs
Chapter 35 - MVC and Swing Models
Week 6
Chapter 36 - JTable and JTree
Chapter 37 - Java Database Programming
Chapter 38 - Advanced Java Database Programming website
Chapter 39 - Servlets website
Chapter 40 - JavaServer Pages website
Chapter 41 - JSF and Visual Web Development website
Chapter 42 - Web Services website
Chapter 43 - Remote Method Invocation website

Chapter 1 - Introduction to Computers, Programs, and Java

To review computer basics, programs, and operating systems
To represent numbers in binary, decimal, and hexadecimal
To explore the relationship between Java and the World Wide Web
To distinguish the terms API, IDE, and JDK
To write a simple Java program
To display output on the console
To create, compile, and run Java programs
To explain the basic syntax of a Java program
(GUI) To display output using the JOptionPane output dialog boxes

Chapter 2 - Elementary Programming

To write Java programs to perform simple calculations
To use identifiers to name variables, constants, methods, and classes
To use variables to store data
To program with assignment statements and assignment expressions
To use constants to store permanent data (FK: actually, data that should not change during the execution of the program. Constants are only permanent in that sense.)
To declare primitive data types: byte, short, int, long, float, double, and char
To use Java operators to write numeric expressions
To represent characters using the char type
To represent sa string using the String type
To obtain input from the console using the Scanner class
To become familiar with Java documentation, programming style, and naming conventions
To distinguish syntax errors, runtime errors, and logic errors
To debug logic errors
(GUI) To obtain input using the JOptionPane input dialog boxes

Chapter 3 - Selections

To declare boolean type and use Boolean
To apply relational operators and logic operators to write Boolean expressions
To use Boolean expressions to control selection statements
To implement selection control using if and nested if statements
To implement selection control using switch statements
To write expressions using the conditional operator
To display formatted output using the System.out.printf method and to format strings using the String.format method
To examine the rules governing operator precedence and associativity
(GUI) To get user confirmation using confirmation dialogs

Chapter 4 - Loops

To use while, do-while, and for loop statements to control the repetition of statements
To understand the flow of control in loop statements
To use Boolean expressions to control loop statements
To discover the similarities between three types of loops
To write nested loops
To learn the techniques for minimizing numerical errors
To learn loops from a variety of examples
To implement program control with break and continue
(GUI) To control a loop with a confirmation dialog

Chapter 5 - Methods

To define methods, invoke methods, and pass arguments to a method
To develop reusable code that is modular, easy to read, easy to debug, and easy to maintain
To use method overloading and understand ambiguous overloading
To determine the scope of variables
To solve mathematics problems using the methods in the Math class
To apply the concept of method abstraction in software development
To design and implement methods using stepwise refinement

Chapter 6 - Arrays

To describe why arrays are necessary in programming
To learn the steps involved in using arrays: declaring array reference variables and creating arrays
To initialize the values in an array
To access array elements using indexed variables
To simplify programming using the for-each loops
To declare, create and initialize an array using an array initializer
To copy contents from one array to another
To develop and invoke methods with array arguments and return value
To declare a method with variable-length argument list
To search elements using the linear or binary search algorithm
To sort an array using the selection sort
To sort an array using the insertion sort algorithm
To use the methods in the Arrays class
To declare and create two-dimensional arrays to solve interesting problems such as Sodoku
To declare and create multi-dimensional arrays

Chapter 7 - Objects and Classes

To describe objects and classes, and use classes to model objects
To use UML graphical notation to describe classes and objects
To construct objects using constructors
To access objects via reference variables
To define a reference variable using a reference type
To access an object's data and methods
To declare a class and create an object from a class
To assign default values for an object's data fields
To distinguish between object reference variables and primitive data type variables
To use classes Date, Random, and JFrame in the Java library
To distinguish between instances and static variables and methods
To declare private data fields with appropriate get and set methods
To encapsulate data fields to make classes easy to maintain
To differentiate between primitive-type arguments and object-type arguments
To develop methods with object arguments
To store and process objects in arrays

Chapter 8 - Strings and Text I/O

To use the String class to process fixed strings (FK: immutable strings)
To use the Character class to process a single character
To use the StringBuilder/StringBuffer classes to process flexible strings (FK: mutable strings)
To distinguish among the String, StringBuilder and StringBuffer classes
To learn how to pass arguments to the main method from the command line
To discover file properties and to delete and rename files using the File class
To write data to a file using the PrintWriter class
To read data from a file using the Scanner class
(GUI) To open files using a dialog box

Chapter 9 - Thinking in Objects

To create immutable objects from immutable classes to protect the contents of objects
To determine the scope of variables in the context of a class
To use the keyword this to refer to the calling object itself
To apply class abstraction to develop software
To explore differences between the procedural paradigm and object-oriented paradigm
To design programs using the object-oriented paradigm

Chapter 10 - Inheritance and Polymorphism

To develop a subclass from a superclass through inheritance
To illustrate inheritancy by creating a custom frame that extends JFrame
To invoke the superclass's constructors and methods using the super keyword
To override instance methods in the subclass
To distinguish between overriding and overloading
To explore the methods toString() and equals(Object) in the Object class
To discover polymorphism, dynamic binding, and generic programming
To describe casting and explain why explicit downcasting is necessary
To store, retrieve, and manipulate objects in an ArrayList
To implement a Stack class using ArrayList
To restrict access to data and methods to subclasses using the protected visibility modifier
To prevent class extending and method overriding using the final modifier

Chapter 11 - Abstract Classes and Interfaces

To design and use abstract classes
To process a calendar using the Calendar and GregorianCalendar classes
To specify a common behaviour for objects using interfaces
To define interfaces and declare classes that implement interfaces
To define a natural order using the Comparable interface
To enable objects to listen for action events using the ActionListener interface
To make objects cloneable using the Cloneable interface
To explore the similarities and differences between an abstract class and an interface
To create objects for primitive values using the wrapper classes (Byte, Short, Integer, Long, Float, Double, Character, and Boolean)
To create a generic sort method
To simplify programming using automatic conversion between primitive types and wrapper classes
To use the BigInteger and BigDecimal classes for computing very large numbers with arbitrary precision

Chapter 12 - Object-Oriented Design and Patterns

To describe the software life cycle
To discover classes and determine responsibilities of each class
To describe relationship types: association, aggregation, composition, dependency, strong inheritance, and weak inheritance
To declare classes to represent the relationships
To design systems by identifying the classes and discovering the relationships among these classes
To implement the Rational class and process rational numbers using this class
To design classes that follow the class-design guidelines
To explain the concept of framework-based programming using the Java API
To apply design patterns for developing sound software systems

Chapter 13 - GUI Basics

To distinguish between Swing and AWT
To describe the Java GUI API hierarchy
To create user interfaces using frames, panels, and simple GUI components
To understand the role of layout managers
To use the FlowLayout, GridLayout, and BorderLayout managers to layout components in a container
To specify colors and fonts using the Color and Font classes
To use JPanel as subcontainers
To apply common features such as borders, tool tips, fonts, and colors on Swing Components
To use borders to visually group user-interface components
To create image icons using the ImageIcon class

Chapter 14 - Graphics

To describe Java coordinate systems in a GUI component
To draw things using the methods in the Graphics class
To explain how and when a Graphics object is created
To override the paintComponent method to draw things on a GUI component
To use a panel as a canvas to draw things
To draw strings, lines, rectangles, ovals, arcs, and polygons
To obtain font properties using FontMetrics and know how to center a message
To display an image in a GUI subcomponent
To develop reusable GUI components FigurePanel, MessagePanel, StillClock, and ImageViewer

Chapter 15 - Event-Driven Programming

To describe events, event sources, and event classes
To declare listener classes, register listener objects with the source object, and write the code to handle events
To declare listener classes using inner classes
To declare listener classes using anonymous inner classes
To write programs to deal with ActionEvent
To write programs to deal with WindowEvent
To simplify coding for listener classes using listener interface adapters
To write programs to deal with MouseEvent
To write programs to deal with KeyEvent
To use the javax.swing.Timer class to control animations

Chapter 16 - Creating User Interfaces

To create graphical user interfaces with various user-interface components: JButton, JCheckBox, JRadioButton, JLabel, JTextArea, JComboBox, JList, JScrollBar, and JSlider
To create listeners for various types of events
To explore JButton
To explore JCheckBox
To explore JRadioButton
To explore JLabel
To explore JTextField
To explore JTextArea
To explore JComboBox
To explore JList
To explore JSlider
To display multiple windows in an application

Chapter 17 - Applets and Multimedia

To explain how the Web browser controls and executes applets
To describe the init, start, stop, and destroy methods in the Applet class
To develop Swing applets using the JApplet class
To embed applets in Web pages
To run applets from the appletviewer and from Web browsers
To write a Java program that can run as both an application and an applet
To pass string values to applets from HTML
To locate resources (images and audio) using the URL class
To play audio in any Java program

Chapter 18 - Exception Handling

To get an overview of exceptions and exception handling
To explore the advantages of using exception handling
To distinguish exception types: Error (fatal) vs. Exception (nonfatal), and checked vs. unchecked
To declare exceptions in a method header
To throw exceptions in a method
To write a try-catch block to handle exceptions
To explain how an exception is propagated
To use the finally clause in a try-catch block
To use exceptions only for unexpected errors
To rethrow exceptions in a catch block
To create chained exceptions
To declare custom exception classes

Chapter 19 - Binary I/O

To discover how I/O is processed in Java
To distinguish between text I/O and binary I/O
To read and write bytes using FileInputStream and FileOutputStream
To filter data using base classes FilterInputStream / FilterOutputStream
To read and write primitive values and strings using DataInputStream / DataOutputStream
To store and restore objects using ObjectOutputStream and ObjectInputStream, and to understand how objects are serialized and what kind of objects can be serialized
To implement the Serializable interface to make objects serializable
To serialize arrays
To read and write files using the RandomAccessFile class

Chapter 20 - Recursion

To describe what a recursive method is and the benefit of using recursion
To develop recursive methods for recursive mathematical functions
To explain how recursive method calls are handled in a call stack
To use an overloaded helper method to derive a recursive method
To solve selection sort using recursion
To solve binary search using recursion
To get the directory size using recursion
To solve the Towers of Hanoi problem using recursion
To draw fractals using recursion
To solve the Eight Queens problem
To discover the relationship and difference between recursion and iteration

Chapter 21 - Generics

To describe the benefits of generics
To use generic classes and interfaces
To declare generic classes and interfaces
To explain why generic types can improve reliability and readability
To declare and use generic methods and bounded generic types
To use raw types for backward compatibility
To explain why wildcard generic types are necessary
To describe generic type erasure and list certain restrictions and limitations on generic types caused by type erasure
To design and implement generic matrix classes

Chapter 22 - Java Collections Framework

To describe the Java collections framework
To use the common methods defined in the Collection interface for operating sets and lists
To use the iterator interface to traverse a collection
To use the for-each loop to simplify traversing a collection
To explore how and when to use HashSet, LinkedHashSet, or TreeSet to store elements
To compare elements using the Comparable interface and the Comparator interface
To explore how and when to use ArrayList or LinkedList to store elements
To use the static utility methods in the Collections class for sorting, searching, shuffling lists, and finding the largest and smallest element in collections
To compare performance of sets and lists
To distinguish between Vector and ArrayList, and to use the Stack class for creating stacks
To explore the relationships among Collection, Queue, LinkedList, and PriorityQueue and to create priority queues using the PriorityQueue class
To tell the difference between Collection and Map, and describe when and how to use HashMap, LinkedHashMap, and TreeMap to store values associated with keys
To obtain singleton sets, lists, and maps and unmodifiable sets, lists and maps, using the static methods in the Collections class

Chapter 23 - Algorithm Efficiency

To estimate algorithm efficiency using the Big O notation
To explain growth rates and why constants and nondominating terms can be ignored in the estimation
To determine the complexity of various types of algorithms
To analyze the binary search algorithm
To analyze the selection sort algorithm
To analyze the insertion sort algorithm
To analyze the Towers of Hanoi algorithm
To describe common growth functions (constant, logarithmic, log-linear, quadratic, cubic, expoential)
To design efficient algorithms for finding Fibonacci numbers
To design efficient algorithms for finding GCD
To design efficient algorithms for finding prime numbers
To design efficient algorithms for finding a closest pair of points

Chapter 24 - Lists, Stacks, and Queues

To design common features of list in an interface and provide skeleton implementation in an abstract class
To design and implement a dynamic list using an array
To design and implement a dynamic list using a linked structure
To explore variations of linked lists
To design and implement a stack using an array list
To design and implement a queue using a linked list
To evaluate expressions using a stack

Chapter 25 - Trees, Iterators, Heaps, and Priority Queues

To design and implement a binary search tree
To represent binary trees using linked data structures
To search an element in binary search tree
To insert an element into a binary search tree
To traverse elements in a binary tree
To delete elements from a binary search tree
To display binary tree graphically
To create iterators for traversing a binary tree
To design and implement a heap
To design and implement a priority queue

Chapter 26 - Sorting

To study and analyze time efficiency of various sorting algorithms
To design, implement, and analyze bubble sort
To design, implement, and analyze merge sort
To design, implement, and analyze quick sort
To design, implement, and analyze heap sort
To design, implement, and analyze bucket sort and radix sort
To design, implement, and analyze external sort for large data in a file

Chapter 27 - Graph Applications

To model real-world problems using graphs and explain the Seven Bridges of Königsberg problem
To describe the graph terminologies: vertices, edges, simple graphs, weighted/unweighted graphs, and direct/undirected graphs
To represent vertices and edges using lists, adjacent matrices, and adjacent lists
To model graphs using the Graph interface, the AbstractGraph class, and the UnweightedGraph class
To represent the traversal of a graph using the AbstractGraph.Tree class
To design and implement depth-first search
To design and implment breadth-first search
To solve the nine-tail problem using breadth-first search
To solve the Knight's Tour problem by reducing it to a Hamiltonian path problem

Chapter 28 - Weighted Graphs Applications

To represent weighted edges using adjacency matrices and priority queues
To model weighted graphs using the WeightedGraph class that extends the AbstractGraph class
To design and implement the algorithm for finding a minumum spanning tree
To define the MST class that extends the Tree class
To design and implement the algorithm for finding single-source shortest paths
To define the ShortestPath class that extends the Tree class
To solve the weighted nine tail problem using the shortest-path algorithm

Chapter 29 - Multithreading

To get an overview of multithreading
To develop task classes by implementing the Runnable interface
To create threads to run tasks using the Thread class
To control threads using the methods in the Thread class
To control animations using threads
To run code in the event dispatch thread
To execute tasks in a thread pool
To use synchronized methods or blocks to synchronize threads to avoid race conditions
To synchronize threads using locks
To faciliate thread communications using conditions on locks
To use blocking queues to synchronize access to an array queue, linked queue, and priority queue
To restrict the number of accesses to a shared resource using semaphores
To use the resource-ordering technique to avoid deadlocks
To describe the life cycle of a thread
To create synchronized collections using the static methods in the Collections class
To run time-consuming tasks in a SwingWorker rather than in the event dispatch thread
To display the completion status of a task using JProgressBar

Chapter 30 - Networking

To explain terms: TCP, IP, domain name, domain name server, stream-based communication, and packet-based communications
To create servers using server sockets and create clients using sockets
To implement Java networking programs using stream sockets
To obtain Internet addresses using the InetAddress class
To develop servers for multiple clients
To develop applets that communicate with the server
To send and receive objects on a network
To create applications or applets to retrieve files from a network
To render HTML files using the JEditorPane class
To develop and interactive TicTacToe game played on the Internet

Chapter 31 - Internationalization

To describe Java's internationalization features
To construct a locale with language, country, and variant
To display date and time based on locale
To display numbers, currencies, and percentages based on locale
To develop applications for international audiences using resource bundles
To specify encoding schemes for text I/O

Chapter 32 - JavaBeans and Bean Events

To describe what a JavaBeans component is
To explain the similarities between beans and regular objects
To develop JavaBeans components that follow the naming patterns
To review the Java event delegation model
To create custom event classes and listener interfaces
To develop source components using event sets from the Java API or custom event sets

Chapter 33 - Containers, Layout Managers, and Borders

To explore the internal structure of the Swing container
To explain how a layout manager works in Java
To use CardLayout and BoxLayout
To use the absolute layout manager to place components in the fixed position
To create custom layout managers
To use JScrollPane to create scroll panes
To use JTabbedPane to create tabbed panes
To use JSplitPane to create split panes
To use various borders for Swing components

Chapter 34 - Menus, Toolbars and Dialogs

To create menus using components JMenuBar, JMenu, JMenuItem, JCheckBoxMenuItem, and JRadioButtonMenuItem
To create popup menus using components JPopupMenu, JMenuItem, JCheckBoxMenuItem, and JRadioButtonMenuItem
To use JToolBar to create toolbars
To use Action objects to generalize the code for processing actions
To create standard dialogs using the JOptionPane
To extend the JDialog class to create custom dialogs
To select colors using JColorChooser
To use JFileChooser to display Open and Save File dialogs

Chapter 35 - MVC and Swing Models

To use the model-view-controller approach to separate data and logic from the presentation of data
To implement the model-view-controller components using the JavaBeans event model
To explain the Swing model-view-controller architecture
To use JSpinner to scroll the next and previous values
To create custom spinner models and editors
To use JList to select single or multiple items in a list
To add and remove items using ListModel and DefaultListModel
To render list cells using a default or custom cell renderer
To create custom combo box models and renderers

Chapter 36 - JTable and JTree

To display tables using JTable
To process rows and columns using TableModel, DefaultTableModel, TableColumnModel, DefaultTableColumnModel, and ListSelectionModel
To enable auto sort and filtering on table model
To add rows and columns, delete rows and columns
To render and edit table cells using the default renderers and editors
To render and edit table cells using the custom renderers and editors
To handle table model events
To display data in a tree hierarchy using JTree
To model the structure of a tree using TreeModel and DefaultTreeModel
To add, remove, and process tree nodes using TreeNode, DefaultMutableTreeNode, and TreePath
To select tree nodes and paths using TreeSelectionModel and DefaultTreeSelectionModel
To edit and render tree nodes using the default and custom renderers and editors

Chapter 37 - Java Database Programming

To understand the concept of database and database management systems
To understand the relational data model: relational data structures, and languages
To use SQL to create and drop tables to retrieve and modify data
To learn how to load a driver, connect to a database, execute statements, and process result sets using JDBC
To use prepared statements to execute precompiled SQL statements
To use callable statements to execute stored SQL procedures and functions
To explore database metadata using the DatabaseMetaData and ResultSetMetaData interfaces

Chapter 38 - Advanced Java Database Programming

To create a universal SQL client for accessing local or remote database
To execute SQL statements in a batch mode
To process updatable and scrollable result sets
To simplify Java database programming using RowSet
To create a custom table model for RowSet
To store and retrieve images in JDBC

Chapter 39 - Servlets

To explain how a servlet works
To create/develop/run servlets
To deploy servlets on application servers such as Tomcat and GlassFish
To describe the servlets API
To create simple servlets
To create and process HTML forms
To develop servlets to access databases
To use hidden fields, cookies, and HttpSession to track sessions
To send images from servlets

Chapter 40 - JavaServer Pages

To create a simple JSP page
To explain how a JSP page is processed
To use JSP constructs to code JSP script
To use predefined variables and directives in JSP
To use JavaBeans components in JSP
To get and set JavaBeans properties in JSP
To associate JavaBeans properties with input parameters
To forward requests from one JSP page to another
To develop an application for browsing database tables using JSP

Chapter 41 - JSF and Visual Web Development

To explain what JSF is
To create a JSF page using NetBeans
To use JSF UI components (e.g., Static Text, Text Field, Button, Drop Down List, List Box, Radio Button Group, Check Box Group, Text Area, Table)
To use JSF containers Grid Panel, Group Panel, and Layout Panel to group components
To bind data with JSF UI components
To maintain persistency using session tracking
To validate input using Message components
To improve efficiency using virtual forms

Chapter 42 - Web Services

To describe what a Web service is
To create a Web service class
To publish and test a Web service
To create a Web service client reference
To explain the role of WSDL
To pass arguments of object type in a Web service
To discover how a client communicates with a Web service
To describe what SOAP requests and SOAP responses are
To track a session in Web services

Chapter 43 - Remote Method Invocation

To explain how RMI works
To describe the process of developing RMI applications
To distinguish between RMI and socket-level programming
To develop three-tier applications using RMI
To use callbacks to develop interactive applications