Basic Java

Title

Java Programming

Description

This comprehensive course covers programming and development in the Java language and environment. It is intended for programmers with experience in languages other than Java, who may or may not have any previous Java experience. The course includes a detailed study of the object oriented aspects of Java, with a case study that is carried from analysis and design (presented in UML) to implementation in Java. The course incorporates treatment of the major Java tools including javac, java, jar and javadoc. There are numerous example programs and lab exercises, all of which are fully documented using javadoc. The course is entirely platform independent and targets the Java 2ä platform. (Almost all the material applies well to Java 1.1, and differences between the platform versions are highlighted.) The course consists of five modules, which are also available independently.

The first module introduces the Java software architecture, including the Java Virtual Machine, Java Runtime Environment, Core API, and the Java Developer’s Kit. Students learn to configure a Java development and runtime environment and to use the JDK command-line tools, and learn the basic software development process for Java.

The second module covers the fundamentals of the Java language, focusing on its grammar, data types, and procedural aspects such as flow control (including exception handling) and threads. By the end of the module students are building simple, practical Java classes and applications.

The third module covers Java as an object-oriented language. The module includes an optional primer on object-oriented methodology and concepts, and then looks at Java as an object-oriented implementation language, including classes, construction, visibility, inheritance, polymorphism, interfaces, abstract classes, and type identification. Lab work moves from analysis and design of a case study to implementation as a Java package of several classes including an application class that implements a command-line interface.

The fourth module introduces GUI programming in Java, starting with the Abstract Windowing Toolkit and moving through chapters on layout management, event handling, and Java Applets. The case study introduced in the previous module is expanded considerably, as a GUI interface is connected to the model, custom events and handlers are added to the model, and the resulting application-driven GUI is rewrapped and delivered via JAR file as an applet.

The fifth module introduces the Java Streams model. First the delegation-based stream model itself is covered, and successive chapters look at use of this model in raw file I/O operations and finally at Java Serialization. The case study is again expanded, finally to include dump and load of the entire application dataset through serialization.

Learning Objectives

	Chiefly, learn to program effectively in the Java language.
	Understand the Java software architecture, and the design decisions which make Java software portable, efficient, secure and robust.
	Learn how to configure a simple Java development environment.
	Know the grammar, data types and flow control constructs of the Java language.
	Understand Java as a purely object-oriented language.
	Learn how to program GUIs using Java, including using event handling to connect the GUI to an underlying data model.
	Understand the structure of streams in Java, and learn how to use streams to manage file I/O.
	Learn how to use Java Serialization to internalize and externalize potentially complex graphs of objects.

Course Duration

5 days

Prerequisites

Experience with some programming language other than Java, on any current operating system for which a JVM is available (including all Windows flavors and most Unix flavors). No Java programming experience or reading is required. C and C++ programmers will probably find that their natural pace through the course is a little faster.

Topics

The Java Software Architecture

The Java Virtual Machine Java Developer’s Kit Robustness – Language Features

	Overview of Architecture
	Java Virtual Machine
	Java Runtime Environment
	The Core API
	Portability and Efficiency
	Security

Building Java Software

	Packages
	Tools
	JARs
	Security Model

The Java Language

Fundamentals

	Source file format
	Intro to classes
	Fields and methods
	Code grammar and expressions
	Identifiers
	Operators
	System class

Data Types

	Primitive types
	Type conversion
	Object references
	Comparing and assigning references
	Garbage collection
	Strings
	Arrays

Flow Control

	Call and return
	Conditional constructs
	Looping constructs
	Exceptions

Threads

	Java Thread Model
	Creating and running threads
	Manipulating thread state
	Creating thread classes
	Thread synchronization

Object-Oriented Programming in Java

Object-Oriented Analysis and Design

	Complex systems
	Abstraction
	Classes
	Responsibilities and collaborators
	Relationships
	Visibility
	Simple UML
	Polymorphism

Encapsulation in Java

	Java Classes
	Member visibility
	Static members
	Constructors and finalizers
	Overloading methods
	Collection classes

Inheritance and Polymorphism in Java

	Extending Classes
	Superclass reference
	Overriding methods and polymorphism
	Defining and implementing interfaces
	Abstract classes
	Type identification

Inner Classes

	Motivation
	Named inner classes
	Outer object reference
	Anonymous inner classes

Java Graphical User Interfaces

The Abstract Windowing Toolkit

	Components
	Containers
	Frames
	Controls
	Menus
	Dialogs

Layout Management

	Layout Manager interface
	Implicit use of layout manager
	Standard layout managers
	Custom layout manager

Events

	Java Event Model
	Event Types
	Listeners
	Sources
	Connections
	Custom Event Types

Applets

	Applet class
	Applet context
	Applet security
	Distribution using JARS

Java Streams

The Java Streams Model

	InputStream and OutputStream
	Delegation-based stream model
	Media-based streams
	Filtering stream

Working with File Systems

	File class
	Modeling files and directories
	Chaining streams to files
	Input and output

Java Serialization