HARTMANN software group

Intermediate Java 7 Using Rational Application Developer (RAD) Training in Columbia

Enroll in or hire us to teach our Intermediate Java 7 Using Rational Application Developer (RAD) class in Columbia, South Carolina by calling us @303.377.6176. Like all HSG classes, Intermediate Java 7 Using Rational Application Developer (RAD) may be offered either onsite or via instructor led virtual training. Consider looking at our public training schedule to see if it is scheduled: Public Training Classes
Provided there are enough attendees, Intermediate Java 7 Using Rational Application Developer (RAD) may be taught at one of our local training facilities.
We offer private customized training for groups of 3 or more attendees.
get pricing information

Course Description

  
This 5-day course includes a short review of basic Java concepts, and then moves on to a comprehensive coverage of more advanced topics in Java and OO programming to provide participants with a strong grounding in using Java in a sophisticated and productive manner. This course goes well beyond the basics of Java and OO programming and covers important topics such as composition, inheritance, polymorphism, interfaces and exceptions, which are all key to creating well-structured OO systems using Java. After coverage of these important areas, it moves on to more advanced topics such as JDBC and JPA 2 (for database access), the Java Collections Framework - including the important generics capabilities, Java I/O, assertions, inner classes, and the reflection API. Finally it covers useful tools for day-to-day programming such as ant, maven, JUnit and various logging frameworks. This course covers far more than an introductory course, and provides participants with a comprehensive understanding of how to use Java's advanced capabilities in a more sophisticated manner. It teaches a number of useful techniques that enhance productivity and good system design - which Java programmers may otherwise take years to absorb on their own.
Course Length: 5 Days
Course Tuition: $2090 (US)

Prerequisites
Suitable for programmers with some previous experience in working with Java and Object-Oriented (OO) programming (equivalent to taking our Gentle Java course).

Course Outline

  
Session 1: Review - Getting Started
Writing and Running Java programs
Setting up and Using the Development Environment
 
Session 2: Review - Class and Object
Creating classes with fields and methods
Encapsulation and access protection
Constructors
Other Capabilities (Static Members, null, final, Wrapper Classes
 
Session 3: Review - Control Flow, String, and Array
Flow of Control
Strings
Arrays
 
Session 4: Review - Packages
Using packages to organize code
Using import
Creating Packages
Package Organization and Classpath
LABS:
Using Packages to Organize Code
 
Session 5: Composition and Inheritance
Using Composition to Deal With Complexity
Composition/HAS-A, Delegation
Using Inheritance and Polymorphism to share commonality
IS-A, extends, Inheriting Features, Overriding Methods, Using Polymorphism
Class Object
Abstract Classes
LABS:
(Optional) Working with Composition
Using Inheritance to Specialize Classes
 
Session 6: Interfaces
Programming by Contract
Using Interfaces to Define Types
Interfaces and Polymorphism
LABS:
Using Interfaces to Remove Implementation Dependencies
 
Session 7: Exceptions and Error Handling
Exceptions
Exception Hierarchy
try and catch
Handling Exceptions
Program Flow with Exceptions
Finally
LABS:
Handle Exceptions
Define Exception Class
 
Session 8: Collections and Generics
The Collections Framework
Collection Interfaces
Collection, Set, List, Map, Iterator
Generics  (Java 5)
Processing Items With an Iterator
for-each Loop (Java 5)
Using ArrayList
Using HashMap
More About Generics (Inheritance, Wildcards, Assignment)
LABS: 
Using Collections
 
Session 9: JDBC and the JPA
JDBC Overview and Architecture
JDBC Connections, Statements, and Queries
Introduction to JPA (Java Persistence API)
Object-Relational Mapping (ORM) and JPA Architecture
Entity Class Introduction
Mapping Entity classes with @Entity, @Id, @Table, and more
Persistence Units, persistence.xml, the EntityManager and EntityManagerFactory
Using JPA to Work with Persistence Entities
JPQL and Querying with JPA
LABS: 
Mapping a Simple Class
Using JPA to Access Persistent Entities
Inserting, Querying, and Other Capabilities
 
Session 10: Additional Java Features
Assertions
Type-safe Enums
Annotations
 
Session 11: I/O Streams
Readers and Writers
Filter Streams
InputStreams and OutputStreams
Converting Between Streams and Readers/Writers
New I/O (NIO) APIs
LABS:
Formatting with Java I/O
 
Session 12: Inner Classes
Why Use Inner Classes?
Named Inner Classes
Static Inner Classes
Anonymous Inner Classes
LABS:
Using Named Inner Classes
Using Anonymous Inner Classes
 
Session 13: Reflection
The class called Class
Finding Fields, Methods, and Constructors
Accessing Fields, Invoking Methods
Examining Arrays
LABS:
Examining Objects Using Reflection
Accessing Fields and Invoking Methods via Reflection
 
Session 14: Introduction to ant
ant Overview, Installing and Running ant
Buildfiles, Projects, Targets, Tasks, Properties
Creating Build Files
Paths(e.g. CLASSPATH, PATH)
Resource Collections - FileSets, DirSets, Files, PatternSets
LABS: 
Running ant
Creating and Using Buildfiles
Using Basic ant Tasks
 
Session 15: maven Overview
Introduction and Installation
Maven Concepts and the POM (pom.xml>
Dependencies and Repositories
Using maven to build Java projects
LABS: 
Using maven
 
Session 16: JUnit Basics
JUnit Overview, Test Driven Development
Tests and Assertions
Working With Exceptions
LABS:
Writing and Running Tests
Testing Exceptions
 
Session 17: Organizing Tests with JUnit
Writing Fixtures - @Before, @After
Test Suites, and Other Capabilities
Mock Objects
LABS:
Using Fixtures
Using Suites
 
Session 18: Introduction to Logging and log4j
Logging Overview
log4j Overview
Loggers, Appenders, Layouts
Configuring and Using log4j
Logger Hierarchy and Logging Levels
Working With Appenders
Using PatternLayout
Other Logging Frameworks (Java Logging, Apache Commons Logging)
LABS:
Setting Up log4j
Using Basic log4j Logging
Working With Loggers
Working With Appenders
Using Layouts

Course Directory [training on all levels]

Technical Training Courses
Software engineer/architect, System Admin ... Welcome!
Business Training Courses
Project Managers, Business Analysts, Paralegals ... Welcome!
Upcoming Classes
Gain insight and ideas from students with different perspectives and experiences.

Java Programming Uses & Stats

Java Programming is Used For:
Android & IOS Development Software Products Video Games Desktop GUI's
Difficulty
Popularity
Year Created
1995
Pros

Most Commonly Used: 
According to Oracle, three billion devices run on Java.  And, because of its real-world applications, it consistently ranks at the top of the TIOBE Programming Community Index. 

Great Career Choice: 
Some of the fastest-growing salaries in the U.S. in 2018 are for Java developers.  (Glassdoor)  

Android Apps Development:
Developers predominatly use their Java skills in building apps for Google's Android. The Android platform is the number one mobile paltform in the world

It Can Run On Any Platform:
Java can compile on Windows and run the same compiled file on Linux, Windows and Mac.

Great Supporting IDE's:
Over the years, coding in Java has become simpler with the introduction of open source development tools, i.e. Eclipse and NetBeans that use Java capabilities for debugging.  
 
Cons

Uses a Lot of Memory:
Performance can be significantly slower with Java and more memory-consuming than natively compiled languages such as C or C++.

Difficulty in Learning: 
Learning Java can be a bit challenging if you are a beginner.  However, once you get the hang of Object Oriented Programming and a decent grasp of the syntax, you will be well on your way.

Slow Start Up Times:
There is quite a bit of one-time initialization done by JDK classes before compiling as well as loading classes and verification (making sure code doesn't do evil things, all of which takes longer that some other languages such as C. 

Verbose and Complex Code:
Long, over-complicated sentences make code less readable and scannable. Compare to let's say Python, we can see how clear Python code appears: It doesn’t require semicolons; uses “and,” “or,” and “not” as operators instead of Java’s “&&,” “||,” and “!”; and generally has fewer bells and whistles such as parentheses or curly braces.

Commercial License Cost:
Companies have to prepare for the changes that Oracle will institute in 2019 . Today, the current version of Java is free and available for redistribution for general purpose computing. However, If you are a DEVELOPER, Oracle recommends you review the roadmap information for Java SE 8 and beyond and take appropriate action depending on the type of application you develop and your distribution mode.
Java Programming Job Market
Average Salary
$102,000
Job Count
26,856
Top Job Locations

New York City 
San Jose
Washington D.C, 
Complimentary Skills to have along with Java Programming

- If you are an experienced Java developer, learning a complimentary language to Java should come much more naturally.  As an example JetBrains recently created the Kotlin programming language which is officially supported by Google for mobile development.  Kotlin compiles to Java bytecode and runs on the JVM; it's purported to address many of Java's shortcomings...

Interesting Reads Take a class with us and receive a book of your choosing for 50% off MSRP.