Course OverviewCORE Java for JDK 1.1 is an intensive five-day course and is a Java primer for developers and programmers who have never touched the Java programming language. Fundamental elements of Object Oriented programming will also be covered to allow the student to understand the various policies and constructs of Java. This will be achieved through a combination of PowerPoint slide presentations by topic with interspersed Java exercises contained within pre-defined Visual Cafe Pro 2.0 build projects. CORE Java for JDK 1.1 is approximately 50% lecture and 50% hands-on labs and exercises. This approach will maximize each attendee’s ability to get up and running with the ability to write and design Java applications.
Course ObjectivesCORE Java for JDK 1.1 will provide participants with the ability to:
Who Should Attend?
CORE Java for JDK 1.1 is designed for software engineers, developers and programmers that are interested in writing distributed applications in the Java language, but have little to no programming experience with Java previously.
What to Expect
Expect an interactive course structured into several modules and delivered to suit each participant’s requirement. All modules enable the participant to learn from hands-on experience and from other participants while working alone or in small teams. Participants will also receive a full copy of supporting notes, designed to complement the instruction and labs. This course is approximately 50% hands-on programming/lab work and 50% lecture.
The following modules are explored during the five days of the CORE Java for JDK 1.1 course:
This is an OO primer to equip students with a basic understanding of the OO tenets Inheritance, Encapsulation and Polymorphism.
This topic will cover the native scalar types of Java like "int" and their data representation and how they can be wrapped as objects through their equivalent wrapper classes. For example, the integer types int, short, long, byte can be wrapped as class type Integer. It will be demonstrated through code how these scalar types can be declared and used as object state variables.
This section deals with the very important topic of how to define a basic blueprint (or cookie cutter) in Java code that represents some well understood and encapsulated piece of logic from which object instances can be created.
These things get work done in an application, where a Java application consists of a set of one or more objects. Much emphasis will be placed on this topic area, so students fully understand the differences between "class of object" and "instance of object". The ancillary topic of garbage collection will also be included within this section.
This topic will be devoted to those constructs that control the flow of individual instruction execution, for example "if (some test) do something else alternative"
This topic is straightforward and deals with those primitives that allow mathematical and logical control of statement composition. For example x = a + b; where "+’ is the operator and "if ( x || b ) do something" where "||" is the logical OR operator.
This topic deals with the powerhouse of objects; it is where the object execution content gets declared. Methods can be thought of as functions or procedures that belong to an object. Students will learn how to declare methods and what makes a good method the various types of methods and the signatures that control those methods.
This is a most important topic and deals with the language constructs that control visibility and accessibility of classes, objects and methods. These constructs underpin two of the cornerstones of OO, namely encapsulation and inheritance. Much effort will be spent in dissecting this topic, as it is poorly understood within the industry and much abused.
This topic deals explicitly with all aspects of encapsulation and how private state and functionality can be controlled and declared within class definitions, where encapsulation is the property that controls visibility of state and functionality. Students will learn how to declare, initialize and access object state in a well-behaved manner.
Again this is a major topic area and covers the ability of Java to provide mappings to real world entities through abstract definitions that can be increasingly specialized into concrete representations. For example, it is possible to define a RoadVehicle class from which a Car class derives functionality. Students will perform exercises on predictable hierarchy trees so that they understand the inheritance constructs, implications and usefulness of this technique.
This is one of the more difficult topics for students to grasp; however, it is a fundamental component of the language and is much used by the Java library within the Java Development Kit. Interfaces provide us with the highest level of abstraction when declaring form. Interfaces provide us with a natural bridge to distributed environments like CORBA and Java Remote Method Invocation, which are covered in more advanced classes. Students will learn how to construct and use Interfaces and how and when to use Interfaces as opposed to classes.
Exceptions are the cornerstone of well-behaved and predictable code, as the language provides us with built in mechanisms that make programming of exceptional circumstances easy. Exceptions are this mechanism and students will learn all the various ways of declaring exceptions and propagating them back down the call chain where there will be mandatory logic for trapping the exception and dealing with it. Exceptions make for good code.
This will be a lightweight introduction to the distributed technologies of Remote Method Invocation and Common Object Request Broker Architecture. This topic can be used as an indicator session for those companies wanting to understand what distribution offers and the types of technologies on offer.
This topic deals with the newly defined Graphical User Interface component set. The topic will allow students to create UI applications and applets through which they can graphically interact with their programs. This topic demonstrates one of the prime portability advantages of Java that is the WORM or Write Once Run Many architecture.
This is an increasingly important topic and underpins both the Java swing set interaction model and more importantly the Java Bean Component model. Students will learn how to declare their own events and how to associate their Java components within an event system.
Java is big business on the Internet and is particularly appropriate for this environment. Students will learn how and why Java is tailored for this approach and how Java will enable business Intranets to flourish where dynamic User Interface logic can be developed and deployed through Applet technology.
This is the only distributed environment covered in depth within CORE Java for JDK 1.1, but it is so fundamental and builds upon Applet technology, that it has been included in the primer course. Students will have their own WEB servers running on the laptop and will learn how to configure the WEB server for applet deployment. This topic allows the exercises to become much more real world solutions and will combine all previous topics into a distributed exercise where graphical applets will be dynamically downloaded into a web page of their own devising.
This topic is outside the bounds of Java but the students will use a state of the art Interactive Development Environment to build and debug their exercise solutions. Currently the chosen IDE I Visual Café Pro Version 2.0
For Further Information: