Book Image

Java 11 Cookbook - Second Edition

By : Nick Samoylov, Mohamed Sanaulla
Book Image

Java 11 Cookbook - Second Edition

By: Nick Samoylov, Mohamed Sanaulla

Overview of this book

For more than three decades, Java has been on the forefront of developing robust software that has helped versatile businesses meet their requirements. Being one of the most widely used programming languages in history, it’s imperative for Java developers to discover effective ways of using it in order to take full advantage of the power of the latest Java features. Java 11 Cookbook offers a range of software development solutions with simple and straightforward Java 11 code examples to help you build a modern software system. Starting with the installation of Java, each recipe addresses various problem by explaining the solution and offering insights into how it works. You’ll explore the new features added to Java 11 that will make your application modular, secure, and fast. The book contains recipes on functional programming, GUI programming, concurrent programming, and database programming in Java. You’ll also be taken through the new features introduced in JDK 18.3 and 18.9. By the end of this book, you’ll be equipped with the skills required to write robust, scalable, and optimal Java code effectively.

Related Content you might be interested in

Current Title:

Small book image
Java 11 Cookbook - Second Edition
Nick Samoylov | Mohamed Sanaulla
Sep, 2018 | 802 pages
Small book image
Introduction to Programming
Nick Samoylov
Jun, 2018 | 722 pages
Small book image
Learn Java 17 Programming
Nick Samoylov
Jul, 2022 | 748 pages
Small book image
Learn Java 12 Programming
Nick Samoylov
Apr, 2019 | 690 pages
Table of Contents (18 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Sections
Get in touch
Free Chapter
1
Installation and a Sneak Peek into Java 11
Installation and a Sneak Peek into Java 11
Introduction
Installing JDK 18.9 on Windows and setting up the PATH variable
Installing JDK 18.9 on Linux (Ubuntu, x64) and configuring the PATH variable
Compiling and running a Java application
What's new in Java 11?
Using application class-data sharing
2
Fast Track to OOP - Classes and Interfaces
Fast Track to OOP - Classes and Interfaces
Introduction
Implementing object-oriented design (OOD)
Using inner classes
Using inheritance and aggregation
Coding to an interface
Creating interfaces with default and static methods
Creating interfaces with private methods
A better way to work with nulls using Optional
Using the utility class Objects
3
Modular Programming
Modular Programming
Introduction
Using jdeps to find dependencies in a Java application
Creating a simple modular application
Creating a modular JAR
Using a module JAR with pre-Project Jigsaw JDK applications
Bottom-up migration
Top-down migration
Using services to create loose coupling between the consumer and provider modules
Creating a custom modular runtime image using jlink
Compiling for older platform versions
Creating multi-release JARs
Using Maven to develop a modular application
Making your library module-path-friendly
How to open a module for reflection
4
Going Functional
Going Functional
Introduction
Using standard functional interfaces
Creating a functional interface
Understanding lambda expressions
Using lambda expressions
Using method references
Leveraging lambda expressions in your programs
5
Streams and Pipelines
Streams and Pipelines
Introduction
Creating immutable collections using the of() and copyOf() factory methods
Creating and operating on streams
Using numeric streams for arithmetic operations
Completing streams by producing collections
Completing streams by producing maps
Completing streams by producing maps using grouping collectors
Creating stream operation pipeline
Processing streams in parallel
6
Database Programming
Database Programming
Introduction
Connecting to a database using JDBC
Setting up the tables required for DB interactions
Performing CRUD operations using JDBC
Using the Hikari Connection Pool (HikariCP)
Using prepared statements
Using transactions
Working with large objects
Executing stored procedures
Using batch operations for a large set of data
Using MyBatis for CRUD operations
Using the Java Persistence API and Hibernate
7
Concurrent and Multithreaded Programming
Concurrent and Multithreaded Programming
Introduction
Using the basic element of concurrency – thread
Different synchronization approaches
Immutability as a means of achieving concurrency
Using concurrent collections
Using the executor service to execute async tasks
Using fork/join to implement divide-and-conquer
Using flow to implement the publish-subscribe pattern
8
Better Management of the OS Process
Better Management of the OS Process
Introduction
Spawning a new process
Redirecting the process output and error streams to file
Changing the working directory of a subprocess
Setting the environment variable for a subprocess
Running shell scripts
Obtaining the process information of the current JVM
Obtaining the process information of the spawned process
Managing the spawned process
Enumerating live processes in the system
Connecting multiple processes using pipe
Managing subprocesses
9
RESTful Web Services Using Spring Boot
RESTful Web Services Using Spring Boot
Introduction
Creating a simple Spring Boot application
Interacting with the database
Creating a RESTful web service
Creating multiple profiles for Spring Boot
Deploying RESTful web services to Heroku
Containerizing the RESTful web service using Docker
Monitoring the Spring Boot 2 application using Micrometer and Prometheus
10
Networking
Networking
Introduction
Making an HTTP GET request
Making an HTTP POST request
Making an HTTP request for a protected resource
Making an asynchronous HTTP request
Making an HTTP request using Apache HttpClient
Making an HTTP request using the Unirest HTTP client library
11
Memory Management and Debugging
Memory Management and Debugging
Introduction
Understanding the G1 garbage collector
Unified logging for JVM
Using the jcmd command for the JVM
Try-with-resources for better resource handling
Stack walking for improved debugging
Using the memory-aware coding style
Best practices for better memory usage
Understanding Epsilon, a low-overhead garbage collector
12
The Read-Evaluate-Print Loop (REPL) Using JShell
The Read-Evaluate-Print Loop (REPL) Using JShell
Introduction
Getting familiar with REPL
Navigating JShell and its commands
Evaluating code snippets
Object-oriented programming in JShell
Saving and restoring the JShell command history
Using the JShell Java API
13
Working with New Date and Time APIs
Working with New Date and Time APIs
Introduction
How to work with time zone-independent date and time instances
How to construct time zone-dependent time instances
How to create a date-based period between date instances
How to create a time-based period between time instances
How to represent epoch time
How to manipulate date and time instances
How to compare date and time
How to work with different calendar systems
How to format dates using the DateTimeFormatter
14
Testing
Testing
Introduction
Behavioral testing using Cucumber
Unit testing of an API using JUnit
Unit testing by mocking dependencies
Using fixtures to populate data for testing
Integration testing
15
The New Way of Coding with Java 10 and Java 11
The New Way of Coding with Java 10 and Java 11
Introduction
Using local-variable type inference
Using local-variable syntax for lambda parameters
16
GUI Programming Using JavaFX
GUI Programming Using JavaFX
Introduction
Creating a GUI using JavaFX controls
Using the FXML markup to create a GUI
Using CSS to the style elements in JavaFX
Creating a bar chart
Creating a pie chart
Embedding HTML in an application
Embedding media in an application
Adding effects to controls
Using the Robot API
17
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Introduction

Modular programming enables one to organize code into independent, cohesive modules, which can be combined to achieve the desired functionality. This allows us to create code that is:

  • More cohesive, because the modules are built with a specific purpose, so the code that resides there tends to cater to that specific purpose.
  • Encapsulated, because modules can interact with only those APIs that have been made available by the other modules.
  • Reliable, because the discoverability is based on the modules and not on the individual types. This means that if a module is not present, the dependent module cannot be executed until it is discoverable by the dependent module. This helps to prevent runtime errors.
  • Loosely coupled. If you use service interfaces, the module interface and the service interface implementation can be loosely coupled. 

So, the thought process in designing and organizing the code will now involve identifying the modules, code, and configuration files that go into the...

Previous Section
End of Section 9
Next Section