Object-Oriented Programming with Java Using AST 6.1 Training

Course Topics

1. An Introduction to Java
   • Key Java benefits
   • Write-Once Run Anywhere (WORA)
   • Compilation to execution
   • Portability implications
   • Java packages
   • Familiar C/C++ syntax
   • Rich library support
   • Library standards
   • Extensive documentation
   • JDBC: Java Database Connectivity
   • Security
   • Internationalization
   • Performance
   • Java product suite
   • Java JDK vs JRE installation
   • The installed JDK
   • The bin directory
   • Running Java
2. Java Language Fundamentals - Types
   • Creating Java statements
   • Structure of Java files
   • Simple program with main()
   • Java naming conventions
   • Java reserved words
   • Comments
   • Primitive data types
   • Integer number types
   • Real number types
   • Char type
   • Boolean type
   • Creating primitives
   • Naming conventions for primitives
   • Initializing primitives
   • Range of primitive types
   • Wrapper classes
   • Boxing and unboxing
   • Java arrays
   • Initializing Arrays
   • Arrays and Objects
3. Java Language Fundamentals – Flow of Control
   • Java operators
   • Operator precedence
   • Branching and looping
   • Code blocks
   • if else statement
   • switch statement
   • while statement
   • do-while statement
   • for statement
   • Enhanced for statement
   • break statement
   • continue statement
4. An Introduction to Object-Oriented Programming – Classes and Objects
   • Use of Object-Oriented programming
   • Object-Oriented definitions
   • Class definition
   • Attributes
   • Methods
   • An example Class
   • Method signatures
   • Objects
5. Creating Classes
   • Java directory system – packages
   • Packages and CLASSPATH
   • Classes and files
   • Declaring a class
   • Classes and packages
   • Anatomy of a class
   • Adding attributes to a class
   • Adding methods to a class
   • Method signatures
   • Variable argument methods
   • Method variables
   • Static attributes
   • More on visibility
   • Declaring constants
   • Constructors
   • Multiple constructors
   • Static methods
6. Using Java Objects
   • Creating an object
   • The process of object construction
   • The reference table
   • Working with objects
7. Namespaces and Java Libraries
   • JAR files
   • Packages and JARs
   • JARs and namespaces
   • Java packages
   • Mapping packages to the file system
   • The import statement
   • Using imported classes
   • Namespace clashes
   • Implicit imports
   • The String class
   • Dynamic strings with StringBuffer
   • The Math class
8. OO Programming Relationships
   • Inheritance
   • Inheritance limitations
   • Interfaces
   • Interface example
   • Polymorphism
   • Association
   • OO Design
   • Abstraction
   • Generalization and specialization
   • Finding classes
   • Noun-verb filtering
9. Inheritance
   • Inheritance in Java
   • java.lang.Object
   • Superclass
   • Subclass
   • Implications of extends
   • Overloading existing methods
   • Overriding existing methods
   • The super keyword
   • Constructors and inheritance
   • The protected modifier
   • The “is a” relationship
   • Abstracted classes
10. Abstract Classes
    • Abstract classes
    • Concrete classes
    • Using abstract references
    • Building a concrete class
    • Casting
    • Upcasting
    • Downcasting
11. Interfaces
    • Interfaces and abstract classes
    • Defining an interface
    • Implementing an interface
    • Using an interface
    • Design implications
    • Extending interfaces
    • Implementing an interface
    • Design issues with interfaces
    • Design practices
12. Polymorphism
    • Polymorphism mechanics
    • Object creation diagram
    • Reference table and polymorphism
    • Creating object references
    • Upcasting and polymorphism
13. Generics
    • What is a Generic?
    • Defining Generics
    • Generic formal type parameters
    • Declaration of Generics
    • Generics and sub-typing
    • Wildcards
    • null as a type
    • Bounded wildcards
    • Generic methods
    • Generics methods vs. sub-typing
    • Using Generics with legacy code
    • Erase and Transition
    • Generic class sharing
    • Casting and instanceof with Generics
    • Generics as array types
    • Class literals as run-time type tokens
    • Wildcard capture
14. Collections
    • Collections
    • The Collections framework
    • The Collection interface
    • The Set collections
    • Using a Set
    • Important methods of the Set interface
    • The Hashset
    • The Iterator interface
    • Sorted sets
    • The List collections
    • The Map collections
    • Linked collections
15. Input and Output
    • Input and output in Java
    • Java.io.*
    • Reading lines of text
    • Properties file
    • Stream hierarchy
    • InputStream class
    • OutputStream class
    • Buffered vs. unbuffered
    • File class
    • Text files
    • Writing to a text file
16. Exceptions
    • Handling exceptions
    • Built in exceptions
    • Throwing exceptions from main()
    • The stack trace
    • Working with catch
    • Multiple catch blocks
    • Different types of exceptions
    • Runtime problems
    • Throwable hierarchy
    • Checked and unchecked exceptions
    • The finally block
    • Throwing multiple exceptions
    • Writing custom exceptions
    • Dealing with error objects
    • Dealing with exceptions locally
    • Designing with exceptions
17. Annotations
    • What is an Annotation
    • The reason for Annotations
    • Annotations vs Javadoc
    • Annotation syntax
    • Types of Annotations
    • Annotation declarations
    • Simple Annotations
    • Override Annotation
    • Deprecated Annotation
    • Suppress Warnings Annotation
    • Meta-annotations
    • Target meta-annotation
    • Retention meta-annotation
    • Documented meta-annotation
    • Inherited meta-annotation
    • Examples of Annotation use
18. Enums
    • What is an Enum?
    • Problems with JDK 1.4 Enums
    • Enum types
    • Extending an Enum
    • Enum constructors
    • Built-in Enum methods
    • Adding fields and methods to Enums
    • Enums and Generics
    • Enums in switch/case
    • When to use Enums
Appendix I: Optional Topics An Introduction to Enterprise Java
• Goals of J2EE systems
• Container-managed systems
• WebSphere J2EE containers
• N-tier J2EE applications
• Presentation tier
• The WebSphere web container
• HTML
• Serving HTML in WebSphere
• Java Server Pages (JSPs)
• Serving JSP in WebSphere
• Key JSP issues
• Controller/mediator tier
• Servlets
• The role of a Servlet
• Key Servlet issues
• Domain tier
• The EJB container
• The EJB specification
• What is EJB?
• EJB fundamentals
• Overview of EJB container responsibilities
• Entity bean overview
• Session bean overview
• Message bean overview
• EJB deployment description
• EJB summary
• Java Messaging Service (JMS)
• Point to point communication
• Publish-subscribe communications
Appendix II: Introduction to AST 6.1
• Eclipse history
• AST: built from Eclipse
• Perspectives and roles
• View
• Editor area
• Basic operations with views and perspectives
• The Java perspective
• The debug perspective
• Navigator view
• Package explorer
• Outline view
• Problems view
• Tasks view
• Import and export project
• Searching
• JRE switching
Appendix III: Project Setup
• Projects
• Project properties
• Setting the compiler
• Workspace build settings
• Clean
• Build All
• Auto build
Appendix IV: Using the Debugger
• Debugging for J2SE
• Setting break points
• Starting a debug session
• Stepping and Run To
• The variables view
• The expressions view
• Examining collections data
• Changing data while debugging