Thank you for sending your enquiry! One of our team members will contact you shortly.
Thank you for sending your booking! One of our team members will contact you shortly.
Course Outline
Core Concepts Review
- Inheritance and Interfaces
- Object References vs. Inheritance
- Polymorphism
- Interface Static and Default Methods
- Collections and Generics
- Advanced Generics (Inheritance, Wildcards)
- Implementing Generic Types
Design Patterns
- Object Creation Techniques
- Static Methods and Fields
- The 'new' Operator
- Creational Patterns
- Inheritance vs. Composition: Pros and Cons
- The Composite Pattern
- Inner Classes
Reflection
- The 'Class' Class
- Discovering Fields, Methods, and Constructors
- Accessing Fields and Invoking Methods
- Examining Arrays
Annotations
- Standard Java API Annotations (e.g., @Override, @Deprecated)
- Defining Custom Annotations
Functional Programming
- Overview of Lambda Expressions
- Lambda Expressions and Functional Interfaces
- Practical Use of Lambda Expressions
- Working with Method References
The Stream API
- Streams and Collections
- Filtering Collections
- Chaining and Pipelining Operations
Date/Time API
- Legacy APIs
- The Date/Time API (JSR 310)
- Date-Based and Time-Based Events
- Timestamps, Periods, and Durations
- Performing Calculations
- Formatting
- Localization and Time Zones
JUnit Fundamentals
- JUnit Overview and Test-Driven Development
- Tests and Assertions
- Handling Exceptions in Tests
- Organizing Tests with JUnit
- Creating Fixtures with @Before and @After
- Test Suites and Additional Features
- Overview of Mock Objects
Build Tools
- Overview of Ant
- Overview of Maven
Abstract Classes
- Principles of Declaration and Implementation for Abstract Classes
- Common Challenges When Working with Abstract Classes
The Role of Classes, Abstract Classes, and Interfaces in the Application Model
- Grades of Java Object-Oriented Abstraction
- The Complete Object Model in Java
- Designing applications with interfaces and abstract classes to enhance flexibility and subsystem independence
- Utilizing abstract classes to extract shared functionality while leveraging the flexibility offered by interfaces
The Role of Static and Dynamic Elements in the Application Model
- Static Java Classes and Their Dynamic Properties
- Differentiating Functionality Between Static and Dynamic Entities: Typical Uses and Best Practices
- Introduction to Design Patterns
- Introduction to the Factory Design Pattern
Operations with Primitive Types and Wrapper Classes
- Key Facts and Techniques for Extending the Use of Primitive Types within the Java Object Model
- The Role of Wrapper Classes for Primitive Types and Their Typical Application Scenarios
Special Java Objects: String, StringBuilder, and StringBuffer
- Review of String Class Properties and How the Virtual Machine Handles String Objects
- Using Buffer Classes and Manipulating String Chains
Formatting, Parsing, and Regular Expressions
- Introduction to Regular Expressions in Java
- Discussion of Basic Techniques for Handling Regular Expressions (String Class) and Advanced Methods Using Dedicated Classes
- Tokenization, Search, and Pattern Matching for String Types
Requirements
-
Foundational knowledge of Java and Object-Oriented Programming (OOP). Participants should be familiar with packages, control flow statements, loops, basic concrete classes, and fundamental interfaces.
21 Hours
Testimonials (3)
That we got a complex overview also about the context - for example why do we need some annotations and what they mean. I liked the practical part of the training - having to manually run the commands and call the rest api's
Alina - ACCENTURE SERVICES S.R.L
Course - Quarkus for Developers
interaction through exercises and also projects sharing
Claudiu - MSG system
Course - Advanced Spring Boot
The extra information that was shared, the training was not straightforward groovy, which was nice.
