Fast Track to Java 7 and OO Development

Request more details:

Description:
This is a 5-day course that provides a broad and deep introduction to Java for non-Java programmers. The course covers all the basic concepts of Object-Oriented Programming and Java. Included is the material and labs on all the key OO concepts, including topics like encapsulation, composition, and inheritance. It also includes some coverage of advanced Java capabilities such as JDBC/JPA and the Collections Framework, as well as coverage and usage of many of the newer capabilities in Java 7. There are a large number of labs, and all labs except the first are done with a development environment (e.g. Eclipse or RAD). The lab instructions include detailed directions on the particular environment for that version of the course.
Prerequisites:
Previous programming experience in C, C++, or C#®, and some knowledge of basic object-oriented concepts are recommended.
A Simple Java Class and Running a Java Program:
A Simple Application Class
The HelloWorld Program Broken Down
Compiling HelloWorld
Note on Comments
Java Overview:
Language and Platform Features
What is Java?
Java is Modern and Object-Oriented
Java is Portable and Safe
Java has Multiple Platforms
Program Life Cycle
Java Source and Java Bytecode
Life Cycle of a Java Program
Java Programs Insulated from Environment
Java is Dynamic – The Runtime Process
The Java SE Software Development Kit (JDK)
The Java API
Downloading and Installing the JDK
Class and Object Basics:
Object-Oriented Programming Overview
What is Object-Oriented Programming?
What is an Object?
Important Characteristics of Objects
About Object-Oriented Programming (OOP)
What’s a Type?
Types, Instances, and Property Values
Classes and Objects
Identity and Object References
Classes, References, and Instantiation
The Class in Java
Class Definition
A Class Definition is a Blueprint
Creating and Referencing Objects
More About Identifiers
Methods and Data in a Class
Behavior and Methods
Invoking Methods
Storing Data in Objects
About Instance Variables
Data Access and Return Values in Methods
Accessing Data (Another Way)
Pretty Pictures
More About Variables
About Java Primitive Data Types
Numeric Literals
Non-numeric Literals
Strings
Primitive Types are Value Types
Arithmetic Operations
Primitive Type Conversion and Casting
More on Classes and Objects:
Working with Methods and Data
Working Within Methods
Calling Methods
Local Variables
The this Variable and Instance Data
Pretty Pictures
Overloading Methods
Calling Overloaded Methods
The tostring() Method
Encapsulation and Access Control
Encapsulation: Black Boxes
Key Advantages of Encapsulation
Program Correctness
Access Control
Access for Data Members and Methods
Private Access
Public Access
Constructors
Using Constructors
Explicit Constructor Call
Static or Class Members
Declaring Static Members
Accessing Static Members
Accessing Data in Static Methods
final Variables
Odds and Ends
Scopes and Blocks
Assignment
Comparison
Null Objects
Wrapper classes
Reference Types as Method Parameters
final Method Parameters
Flow of Control:
Branching Statements
Program Execution Sequence in Java
The Comparison Operators
The Logical Operators
if-else Statement
switch Statement
Iteration Statements
while Statement
do-while Statement
for Statement
break Statement
continue Statement
Strings and Arrays:
String and StringBuffer/StringBuilder
Using Strings
Changing Strings
Classes StringBuffer and StringBuilder
Using StringBuffer and StringBuilder
Regular Expressions
Arrays
Creating Arrays and Accessing Elements
Array of Object References
Array of Strings
args Array
Iterating Over Arrays
varargs
Packages:
Packages Overview
Dealing with Complexity
Packages
package Statement
The Default Package
import Statement
Importing a Complete Package
Importing a Single Package Member
Using the Fully Qualified Name
Standard Imports
Resolving Naming Conflicts
Creating a Package
Access Control for Class Members
Access Control for Classes
Finding Classes
Tools Must Locate Class Definitions
Organizing Files and Packages
Class Path
What is a JAR?
Composition and Inheritance:
Composition
Dealing with Complexity and Composition
Composition
Delegation
Benefits of Composition
Issues with Composition
About Object Relationships
Other Kinds of Relationships
Inheritance
Inheritance and Dealing with Complexity
Inheritance Hierarchy
The extends Keyword
Inheriting from the Superclass
Inheritance and Superclass Data Members
A Subclass IS-A Superclass
Accessing Superclass Members
Constructors and Inheritance
Final Classes
Overriding and Polymorphism
Changing Behavior with Method Overriding
OO Concepts – Polymorphism
Polymorphism
Importance of Polymorphism
The super keyword
Access Control – protected Access
Class Object
Methods of Class Object
Automatic Storage Management
Abstract Classes
Using Abstract Classes
Interfaces:
What if All You Have to Share is an Idea?
Interface Types
Interface Definitions
The implements Keyword
Interface Types – Revisited
Extending Interfaces
Implementing Extended Interfaces
Interfaces are Abstract
Data Members in Interfaces
Implementing Multiple Interfaces
Exceptions:
Overview of Exceptions
Exception Hierarchy
Exception, Error, RuntimeException
Handling Exceptions with try and catch
Exceptions and Program Flow
Variable Scope
The throws Clause
Throwing Exceptions with throw
User-Defined Exceptions
Multiple catch Blocks
finally Block
Runtime Exceptions
Multicatch (Java7)
Using try-with-resources
(Java 7)
Collections and Generics:
Java Collections Framework Overview
java.util Collection Interfaces
Collection Interface
Generics and Type-Safe Collections
List and ArrayList
List Interface
ArrayList
The for-each Construct
Autoboxing and Collections of Object
Autoboxing
Summarizing Collections Features
Collections of Object
Issues with Collection of Object
Other Collection Types
Set Interface
Using Sets
Map Interface
HashMap
Generic HashMaps
Creating and Using HashMap
Iterating Through a HashMap
Iterator
Processing Items with an Iterator
Iterator Interface
What are Generics
Declaring a Generic Class
Summary – Basic Generics Usage
Inheritance with Generic Types
Assignment with Generic Types
Wildcard Parameter Types
Generic Methods
The Collections Class
Unmodifiable Wrappers
Algorithms
Database Access with JDBC and JPA:
What is JDBC?
JDBC Architecture
The Fundamental JDBC API
Common JDBC Types
Naming Databases with URLs
The Item Database Table
JPA Overview
Java Persistence API (JPA)
JPA Architecture – High Level View
JPA Architecture – Programming View
Working with JPA
Entity Classes
MusicItem Entity Class
Annotation Overview
Additional MusicItem Annotations
Mapping an Entity Class
The Persistence Unit
persistence.xml Structure
The EntityManager
Working with Transactions
Using JPA
Persisting a New Entity
Updating a Persistent Instance
Removing an Instance
Executing a Query
Additional Language Features:
Assertions Defined
Assertion Uses
Assertion Non-Uses
Assertion Syntax
Using Assertions to Check Flow of Control
Enabling/Disabling Assertions at Runtime
What They Look Like at Runtime
Type-Safe Enums
Enumerated Types Defined
Problems with int Enumerated Types
The enum Keyword
switch on enum
for-each with enum
Advanced enum Features
Annotations
The Issue
Annotations – The Solution
Other Java Features
XML and Web Service Support
Java DB
Scripting Language Integration
Desktop Application Improvements
Monitoring and Management Tools
Other Features (Java 6+)
I/O Streams:
Readers and Writers
Overview of I/O Streams
Character Streams
Class Reader
Class Writer
Common Reader Subclasses
Common Writer Subclasses
Using Readers and Writers
Path Separators
Filter Streams
High-Level and Low-Level Streams
Converting between Streams & Readers/Writers
Byte Stream Classes
Common Stream Subclasses
Converting Between Byte & Character Streams
Character Stream and Byte Stream Equivalents
Formatted Output
Integer Format Specifiers
Format Specifier Modifiers
Other Format Specifiers
New I/O (NIO) APIs
New I/O (NIO)
NIO Features
Recap
Resources