Since its creation, the Java language has been augmented with a powerful library of interfaces and classes organized into various packages. With these packages one can connect to the operating system, legacy databases, GUIs, intranets and the Internet. This course would normally taken after a Java language programming course, such as Hands-On Object-Oriented Design & Programming with Java. Participants might consider going on to the follow up course Enterprise Java, which focuses on the wider issues of client-server, components, transactions, persistence and security.
This is not a first language course, indeed it's not really a language course, although certain key architectural relationships are reviewed. Participants should be practising software engineers who already know the essentials of Java programming and object-orientation. Participants will be wanting to familiarise themselves with the contents of the Java library packages, and to be introduced to way that the various classes and interfaces work and are intended to be used. It will help if participants have a little experience in other areas of software engineering in general, such as relational databases and SQL, and networking.
This is the original 3-day course that stood us in good stead until the arrival of Java 5 (JDK 1.5). There is now a modular, four-day alternative to this course.
The course lasts three days.
It is based on a cycle of theory-language-practice-review, with approximately two cycles per day. One non-trivial, practical case-study is developed during the course. Each day will start at 09.30 and finish at 17.00, with an hour for lunch. Time is available at the end of the day for extended discussions or related issues.
We look at package mechanism and way that it organizes not just the Java Development Kit (JDK), but third party libraries as well. We look at the contents of the JDK.
We review the extension (inheritance) mechanism, its purpose and the care required in its use. We also review interfaces and their implementation and why this is such a powerful feature and yet so simple.
Participants will probably already be familiar with collections classes like Vector. Here though we go into more detail on how the framework has been put together, how the various kinds of collection work and the trade-offs amongst them. Iterators are covered.
Since version 1.1 of the JDK, the Abstract Windowing Toolkit (AWT) has provided a useful, event-driven GUI technology using native GUI mechanisms. We examine the event model in some detail. We survey the various component objects in the AWT and experience the way in which they work.
Participants will probably already be familiar with the basics of multi-threading. Here we look at threads in more detail and cover inter-thread communication, synchronization and locking, and avoidance of deadlock.
For many years, in many technologies, the idea of a stream to generalise input-output or producer-consumer problems has proved its worth. When a stream is a Java object they become even more powerful. Understanding streams is crucial to correct Java deployment and we look at the various steam objects and mechanisms in some detail. We also look, since it's in the same package at tokenization.
Following on our work with streams, we see how to use streams to serialise objects. Serialised objects can be transmitted and can be stored; so serialization is an important constituent of distributed systems and lightweight object persistence schemes.
Participants will already be familiar with try/catch. Here we ensure that throwing is understood, and we review the structure and contents of the exception class hierarchy.
Although object persistence and "object bases" may turn out to be the way of the future, we will want to connect to relational database for many years to come. We do this through SQL and JDBC. Provided the platform has a familiar RDBMS and JDBC/ODBC, we will also do some practise.
Java cannot connect to chips and IO registers. Java doesn't pretend to be the fastest of all languages either. There will occasionally be a need to implement some Java methods in a language other than Java. Here, provided the platform has a C/C++ compiler we will practise implementing Java methods in C through the Java Native Interface (JNI).
Tool builders need to discover, programatically, the details of classes and methods at run time. The reflection package support this. We survey the support provided.
Given Java's origins, one would expect strong support for networking. Java's support for networking is excellent, and network programming is pleasantly easy. We look at the interfaces and classes that support this, and provided the platforms have some networking capability, we practise as well.
We recommend that there are no more than 10 participants, with the best results usually obtained when there are at least 8 participants. It is possible, by negotiation and mutual agreement, for more than 10 participants to be present.
This is quite a challenging course for practical work as we are concerned with Java's connection to everything else! We will experiment with as much as we can. We will create GUIs, read and write files, use threads, connect to databases, connect across networks, connect to the Internet, connect to Web servers, serialise objects, ...
Please contact John Deacon by telephone on +44 20 7498 3773; by fax on +44 20 7498 3747; by emailing jdeacon@jdl.co.uk; or by visiting http://www.jdl.co.uk
[ Home page | Courses List ]