nTier Training has delivered highly-customized Java training to technical teams for more than a decade, teaching everything from fundamentals to advanced techniques. Our comprehensive catalog includes Java SE, Java EE, Web Programming, SOAP and RESTful Web Services, EJB, Spring, Hibernate and more.
To get started, check out the class outlines below or connect with a training consultant.
The twenty-year-old language consistently tops the TIOBE index as the world’s most popular programming language, which comes as no surprise to those familiar with Java’s benefits, including:
The ability to write better code with fewer bugs
Lower software maintenance costs
Reduced time to market
Design patterns
A library of powerful, well-designed APIs
Click on the links below to view course outlines, pre-requisites, course length and course objectives.
Duration: 5days | NTJVA201
Description
nTier’s intermediate Java training course teaches programming focuses on core Object Oriented Principles
and concepts, Unit Testing and Test Driven Development, key Java functionalities. It is intended for students
with some previous Java experience or training and who already know the fundamentals of the Java
architecture and basic procedural programming. This course provides in-depth coverage of object-oriented
concepts and how to apply them to Java software design and development. This includes the introduction of
some core design patterns and the advantages that they bring to an extensible design.
Students must be able to write, compile, test and debug simple Java programs using structured programming
techniques, strong data types and flow- control constructs such as conditionals and loops. At least six months
of Java experience is recommended.
Objectives
● Chiefly, learn to program effectively in the Java language
● Understand Java as a purely object-oriented language, and implement software as systems of classes
● Implement and use inheritance and polymorphism, including interfaces and abstract classes
● Utilize Functional Interfaces i.e. Lambdas, Generics, Optional and LocalDateTime API
● Understand the structure of streams in Java including predicates, mapping, reducing and finding
● Use JUnit capabilities
● Use Test Driven development (TDD) to evolve the design, utilize common refactoring techniques to
overcome code smells
● Learn how to leverage Files, and how to use streams to manage file I/O
● Learn how to use Java Serialization to internalize and externalize potentially complex graphs of
objects
Prerequisites
Students must be able to write, compile, test and debug simple Java programs using structured programming
techniques, strong data types and flow-control constructs such as conditionals and loops. At least six months
of Java experience is recommended.
Outline
● Object-Oriented Software
o Complex Systems
o Abstraction
o Classes and Objects
o Responsibilities and Collaborators
o Lightweight Design
o Relationships
o Visibility
● Inheritance and Polymorphism in Java
o Extending Classes
o Using Derived Classes
o Type Identification
o Compile-Time and Run-Time Type
o Polymorphism
o Overriding Methods
o Superclass Reference
o Lab – Build by extension rather than modification
● Interfaces and Abstract Classes
o Separating Interface and Implementation
o Designing Interfaces and Interface Realization
o Implementing and Extending Interfaces
o Default Methods, Static Methods and Functional Interfaces (Lambda)
o Abstract Classes
o Lab – Advanced Interfaces
● Generics
o Raw Types
o Generic Methods and Bounded Type Parameters
o Upper and Lower Bounded WildCards
o Type Erasure
o Lab – Using Generics
● Unit Testing
o JUnit
o JUnit Life Cycle, @BeforeAll, @BeforeEach, @Test, @AfterEach, @AfterAll,
o Using assertThat and Hamcrest Matchers
o Parameterized Tests
o Testing Exceptions
o Lab – Unit Testing
● Test Driven Development (TDD)
o Defining your API
o Writing tests First, Design Test, Code, refactor cycles
o Refactoring techniques and code Smells
o Test Antipatterns
o Lab TDD
● Understanding Patterns
o Refactoring to Patterns
o Factories and Builders
o Lab – Creational pattern
o Strategy
o Adapter
o Template Method
o Lab – Structural and behavior patterns
● Lambdas
o Functional Interfaces
o Java.util.function package – Consumer, BiConsumer, Function, BiFunction and Predicate
o Generics and Type coercion in Lambdas
o Creating your own Functional interfaces
o Method References
o Lab – using Lambdas
● Streams
o Streams vs Collections
o Intermediate and Terminal Operations
o Filtering with Predicates
o Mapping and transforming, flatMaps
o Reducing, numeric Streams
o Lab – simple streams
o Collectors
o Grouping
o Finding elements in streams
o Parallel Streams
o Fork and Join framework
o Lab – Parallel streams, executor
● Optional
o Representing optional values instead of using null references
o Optional.of(), Optional.ofNullable()
o Using get(), orElse(), isPresent()
o Lab – using Optional
● Date and Time API
o LocalDateTime
o Formatting Dates
o Parsing date time objects
o Lab – LocalDateTime
● Working with Files
o Delegation-Based Stream Model
o InputStream and OutputStream
o Media-Based Streams
o Filtering Streams
o Readers and Writers
o File Class
o Modeling Files and Directories
o File Streams
o Random-Access Files
o Lab – Readers and writers
● Java Serialization
o The Challenge of Object Serialization
o Serialization API
o Serializable Interface
o ObjectInputStream and ObjectOutputStream
o The Serialization Engine
o Transient Fields
o readObject and writeObject
o Externalizable Interface
o JAXB marshalling and unmarshalling
o Lab – Serialization
Course Number:
Audience:
Prerequisites:
Solid Java programming skills are required. At least 6 months of hands on experience with Java or graduating a Java boot camp are required.
Course Number:
Audience:
Prerequisites:
Solid Java programming experience is extremely helpful – especially object-oriented use of the language. Language features and techniques that are integral to some lab exercises include interfaces and abstract classes, threading, generics, collections, and recursive methods. Previous experience with UML (Unified Modeling Language) will be helpful, but is not critical. The course uses UML class diagrams extensively but keeps notation fairly simple, and also includes a quick-reference appendix.
Course Number:
nTier’s intensive hands-on course will teach you how to integrate Test Driven Development (TDD) to fully harness the power of modern best practices to provide the most valuable software possible. TDD is about return-on-investment; this course shows you how to implement TDD for results! Derived from our 2 week “Effective Software Development Boot Camp”, this course is highly customizable to fit your specific needs – just ask!
This class is tailored to serve the following audiences: Software Developers, Technical team leaders and Managers needing to better understand the technologies they oversee.
Default language focus is on Java, but the training can be delivered relevant to: Java, C#, VB.net, & C++ languages.
Audience:
Prerequisites:
Students should complete at least 3-6 months experience with the programming language you want to learn TDD in before taking this course.
Course Number:
Audience:
Prerequisites:
The following courses are intended for students with some previous Java experience or training and who already know the fundamentals of the Java architecture and basic procedural programming. Students must be able to write, compile, test and debug simple Java programs using structured programming techniques, strong data types and flow- control constructs such as conditionals and loops. At least six months of Java experience is recommended.
Course Number:
Audience:
Prerequisites:
Solid Java programming skills are required. A minimum of 6 months hands on Java coding or a Java Boot Camp is strongly recommended.
Introduction and Fundamentals
Events and Controls
Layout Components
UI Control Fundamentals
– Composite UI Controls
Properties and Bindings
Charts and WebView
Course Number:
Java 8 introduces a number of revolutionary capabilities – many of them centered on lambda expressions and functional-style programming. These capabilities add powerful new programming techniques to the language, but also add complexity. This concise course is focused on introducing the new capabilities and how to use them. It includes numerous code examples and programming labs that illustrate all of the new capabilities.
The course is hands on, and requires that students be comfortable with writing general Java code at an intermediate level, including the use of interfaces.
Audience:
Prerequisites:
Course Number:
Audience:
Prerequisites:
Solid Java programming skills are required. A minimum of 6 months hands on Java coding or a Java Boot Camp is strongly recommended.
Course Number:
This course provides a comprehensive introduction to Java suitable for programmers with limited experience.
In addition to teaching the fundamentals needed to be productive in basic Java programming, this course provides a solid understanding of the core OO and Java concepts needed to create well designed Java programs. It covers all the key OO capabilities and how to use them in Java, including material on creating well-designed Java classes using encapsulation, building more complex functionality with composition and using inheritance to share functionality and create specialized types. It also covers more advanced concepts such as using interfaces, working with the Java Collections Framework and overviews of accessing databases with JDBC and JPA (including labs using JPA).
The course can be customized to fit your needs. Supported platforms include Java 8, Eclipse, Intellij, NetBeans and other IDEs upon request.
Audience:
Prerequisites:
Experience with Java programming is essential.
Course Number:
Audience:
Prerequisites:
At least 6 months of Java programming experience or a Java Bootcamp is required.
Click on the links below to view course outlines, pre-requisites, course length and course objectives.
Course Number:
Audience:
Prerequisites:
Students should complete an introductory Java class or have at least three months of Java programming experience before taking this course.
Course Outline Coming Soon!
Course Number:
Audience:
Prerequisites:
Students should complete an introductory Java class or have at least three months of Java programming experience before taking this course.
• Recognize what technologies are available in JEE
• Demonstrate understanding of web application file and packaging structure
• Understand and appreciate the role of Java Servlets in the overall Java Enterprise Edition architecture
• Use request and response objects provided to a servlet to read parameters and to produce an HTML response
• Develop interactive web applications using HTML forms and servlets
• Manage complex conversations with HTTP clients using session attributes
• Diagram and explain the differences in MVC and MVVM
• Create a RESTful web service in Java using JAX-RS
Course Number:
Java Enterprise Edition (Java EE 5) is a powerful platform for building web applications. The Java EE platform offers all the advantages of developing in Java plus a comprehensive suite of server-side technologies. This course tells students what they need to know to design and build their own web applications. Participants will explore details of the key Java EE technologies and how to leverage the strengths of each with special focus on Servlets and JSP. At the same time, they’ll learn about the big picture of Java EE and how to design web applications that are robust, efficient and maintainable. If you want to deliver an application on the web, you’ll find this course essential.
The course begins with a discussion of web application architecture. A major part of the course is spent on Servlets and JavaServer Pages (JSP) with special focus on using the JSTL. It then covers JDBC, Java’s database access technology. The course concludes with an introduction to EJB and other important Java EE technologies. Throughout the course, students will create code for a online store. Students will learn not only specific topics and APIs but also how to fit the pieces together into a complete application.
Audience:
Prerequisites:
Students should have an understanding of Java, Servlets, JSPs and EJBs.
Course Outline Coming Soon!
Course outline coming soon!
Course Number:
As part of the complete overhaul of the Enterprise JavaBeans (EJB) specification, database persistence was broken out into a completely separate specification, the Java Persistence API (JPA). JPA replaces entity beans with powerful new Object-Relational Mapping (ORM) capabilities based on proven technologies such as Toplink and Hibernate. This course includes all-important features from JPA 2 and is also suitable for users of the 1.0 release.
JPA supports a POJO (Plain Old Java Object)-based model using annotations, which lets you develop persistent classes following common Java idioms. It supports entity relationships, inheritance, polymorphism, composition and much more. The Java Persistence Query Language (JPQL), which is based on SQL but operates on the object model, provides a powerful bridge between the object and relational worlds. JPA also allows you to express queries using native SQL, including the capability to map the SQL query results to persistent entities.
Audience:
Prerequisites:
This course concisely covers everything you need to know to begin working with the Java Persistence API. All the important concepts necessary to access and update data stored in relational databases are reviewed and an extensive series of labs is included to exercise all major capabilities.
Prerequisites
Students should be proficient is OOP (Object-Oriented Programming) and Java.
Outline
Click on the links below to view course outlines, pre-requisites, course length and course objectives.
Course Outline Coming Soon!
Course Outline Coming Soon!
Course Outline Coming Soon!
Course Outline Coming Soon!
Course Outline Coming Soon!
Course Outline Coming Soon!
Course Outline Coming Soon!
Click on the links below to view course outlines, pre-requisites, course length and course objectives.
Course Outline Coming Soon!
Course Number:
Hibernate is an open source object/relational (OR) persistence and query service for Java. Hibernate lets you develop persistent classes following common Java idioms – including association, inheritance, polymorphism, composition and the Java collections framework.
The Hibernate Query Language designed as a minimal object-oriented extension to SQL, provides an elegant bridge between the object and relational worlds. Hibernate also allows you to express queries using native SQL or Java-based criteria and example queries.
Hibernate is now the most popular OR mapping solutions for Java, and it has become a de facto standard in Java OR mapping. JBoss has integrated Hibernate into its JEMS (Java Enterprise Middleware System) product line. The Java Persistence API (EJB 3) specification derives a great deal of its architecture from Hibernate, and the Hibernate annotations are compatible with the Java Persistence annotations. This promises to make Hibernate an even more important technology.
This course covers everything you need to know to begin working with Hibernate in a very short time. It covers all the important concepts necessary to access and update data stored in relational databases. It includes an extensive series of labs to exercise all major capabilities.
All labs are done with the Eclipse IDE. Lab instructions are also available for other major IDEs, such as IntelliJ IDEA.
Audience:
Prerequisites:
Intermediate knowledge of Java programming is required. Some familiarity with the Java Database Connectivity (JDBC) interfaces, relational databases and SQL is recommended.
Course Number:
Audience:
Prerequisites:
Click on the links below to view course outlines, pre-requisites, course length and course objectives.
Course Number:
Available in C++, C#, Java, Python and more!
This intense training experience takes a problem-solving approach to learning many of the 23 design patterns as noted in the book, “Design Patterns: Elements of Reusable Object-Oriented Software” by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides (GoF). Separated into 15 percent lecture and 85 percent hands-on labs, participants will possess a working knowledge of design patterns and their benefits upon completion of this course.
Audience:
Prerequisites:
Software developers who have been using the Java language for at least six months in a production environment.
Each of the 23 patterns will be discussed in its own section (choose 2 per day of training):
Course Number:
This Comprehensive Spring Boot bootcamp is focused on helping existing Java developers quickly build and manage Spring Boot based applications. Instead of taking a traditional approach to Java EE development with Spring, the program begins by jumping right into Spring Boot. Using a progressive learning format, each session builds on the prior session so that when the boot camp completes, an engineer will have learned how to build and test comprehensive Spring Boot services. Spring Cloud topics will also be introduced including the scaling of applications using Docker containerization
Audience:
Prerequisites:
Students should have a java background.
Spring Core XML Configuration
Annotation Configuration
Java Configuration
Spring MVC Primer (brief)
Spring Boot Basics
Spring Boot Externalize Configuration
Contollers and RestControllers
RestControllers and Content Negotiation
RestTemplate Clients
Spring Boot Actuators
Persistence Frameworks
Spring Cloud Introduction
Spring Security
Testing Services
