Intermediate Java 7 Training

Answers to Popular Questions:

 
Yes, this class can be tailored to meet your specific training needs.
Yes, we provide Java Programming consulting services.
Yes, group discounts are provided.

Course Description

 
This five-day courseIt 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

Programmers with some previous experience in working with Java a nd Object - Oriented (OO) programming.

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]

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.