Call (605) 391-2110 to speak with a sales representative, or email us at email@example.com
||Introduction to Java Programming
||This course is designed for developers who want to learn the Java programming language and have experience in other languages like C, COBOL, Visual Basic, Fortran, and so on.
||Java: Behind the Wheel is an introduction to Java that builds a foundation for using Java in a real-world development environment. This intense five-day course begins with a discussion of why Java has become so popular and ends with the student writing a fully-functional chat program that uses Java threads, sockets, streams and GUI programming.
Module 1: An Introduction to Java
- Java Overview:
What Java is and why it is so popular today.
- The Lifecycle of Other Programs:
A look at how programs are developed
in other languages.
- The Lifecycle of a Java Program:
A look at how Java programs are developed.
- Performance Issues:
Translating vs. Interpreting.
- A Simple Java Program:
Writing a class in Java with main().
- The Java Development Kit: The
tools used to create a Java program.
- Writing a Java Program:
The details of creating and running a Java program.
Module 2: The Java Programming Language
- Java Keywords: The
- Identifiers: Names
used to identify the various parts of a program, like names of classes,
methods and fields.
- The Built-in Data Types: The
way Java stores data.
- The String Class:
A useful class in Java.
- Declaring Variables: Allocating
memory for data.
- Arithmetic Operators: The
syntax of the Java operators and their order of operation.
- Comparison Operators
- Boolean Expressions: Logic
and the Boolean operators.
- The if Statement: The
basic tool for making decisions.
- The if/else Statement:
Extending an if statement.
- The switch Statement: Another
- The while Loop: Repeating
- The do/while Loop:
A variation of the while loop.
- The for Loop: Useful
for repeating a specific number of tasks.
Module 3: Object Oriented Analysis &
- OOP and Procedural Languages:
Today’s common programming languages.
- Writing a Program Procedurally:
An overview of how procedural programs
- Writing a Program Using Objects:
An overview of OOP.
- Classes and Object:
The fundamental components of an object-oriented program.
- An Introduction to OOAD: Object
Oriented Analysis and Design.
The Unified Modeling Language.
Creating a new class from an existing class.
Module 4: Classes and Objects
- Classes and Objects: An
object is an instance of a class.
- Writing a Class in Java: Determining
fields and methods.
- Instantiating Objects: The
- Using Objects:
The dot operator.
- Understanding References: Understanding
the difference between a reference and an object.
- Garbage Collection
- The == operator
- The "this" Reference
- Methods: The
signature of a method.
- Invoking Methods:
Using the dot operator.
- Passing References by Value:
- Method Overloading
A special type of method that allows an object to be initialized when
it is instantiated.
- Access Specifiers
- Encapsulation: Hiding
the fields of a class.
- Static Fields and Methods: Understanding
the concept of static.
- Instance and Static initializers
- Packages: Java’s
well-defined namespace technique.
Module 5: Inheritance and Polymorphism
Creating new classes from existing classes.
- The "is a" Relationship:
Determining when inheritance is a good
- The extends Keyword:
Implementing inheritance in Java.
- What Gets Inherited: Understanding
what a child inherits from its parent.
- Single Inheritance: A
child can only have one parent.
- Method Overriding:
A child class overriding a behavior of the parent class.
- The super Keyword:
- The Object Class:
The finalize() and toString() methods
Using this() and super()
- Virtual methods
- final Methods and Classes
Module 6: Arrays
Contiguous memory for storing data.
- Array References
- Array Objects:
- Using Arrays:
Indexes and the length attribute.
- Arrays of References
- Copying Arrays:
- Multidimensional Arrays
Module 7: Interfaces
- Interfaces: Creating
an interface in Java.
- Implementing an Interface:
A class implements each method of an
- Constants in Interfaces:
Interfaces can contain static final attributes.
- Extending Interfaces:
An interface can be subclassed by another interface.
- Interfaces and Polymorphism:
Using interface references.
Module 8: Exception Handling
- Exceptions: The
hierarchy of exception classes.
- The Throwable Class: The parent
of all the exception and error classes.
- Catching Exceptions: Using
- Declaring Exceptions: The
handle or declare rule.
- Throwing Exceptions: The
- The finally Statement: Always
executes after a try block.
- User-defined Exceptions: Creating
your own exception classes.
Module 9: GUI Programming
- Swing vs. AWT: Understanding
the difference options available.
- Containers and Components: The
relationship between components and containers.
- The java.awt.Frame Class:
Represents a standard window.
- Layout Managers:
Flow, border and grid layout.
- Event Handling: The
- The GUI Events:
The event classes and listener interfaces.
- The Event Adapters
The various Swing and AWT components.
Module 10: Threads
- Processes vs. Threads:
Understanding what a thread is.
- Thread Scheduling:
The lifecycle of a thread.
- Creating a Thread:
The Thread class and the Runnable interface.
Making your Java classes thread-safe.
Module 11: Input and Output
- The File Class: Represents
a file on a hard drive.
- The java.io Package:
An overview of the input/output classes.
- Streams vs. Readers and Writers:
Binary streams vs. character streams.
- Low-level Streams: Connecting
to the source of data.
- High-level Streams:
Stream filters and buffers.
Java’s object serialization.
- Low-level Readers and Writers:
- High-level Readers and Writers
Module 12: Sockets
An overview of sockets.
- The Server:
Listening for requests from clients.
- The Client:
Connecting to the server.
- Socket Streams:
Communicating between the client and server.
Appendix A: Applets
- An Overview of Applets:
A Java program that runs in a web browser.
- The Applet Class:
The parent class of all applets.
- The Methods of the Applet Class:
init(), start(), stop(), destroy() and
- Embedding an Applet in a Webpage:
The <applet> tag in HTML.
- The Graphics Class:
Used for drawing in the applet.
Allows the HTML to pass data to the applet.