Java 7 SE Programming for OO Experienced Developers (TT2100-J7) TT2100-J7

Days: 5 day
Price: $2495

Course Details

This comprehensive, hands-on introduction to Java is geared for developers who have prior working knowledge of object-oriented (OO) programming languages such as C++.

Throughout the course, you will learn the best practices for writing great OO programs in Java 7 using sound development techniques, new improved features for better performance, and new capabilities for addressing rapid application development. You will participate in exercises, and you will work through a case study that covers the entire spectrum, from use cases to OO design to implemented classes. You can use the case study during and after the course as a reference and a tool for reviewing and practicing what you learned in class.

Course Agenda

1. Java: A First Look

  • Using the JDK
    • Setting Up Environment
    • The Development Process
    • Class Files
    • Java Applications
  • Writing a Simple Class
    • Classes in Java
    • Class Modifiers and Types
    • Variables and Primitives
    • Creating Objects
    • The main Method
    • Using the Dot Operator
    • Writing Output
  • The Java Platform
    • Defining Java
    • Java SE Development Kit (JDK)
    • Executing Programs
    • Lifecycle of a Java Program
    • Java Virtual Machine (JVM)
    • Java is Dynamic: The Runtime Process
    • Garbage Collection
    • Documentation and Code Reuse
    • JavaDoc Provides Documentation Delivery
    • In-Line Comments are Translated into HTML Rendering

2. OO Concepts In Java

  • OO Programming
    • The OO Way
    • Real-World Objects
    • Classes and Objects
    • Object Behavior
    • Methods and Messages
  • Inheritance, Abstraction, and Polymorphism
    • Encapsulation
    • Inheritance
    • Method Overriding
    • Aggregation
    • Type Abstraction: Grouping as Supertype
    • Polymorphism

3. Getting Started with Java

  • Adding Methods to the Class
    • Instance Methods
    • Passing Parameters into Methods
    • Overloaded Methods
    • Constructors
  • Language Statements
    • Operators
    • Comparison and Logical Operators
    • Using Comparison and Logical Operators
    • Looping: The for Statement
    • Looping: The while Statement
    • Looping: The do Statement
    • Continue and Break Statements
    • The switch Statement
  • Using Strings
    • Strings
    • StringBuffer
    • StringTokenizer
    • Scanner
    • Formatter
  • Specializing in a Subclass
    • Extending a Class
    • The extends Keyword
    • Casting
    • Overriding Superclass Methods
    • Method Overriding Diagram
    • Calling Superclass Methods from Subclass
    • The Object Class
    • The equals Method
    • Constructors

4. Essential Java Programming

  • Fields and Variables
    • Fields vs. Variables
    • Instance vs. Local Variables: Usage Differences
    • Data Types
    • Default Values
    • Block Scoping Rules
    • Using this
    • Final and Static Fields
    • Static Variable Diagram
  • Using Arrays
    • Arrays
    • Accessing the Array
    • Multidimensional Arrays
    • Copying Arrays
  • Static Methods and Fields
    • Static Fields
    • Simple Example of Static Fields
    • Static Methods
  • Java Packages and Visibility
    • The Problem
    • Packages
    • Class Location of Packages
    • The Package Keyword
    • Importing Classes
    • Executing Programs
    • Accessibility/Visibility
    • Java Naming Conventions
    • Packages Diagram

5. Advanced Java Programming

  • Inheritance and Polymorphism
    • Polymorphism
    • Polymorphism: The Subclasses
    • Derived Classes as the Superclass
    • Casting to the Derived Class
    • Using instanceof for Downcasting
    • Upcasting vs. Downcasting
    • Calling Superclass Methods from Subclass
    • The final Keyword
  • Interfaces and Abstract Classes
    • Separating Capability from Implementation
    • Abstract Classes
    • Shape as an Abstract Class
    • Polymorphism with Abstract Classes
    • Interfaces
    • Implementing an Interface
    • Extending Interfaces
    • Polymorphism with Interfaces
    • Type Checking
    • Abstract Classes vs. Interfaces
    • Interfaces Diagram
  • Exceptions
    • Exception Architecture
    • Handling Exceptions
    • The Throwable Class
    • The try Block, The catch Block, and The finally Block
    • Generalized vs. Specialized Exceptions
    • Overriding Methods
    • Creating Your Own Exceptions
    • Throwing Exceptions
    • Checked vs. Unchecked Exceptions

6. Java Developer's Toolbox

  • Utility Classes
    • Wrapper Classes
    • The Number Class
    • Numbers and Strings
    • Big Decimal
    • Random Numbers
    • Decimal Formatting
    • The Date Class
  • Collections
    • The Collections Framework
    • Characterizing Collections
    • Collection Interface Hierarchy
    • Top-Level Collection Interfaces
    • Collection Interface Provides Element Handling
    • Collections Utility Methods
    • Generics and Collections
    • Generics and Parametric Polymorphism
    • Java 7: The Diamond Operator
    • Simple Generics
    • Iterators
    • The Set Interface; SortedSet
    • Comparable; Comparator
    • HashSet (Set) and TreeSet (SortedSet) Example
    • NavigableSet
    • The List Interface
    • Queue Interface
    • Map Interface Hierarchy
    • Creating and Using a HashMap
    • Feature Comparison
    • Using the Right Collection
    • Collection vs. Vector/Hashtable
    • Collections and Multithreading
    • Optimizing Collection Constructors: Initial Size
  • Generics
    • Generics and Subtyping
    • Compiler Restrictions on Generics and Subtyping
    • Wildcards
    • Standard Rules Apply
    • Generic Methods
    • Interoperability with Legacy Code
    • Raw Types
    • Legacy Calls to Generics; When Generics Should Be Used
  • Java GUIs
    • Java Foundation Classes (JFC)
    • Categories of Classes in JFC
    • Creating the Frame and Adding Content to a Frame
    • A Closer Look at Layout Managers
    • BorderLayout
    • JFC Provides an Event Handling Structure
  • Autoboxing, Enhanced for Loop, and Varargs
    • Autoboxing/Unboxing
    • Iterators and Collections
    • The for-each() Loop; For-each Loop Restrictions
    • Legacy Variable Argument Support
    • Variable Arguments and Varargs Rules
    • Issues
  • Enumerations and Static Imports
    • Rationale for Enumerations
    • Enumeration Syntax and Methods
    • Enumerations as a Better Class Type
    • EnumSet and EnumMap
    • When You Should Use Enumerations
    • Using Static Imports
    • When You Should Use Static Imports
  • Inner Classes
    • Defining Inner Classes
    • Member Inner Classes
    • Local Inner Classes
    • Anonymous Inner Classes
    • Anonymous Subclassing
  • Multithreading
    • Principles of Multithreading
    • Creating a Threaded Class
    • Example: Runnable Class
    • Daemon Threads
    • Thread Scheduling and Signaling a Thread
    • Sleeping
    • Thread Synchronization
    • Synchronized Methods and Statements
    • Object Synchronization
  • Concurrent Java
    • Synchronized Code Uses an Implicit Lock
    • Concurrent Locks are Explicit and Flexible
    • Using ReadWriteLock
    • Need to Separate Thread Management
    • Executor Interfaces Provide Thread Management
    • Scheduling Tasks using Executors
    • Concurrent Use of Collections
    • Scaling Using BlockedQueue
    • Atomic Variables Avoid Synchronization
    • Options for Avoiding Threading Errors and Issues
    • Java 7: Support for Multi-Core Platforms
  • Java I/O
    • The Java I/O Mechanism
    • Subclasses Accessing Real Data
    • Filter Classes
    • Reading Stream as Data Primitives
    • Writing Buffered Data to a File
    • Character Level I/O
    • Subclasses Accessing Real Data
    • Reader/Writer Filter Classes
    • Serialization
    • New File IO - NIO
    • NIO Overview
    • Stream-Based (IO) vs. Buffer-Based (NIO)
    • Blocking (IO) vs. Non-Blocking (NIO)

7. Java Application Development

  • Annotations
    • Annotations Overview
    • Working with Java Annotations
    • Example of Using @ Override
    • Annotations are Heavily Used in Many Technologies
    • Declaring Persistence in Hibernate
  • File System Access
    • The File Class
    • File Utility Methods
    • RandomAccessFile
    • Byte-Based File Access
    • Text-Based File Access
    • FileReader Diagram
    • Java 7: Automatic Closure of Resources
  • Networking
    • Socket Programming Fundamentals
    • Communicating on a Socket
    • Single-Threaded Server Performance
    • Creating a Threaded Server
    • Sending and Receiving Objects
    • Useful Methods
    • Java 7: Automatic Closure of Resources
  • JDBC
    • What is JDBC?
    • Structured Query Language (SQL)
    • Connecting to the Database
    • Statement and PreparedStatement
    • ResultSet
    • JDBC Diagram
    • Executing Inserts, Updates, and Deletes
    • Controlling Transactions and Concurrency
    • Mapping SQL Types to Java Types
    • Database Connection via JDBC Calls
    • Connection Pooling
    • Database Connection Using a DataSource
    • Stored Procedures
    • Callable Statement Syntax
    • Stored Procedure Parameters
    • RowSet Implementations
    • JDBCRowSet and CachedRowSet
  • Java Logging
    • Logging Framework
    • Logging in Java
    • The Logger Class
    • Global Configuration
    • Programmatically Setting Logging Properties
    • Programmatic Handlers
    • Formatters
    • Logging Security and Performance

Details

Options

Training