Java Training Course

The Java Platform

Before exploring the full breadth of Java's capabilities as a programming language, it is important to understand some basic principles of Java programming, and to set up your development environment. We show you:

• the fundamental concepts behind organization in Object Oriented Programming
• how the Java platform is set up and used
• the different types of programs you can write using Java
• how to choose, install and configure the appropriate Java Software Development Kit
• basic syntax and conventions of Java
• how to compile, run and debug a simple Java program

Using Data in a Program

Unlike Perl, PHP, JavaScript, or other scripted languages, Java has strict rules regarding the use of data. The information for a Java program can be of many types - integers, real numbers, characters, booleans, etc. Here, we cover:

• the difference between constant and variable data
• declaring variables with or without initial values
• the primitive data types; what they are and how to use them
• converting between numeric data types
• how to use escape sequences
• how to use ASCII and Unicode characters

Classes, Objects, Methods, and Properties

As the building blocks of any Java Program, a firm grasp of classes, objects, methods,and properties is a crucial foundation to your training. You will examine:

• classes: what the are and how to create them
• organizing your classes to be readable and functional
• how to create and work with objects using constructor methods
• how to create methods and what they must include
• the importance of, and how to set up, implementation hiding
• using single and multiple arguments in methods
• actual vs. formal parameters
• how to define and use instance methods

Advanced Object Concepts

Once you understand the basic components of Objects and how to work with them, we will move on to some more advanced concepts regarding their use and definition. In particular, the training covers:

• the "geography" of a class or method
• the effect blocks have on variable reference: the scope of a variable
• overloading methods and constructors
• implementing arguments in constructors
• using imported, prewritten constants and methods
• importing classes and packages

Getting Input from the User

After establishing a firm foundation in the inner workings of Java, it is time to begin opening up your program to input from the user. In this section of the course, you will explore:

• recording input from the keyboard
• importing and using the JOptionPane class, a Swing component that produces a dialog box

Creating and Manipulating Arrays

Occasionally, you will want to store more than one value at a time to a variable and in these instances you will use an array. In this portion of the class we discuss the nuances of arrays in Java and how to manipulate them:

• declaring an array variable of integers, doubles or even objects
• initializing arrays with and without values
• using subscripts to simplify operation performance
• searching the values in an array for exact matches or ranges
• passing array elements to methods
• sorting primitive or object array elements in ascending or descending order
• declaring multi-dimensional arrays

Applets

Java applets are small Java programs run within the confines of a rectangular area on a web page. A reference to a Java applet is put into the HTML of a web page similar to how you would reference an image or Flash animation. In this introduction to applets we explore:

• writing an HTML document to include an applet
• commonly used Windows components of applets
• enabling or disabling and defining the position of components in your applet
• using a layout manager to control the position of components within a container
• the lifecycle of a Swing applet
• creating an interactive Swing applet

Event-driven Programming

Though Object Oriented, the program examples to this point have been effectively procedural. You have only controlled for when the code does or does not run. Event-driven programming will allow for more variability in the user experience. You will become familiar with:

• the event-driven model for programming
• the steps necessary to handle events
• passing and retrieving event information

Adding Graphics in your Java Programs

Now that the functionality of the programs has been set, you will learn to specify the basic design elements of your applets and programs to give them a more personalized or branded feel. We cover:

• actively controlling the "painting" and "repainting" of your applet window
• adding colors, shapes and images
• setting font for your texts
• controlling the location of strings of text
• setting graphics to be painted or repainted on actions
• drawing 2D and 3D graphics using objects or the Graphics 2D class
• adding sound, images and animations

Inheritance

Creating Java classes is often a time consuming practice. However, one way to streamline the process is to use the concept of inheritance to build upon existing classes you have created. In this section you will see and practice:

• how Java uses inheritance to copy objects and methods between superclasses and subclasses
• extending a superclass
• overriding superclass definitions in a subclass
• the creation of subclass objects and the requisite superclass construction
• adding arguments to superclass constructors
• accessing superclass methods within a subclass
• information hiding and its use in the protection of data
• the types of methods that cannot be overridden

Advanced Inheritance Concepts

Once you have grasped the basics of inheritance, we cover a few of the more advanced aspects which are of particular use to programmers. In particular, we cover:

• classes from which you extend, but do not instantiate
• using the concept of polymorphism
• treating a series of subclass objects as an array
• some of the methods in the Object superclass
• creating interfaces to allow inheritance from multiple superclasses
• grouping classes together into packages for easy shareability

Swing Components

Swing is a Java toolkit that allows you to quickly build graphical, interactive programs with menus, buttons, and windows. In this section you will practice:

• using container objects
• implementing swing event listeners to make your containers interactive
• using scroll panes to provide more display area for the object

Layout Managers and Events

To further enhance the user experience, it is necessary to control whereyour objects appear within a container and how the user's interactions affect them. In this portion of the course, we cover:

• the layout managers provided by Swing and how you use each of them
• including multiple objects in a single location within the layout managers
• setting specific size and location requirements for components within containers
• defining different event objects
• defining event handlers
• native methods in the AWTEvent class
• inheritance of event methods
• special events unique to the mouse

Exception Handling

It is common for your Java applets and programs to contain errors which can range from misspelling an object reference to holes in the logic. It can be difficult for a programmer to know exactly what to do when their program "throws an exception." To help with that we cover:

• classes of errors
• error handling procedures
• using inherited methods to define the message given when an exception is thrown
• throwing and catching multiple exceptions
• defining statements that execute regardless of the success of the try block
• traditional vs. modern methods of error handling
• using the call stack to cycle through methods
• defining unique exceptions

File Input and Output

All programs function by taking data stored in files, manipulating it and returning the result. In Java, your programs can receive input from, or send output to, files. Most often these files are text files. In this section you will learn:

• to obtain information about files
• the data file hierarchy
• how the data file stream and its classes are handled in Java
• reading and writing formatted and unformatted file data
• how to work with sequential and random access data files

Multithreading and Animations

In this section of the course, we discuss the way in which computers execute multiple threads of statements seemingly simultaneously. Then we explore the use of this knowledge to integrate animation into your applet. We cover:

• multithreading CPU processes
• extending the thread class and initializing multiple threads at once
• pausing a thread for a limited time
• defining the order in which threads have access to the CPU's processing capabilities
• implementing classes that can run as threads
• animating images and reducing flickering
• importing animated images and the function of the garbage collector
• adding animation to a Web page using Java

Databases and JDBC

As with any programming language, Java provides a mechanism for accessing databases and using Structured Query Language (SQL). In this final section you will examine:

• architecting your system: both the two- and multi-tiered models
• registering a JDBC Driver
• JDBC Driver URLs and Types
• database transactions
• datasources
• connection pools
• optimizing database communications

Prerequisites:

• Experience with any other programming language (e.g.,Visual Basic, VBScript, C/C++, Javascript or Perl)

Related programming classes in San Francisco:

• Intro to Programming
• Intro to Programming