Course Overview:
Intensive and hands-on, the course emphasizes becoming productive quickly as a Java application developer. This course quickly covers the Java language syntax and then moves into the object-oriented features of the language. As a participant you will be able to create basic applications using the Java 8 programming language.
The participants will also be able to describe object-oriented concepts, object-oriented programming (OOP) concepts, and Java platforms and technologies. This course will use Eclipse as an IDE.
Course Objectives:
Participants will learn how to:
- Write, compile and execute Java programs
- Build robust applications using Java’s object-oriented features
- Create robust applications using Java class libraries
Pre-requisites:
- The course assumes knowledge of programming.
Target Audience:
This course is meant for programmers who wish to move to object-oriented programming using Java. This course is designed for participants who are looking for an entry into an application development or a software project management career using Java technologies.
Course Duration:
- 35 hours – 5 days
Course Content:
Day 1
- Programming Concepts
- What is Programming
- Components of a Programming Language
- Programming Paradigms
- What is Java
- The Object-Oriented Paradigm and Java
- Writing Java Programs
- What is a Java Program
- Writing the Source Code
- Compiling the Source Code
- Running the Compiled Code
- Installing and configuring Eclipse IDE
- Downloading and Installing Maven
- Testing Maven Installation
- Data Types
- What is a Data Types
- What is an Identifier
- Data Types in Java
- Primitive Data Types in Java
- Special Floating-Point Numbers
- Rounding Modes
- Number Objects
- String Objects
- Format data for output
- Operators
- What is an Operator
- Assignment Operator
- Arithmetic Operators
- String Concatenation Operator
- Relational Operators
- Boolean Logical Operators
- Statements
- What is a Statement and Type of Statements
- A Block Statement
- The if-else Statement
- The switch Statement
- Strings in Switch
- The for Statement
- The for-each Statement
- The while Statement
- The do-while Statement
- The break Statement
- The continue Statement
- Diamond Syntax
Day 2
- Classes and Objects
- What is a Class
- Declaring Fields in a Class
- Creating Instances of a Class
- The null Reference Type
- Using Dot Notation to Access Fields of a Class
- Default Initialization of Fields
- Access Level Modifiers for a Class
- Import Declaration
- Declaring Methods of a Class
- Local Variables
- Instance Method and Class Method
- Invoking a Method
- Access Level for Class Members
- The Object and Objects Classes
- The Object Class
- What is the Class of an Object
- Computing Hash Code of an Object
- Comparing Objects for Equality
- String Representation of an Object
- Cloning Object
- Finalizing an Object
- Immutable Objects
- Java Package
- Package declaration
- Sub-Packages in Java
- Naming Convention
- Importing Java Package
- Access Modifier
- Java Archive (JAR) Files
- Wrapper Classes
- Wrapper Classes
- Autoboxing and Unboxing
- Beware of Null Values
- Overloaded Methods
- Comparison Operators
- Collectionsc
- Exception Handling
- What is an Exception
- Using a try-catch Block
- Exception Class Hierarchy
- Arranging Multiple catch Blocks
- Throwing an Exception
- Creating an Exception Class
- The finally Block
- The try-with-resources Block
- Multi-Catch Exceptions
- Re-throwing Exceptions
- Try with Resources
- AutoCloseable Interface
- Assertions
- What is an Assertions
- Testing Assertions
- Enabling / Disabling Assertions
- Using Assertions
Day 3
- Strings
- What is a String
- String Literals
- Creating String Objects
- String Operators
- Comparing Two Strings
- StringBuilder and StringBuffer
- Dates and Times
- The Date-Time API
- Calendar Systems
- Clocks and Period Packages
- Period between Two Dates and Times
- Partials
- Formatting Dates and Times
- Parsing Dates and Times
- Formatting Data
- Wrapper Classes
- Autoboxing and Unboxing
- Beware of Null Values
- Overloaded Methods
- Comparison Operators
- Arrays
- What is an Array
- Arrays are Objects
- Accessing Array Elements
- Length of an Array
- Multi-Dimensional Arrays
- Enhanced for Loop for Arrays
- Runtime Array Bounds Check
- Inheritance
- What is Inheritance
- The instanceof Operator
- Binding
- Method Overriding and Method Overloading
- Method Hiding and Field Hiding
- Disabling Inheritance
- Interfaces
- What is an Interface
- Implementing an Interface
- Implementing Multiple Interfaces
- Interface Inheritance
- The instanceof Operator
- Marker Interfaces
- Functional Interfaces
- Polymorphism – One Object, May Views
- Dynamic Binding and Interfaces
- Core Collection Classes
- The Collections Framework
- The Set Interface
- Set Implementation Classes
- The List Interface
- List Implementation Classes
- The Map Interface
- Map Implementation Classes
Day 4
- Pluggable Annotation Processing API
- Common Annotations and Role Based Annotations
- @Generated
- @Resource
- @Resources
- @PostConstruct
- @PreDestroy
- @DeclareRoles
- @RolesAllowed
- @PermitAll
- @DenyAll
- Java API for XML Based Web Services – 2.0
- JAXB 2.0
- Web Services Metadata
- Streaming API for XML
- XML Digital Signature
- Java Class File Specification Update
- Java Compiler API
- JDBC 4.0
- Setting up MySQL Database
- Auto loading of Driver by JVM
- Standard Connection Factory Management
- Enhanced Connection and Statement Interface
- Inserting Data
- New interface RowID to support the ROWID data type
- Updating Data
- Deleting Data
- Use of Annotated SQL queries
- Creating prepared statements
- Calling stored procedure
- Lambda Expressions
- Single method Interface
- Anonymous Interface Implementation
- Lambda Type Inference
- Lambda Parameters
- Lambda Function Body
- Returning a Value
- Lambdas as Objects
- Variable Capture
- Method References as Lambdas
- Java Stream API for Bulk Data Operations on Collections
- Introduction
- Stream Creation
- Referencing a Stream
- Stream Pipeline
- Lazy Invocation
- Order of Execution
- Stream Reduction
- Parallel Streams
- Java Date / Time API
- Issues with existing Date / Time APIs
- LocalDate, LocalTime and LocalDateTime
- Using ZonedDateTime API
- Using Period and Duration
- Compatibility with Date and Calendar
- Date and Time Formatting
- Concurrency API improvements
- The Concurrency API
- Semaphore and Other Synchronizers
- Concurrent Collections
- Atomic Operations
- Executor and ExecutorService
- Thread Pools
- Parallel Processing
- Reflection
- Uses for Meta-Data
- The Reflection API
- The Class<T> Class
- The java.lang.reflect Package
- Reading Type Information
- Navigating Inheritance Trees
- Dynamic Instantiation
- Dynamic Invocation
- Reflecting on Generics
Day 5
- Getting Started With Maven
- Terminology and Basic Concepts
- Artifacts
- Lifecycle
- Plugins
- Running Maven
- Running Maven from Eclipse
- Common Goals
- Commonly Used Plugins
- Maven Plugins
- Declaring and Configuring Plugins
- Running the Plugin
- Binding a Plugin Goal to the Lifecycle
- Maven Surefire Test Plugin
- Failsafe Plugin
- Site Plugin
- JavaDoc Plugin
- PMD Plugin
- Multi-Module Builds
- Introduction
- The Reactor
- Reactor Sorting
- Multi-Module Build by Example
- POM Projects
- Project Object Model (POM)
- The overall POM structure
- Storing POM
- What is Maven Plugin
- Example of Using a Plugin
- Create a Custom Plugin
- Create a Custom Plugin (cont.)
- Plugin Management
- Creating Archetypes
- Introduction to Maven Archetypes
- Introduction to Maven Archetypes (cont.)
- Using Interactive Mode to generate Goal
- Common Maven Archetypes
- Repository Management
- Maven’s Approach to Artifacts
- Publishing Artifacts
- Summary of Maven’s Artifact Handling
- Repository
- Repository Manager
- Proxy Remote Repositories
- Types of Artifacts
- Release Artifacts
- Snapshot Artifacts
- Reasons to Use a Repository Manager
- Repository Coordinates
- Addressing Resources in a Repository
