Course Outline
Review
- Inheritance and Interfaces
- Object References vs. Inheritance
- Polymorphism
- Static and Default Methods in Interfaces
- Collections and Generics
- Generics: Inheritance and Wildcards
- Defining Generic Types
Design Patterns
- Object Creation
- Static Methods and Fields
- The new Operator
- Creation Patterns
- Inheritance vs. Composition: Pros and Cons
- Composite Pattern
- Inner Classes
Reflection
- The Class Class
- Finding Fields, Methods, and Constructors
- Accessing Fields and Invoking Methods
- Examining Arrays
Annotations
- 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 Basics
- JUnit Overview and Test-Driven Development
- Tests and Assertions
- Working With Exceptions
- Organizing Tests with JUnit
- Writing Fixtures: @Before and @After
- Test Suites and Additional Capabilities
- Overview of Mock Objects
Build Tools
- Ant Overview
- Maven Overview
Abstract Classes
- Principles of Declaration and Implementation for Abstract Classes
- Common Challenges Encountered When Working with Abstract Classes
The Role of Classes, Abstract Classes, and Interfaces in the Application Model
- Grasping Java’s Object-Oriented Abstraction
- Understanding the Complete Object Model in Java
- Designing Applications Oriented Toward Interfaces and Abstract Classes to Enhance Flexibility and Independence Among Sub-systems
- Leveraging Abstract Classes to Extract Common Functionality While Extending Flexibility Through Interfaces
The Role of Dynamic and Static Objects in the Application Model
- Static Java Classes and Their Dynamic Properties
- Distinguishing Functionality Between Static and Dynamic Entities in Java, Including Best Practices for Design Solutions Based on Both Types
- Introduction to Design Patterns
- Introduction to the Factory Design Pattern
Operations with Primitive Types and Wrapper Classes
- Essential Facts and Techniques for Extending the Use of Primitive Types Within Java’s Object Model
- Discussion of the Role of Wrapper Classes for Primitives and Their Typical Applications in Applications
Special Java Objects: String, StringBuilder, and StringBuffer
- Review of Basic String Class Properties and How the Virtual Machine Handles String Objects
- Using Buffer Classes and Manipulating Strings
Formatting, Parsing, and Regular Expressions
- Introduction to Regular Expressions in Java
- Discussion of Both Basic Techniques for Handling Regular Expressions (via the String class) and Advanced Techniques Using Dedicated Classes
- Tokenization, Search, and Pattern Matching for String Types
Requirements
-
A solid foundation in Java and Object-Oriented Programming (OOP) is required. Participants must be familiar with packages, control flow structures, loops, basic concrete classes, and fundamental interfaces.
Testimonials (4)
The patience with which he addressed the questions that arose
Carlos Ceballos - Banco de Mexico
Course - Spring Boot, React, and Redux
Machine Translated
Excellent topic, use cases, and examples to visualize the delivered material
Gionathan Rodriguez - CENTRO NETEC SPA
Course - Building Microservices with Spring Boot, Docker, and Kubernetes
Machine Translated
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
