book

The Java Workshop

Name: The Java Workshop
ISBN: 9781838986698

by David Cuartielles, Pradeep Kumar Gupta, Scott Cosentino, Andreas Göransson, Eric Foster-Johnson, Avinash Kate

October 2019

Beginner

606 pages

10h 37m

English

Packt Publishing

Read now

Unlock full access

Preface
About the BookAbout the ChaptersConventionsBefore You BeginInstallation of JREInstallation of JDKInstallation of IntelliJ IDEAInstalling the Code Bundle
1. Getting Started
IntroductionWriting, Compiling, and Executing Your Hello World ProgramExercise 1: Creating Your Hello World Program in JavaBasic Syntax and Naming ConventionsPrinting Out Different Data TypesVariables and Variable TypesExercise 2: Printing Different Types of DataPrimitive versus Reference Data TypesNullChars and StringsExercise 3: Declaring StringsDoing Some MathExercise 4: Solving a Simple Trigonometry ProblemComments Help You to Share CodeCLI versus GUIExercise 5: Running the Code from the CLIActivity 1: Obtaining the Minimum of Two NumbersSummary
2. Learning the Basics
IntroductionControlling the Flow of Your ProgramsExercise 1: Creating a Basic if StatementComparison OperatorsExercise 2: Using Java Comparison OperatorsNested if StatementsExercise 3: Implementing a Nested if StatementBranching Two Ways with if and elseExercise 4: Using if and else StatementsUsing Complex ConditionalsExercise 5: Using Logical Operators to Create Complex ConditionalsUsing Arithmetic Operators in an if ConditionThe Ternary OperatorExercise 6: Using the Ternary OperatorEquality Can Be TrickyExercise 7: Comparing Decimal ValuesComparing StringsUsing switch StatementsExercise 8: Using switchExercise 9: Allowing Cases to Fall ThroughUsing Java 12 Enhanced switch StatementsExercise 10: Using Java 12 switch StatementsLooping and Performing Repetitive TasksLooping with the for LoopExercise 11: Using a Classic for LoopExercise 12: Using an Enhanced for LoopJumping Out of Loops with Break and ContinueExercise 13: Using break and continueUsing the while LoopExercise 14: Using a while LoopUsing the do-while LoopHandling Command-Line ArgumentsExercise 15: Testing Command-Line ArgumentsConverting Command-Line ArgumentsExercise 16: Converting String to Integers and DoublesDiving Deeper into Variables — ImmutabilityComparing Final and ImmutableUsing Static ValuesUsing Local Variable Type InferenceActivity 1: Taking Input and Comparing RangesSummary
3. Object-Oriented Programming
IntroductionThe Anatomy of a ClassWorking with Objects in JavaChecking the Precedence of a Class with instanceofExercise 1: Creating the WordTool ClassActivity 1: Adding the Frequency-of-Symbol Calculation to WordToolInheritance in JavaOverriding and Hiding MethodsAvoiding Overriding: Final Classes and MethodsOverloading Methods and ConstructorsRecursionAnnotationsInterfacesInner ClassesDocumenting with JavaDocActivity 2: Adding Documentation to WordToolSummary
4. Collections, Lists and Java's Built-In APIs
IntroductionArraysActivity 1: Searching for Multiple Occurrences in an ArraySetsListsExercise 1: Creating the AnalyzeInput ApplicationMapsIterating through CollectionsExercise 2: Bringing Analytics into the AnalyzeInput ApplicationSorting CollectionsExercise 3: Sort the Results from the AnalyzeInput ApplicationPropertiesActivity 2: Iterating through Large ListsSummary
5. Exceptions
IntroductionA Simple Exception ExampleNullPointerException – Have No FearCatching ExceptionsExercise 1: Logging ExceptionsThrows and ThrowExercise 2: Breaking the Law (and Fixing It)The finally BlockActivity 1: Designing an Exception Class Logging DataBest Practices for Handling ExceptionsWhere Do Exceptions Come from?Summary
6. Libraries, Packages, and Modules
IntroductionOrganizing Code into PackagesImporting ClassesExercise 1: Importing ClassesFully Qualified Class NamesImporting All Classes in a PackageDealing with Duplicated NamesStatic ImportsCreating a PackageNaming Your PackageDirectories and PackagesExercise 2: Creating a Package for a Fitness Tracking AppBuilding JAR FilesExercise 3: Building a JAR FileDefining the ManifestExercise 4: Building an Executable JAR FileBuild ToolsMavenExercise 5: Creating a Maven ProjectExercise 6: Adding Java Sources to the Maven ProjectExercise 7: Building the Maven ProjectExercise 8: Creating an Executable JAR with MavenUsing GradleExercise 9: Creating a Gradle ProjectExercise 10: Building an Executable JAR with GradleUsing Third-Party LibrariesFinding the LibrariesAdding a Project DependencyExercise 11: Adding a Third-Party Library DependencyUsing the Apache Commons Lang LibraryExercise 12: Using the Apache Commons Lang LibraryUsing ModulesCreating ModulesExercise 13: Creating a Project for a ModuleExercise 14: Creating a Second Module Using the First OneActivity 1: Tracking Summer High TemperaturesSummary
7. Databases and JDBC
IntroductionRelational DatabasesRelational Database Management SystemsInstalling a DatabaseExercise 1: Running the H2 DatabaseIntroducing SQLExercise 2: Creating the customer TableInserting Data into a TableExercise 3: Inserting DataRetrieving DataRelating TablesExercise 4: Creating the email TableSelecting Data from Multiple TablesModifying Existing RowsExercise 5: Modifying email DataDeleting DataJDBC—Accessing Databases from JavaConnecting to DatabasesQuerying Data with JDBCExercise 6: Querying Data with JDBCSanitizing User InputUsing Prepared StatementsTransactions and RollbackExercise 7: Using Prepared Statements with TransactionsSimplifying JDBC ProgrammingUsing Object-Relational Mapping SoftwareDatabase Connection PoolingNon-Relational, or NoSQL, DatabasesActivity 1: Track Your ProgressSummary
8. Sockets, Files, and Streams
IntroductionListing Files and DirectoriesSeparating Directories from FilesExercise 1: Listing the Contents of SubdirectoriesCreating and Writing to a FileActivity 1: Writing the Directory Structure to a FileReading an Existing FileReading a Properties FileExercise 2: Creating a Properties File from the CLIWhat are Streams?The Different Streams of the Java LanguageWhat are Sockets?Creating a SocketServerWriting Data on and Reading Data from a SocketActivity 2: Improving the EchoServer and EchoClient ProgramsBlocking and Non-Blocking CallsSummary
9. Working with HTTP
IntroductionExploring HTTPHTTP Request MethodsRepresentational State TransferRequest HeadersUsing HttpUrlConnectionExercise 1: Creating a HEAD RequestReading the Response Data with a GET RequestExercise 2: Creating a GET RequestDealing with Slow ConnectionsRequesting ParametersHandling RedirectsCreating HTTP POST RequestsExercise 3: Sending JSON Data with POST RequestsParsing HTML DataExercise 4: Using jsoup to Extract Data from HTMLDelving into the java.net.http ModuleExercise 5: Getting HTML Contents Using the java.net.http ModuleActivity 1: Using the jsoup Library to Download Files from the WebSummary

10. Encryption
IntroductionPlaintextCiphertextCiphersKeysSymmetric Key EncryptionExercise 1: Encrypting the String Using Advanced Encryption StandardBlock CiphersInitialization VectorsStream CiphersAsymmetric Key EncryptionExercise 2: Encrypting the String Using the RSA Asymmetric Key EncryptionEncrypting FilesExercise 3: Encrypting a FileSummary
11. Processes
IntroductionLaunching a ProcessSending Input to a Child ProcessCapturing the Output of a Child ProcessStoring the Output of a Child Process in a FileActivity 1: Making a Parent Process to Launch a Child ProcessSummary
12. Regular Expressions
IntroductionDecrypting Regular ExpressionsCharacter ClassesCharacter SetsQuantifiersAnchorsCapturing GroupsEscaped CharactersFlagsExercise 1: Implementing Regular Expressions Activity 1: Regular Expressions to Check If the Entrance is Entered in the Desired FormatRegular Expressions in JavaExercise 2: Extracting the Domain Using Pattern MatchingExercise 3: Extracting Links Using Pattern MatchingSummary
13. Functional Programming with Lambda Expressions
IntroductionBackgroundFunctional ProgrammingSide EffectsDeterministic FunctionsPure FunctionsExercise 1: Writing Pure Functions Immutability of StateExercise 2: Creating an Immutable ClassActivity 1: Modifying Immutable ListsImmutable CollectionsExercise 3: Overriding the String MethodFunctional InterfacesLambda ExpressionsExercise 4: Listing Spare TiresSummary
14. Recursion
IntroductionDelving into RecursionExercise 1: Using Recursion to Overflow the StackTrying Tail RecursionExercise 2: Using Recursion to Calculate FactorialsProcessing an XML DocumentExercise 3: Creating an XML FileIntroducing the DOM XML APIExercise 4: Traversing an XML DocumentActivity 1: Calculating the Fibonacci SequenceSummary
15. Processing Data with Streams
IntroductionCreating StreamsParallel StreamsEncounter OrderClosing StreamsTerminal OperationsIntermediate OperationsExercise 1: Using the Stream APIActivity 1: Applying Discount on the ItemsUsing CollectorsI/O StreamsExercise 2: Converting CSV to a ListActivity 2: Searching for SpecificsSummary
16. Predicates and Other Functional Interfaces
IntroductionPredicate InterfaceExercise 1: Defining a predicateActivity 1: Toggling the Sensor StatesConsumer InterfaceExercise 2: Producing Side EffectsFunctionExercise 3: Extracting DataActivity 2: Using a Recursive FunctionActivity 3: Using a Lambda FunctionSummary
17. Reactive Programming with Java Flow
IntroductionPublisherSubmissionPublisherSubscriberSubscriptionExercise 1: A Simple Application with a Single Publisher and a Single SubscriberProcessorExercise 2: Using a Processor to Convert a Stream of Strings to NumbersActivity 1: Let NumberProcessor Format Values as IntegersSummary
18. Unit Testing
IntroductionGetting Started with Unit TestsIntroducing JUnitWriting Unit Tests with JUnitExercise 1: Writing a First Unit TestExercise 2: Writing a Successful TestDeciding What to TestWriting Parameterized TestsExercise 3: Writing a Parameterized TestWhen Tests Won't Work—Disabling TestsTest SetupExercise 4: Using Test Setup and Cleanup MethodsMockingTesting with Mocks Using MockitoExercise 5: Using Mocks when TestingActivity 1: Counting the Words in the StringSummary
Appendix
1. Getting StartedActivity 1: Obtaining the Minimum of Two Numbers2. Learning the BasicsActivity 1: Taking Input and Comparing Ranges3. Object-Oriented ProgrammingActivity 1: Adding the Frequency-of-Symbol Calculation to WordToolActivity 2: Adding Documentation to WordTool4. Collections, List, and Java's Built-In APIsActivity 1: Searching for Multiple Occurrences in an ArrayActivity 2: Iterating through Large Lists5. ExceptionsActivity 1: Designing an Exception Class Logging Data6. Libraries, Packages, and ModulesActivity 1: Tracking Summer High Temperatures7. Databases and JDBCActivity 1: Track Your Progress8. Sockets, Files, and StreamsActivity 1: Writing the Directory Structure to a FileActivity 2: Improving the EchoServer and EchoClient Programs9. Working with HTTPActivity 1: Using the jsoup Library to Download Files from the Web11. ProcessesActivity 1: Making a Parent Process to Launch a Child Process12. Regular ExpressionsActivity 1: Regular Expressions to Check If the Entrance is Entered in the Desired Format13. Functional Programming with Lambda ExpressionsActivity 1: Modifying Immutable Lists14. RecursionActivity 1: Calculating the Fibonacci Sequence15. Processing Data with StreamsActivity 1: Applying Discount on the ItemsActivity 2: Searching for Specifics16. Predicates and Other Functional InterfacesActivity 1: Toggling the Sensor StatesActivity 2: Using a Recursive FunctionActivity 3: Using a Lambda Function17. Reactive Programming with Java FlowActivity 1: Let NumberProcessor Format Values as Integers18. Unit TestingActivity 1: Counting the Words in the String
What Next?
The JavaScript WorkshopThe Clojure WorkshopThe Go WorkshopPlease leave a review

Content preview from The Java Workshop

3. Object-Oriented Programming

Overview

In this chapter, we will consider the way in which Java implements object-oriented programming (OOP) concepts. For these purposes, you will first practice creating and instantiating your own classes so that you can later create methods that can handle data within them. We will then take you through how to code recursive methods, and even how to override existing methods in favor of your own. By the end of the chapter, you will be fully equipped to overload the definition of methods in order to accommodate different scenarios with different parameters to the same method or constructor, and annotate code to inform the compiler about specific actions that must be taken.

Introduction

A Java class is ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Java Projects - Second Edition

Peter Verhas

Java 9 Programming By Example

Peter Verhas

JavaFX 8: Introduction by Example, Second Edition

Carl Dea, Mark Heckler, Gerrit Grunwald, José Pereda, Sean M. Phillips

The JavaScript Workshop

Joseph Labrecque, Jahred Love, Daniel Rosenbaum, Nick Turner, Gaurav Mehla, Alonzo L. Hosford, Florian Sloot, Philip Kirkbride, Christer Johansson, Peter Lyons Kehl, Andrew Artajos, Shubham Shrivastava, Lior Avital, Archit Goyal, Gavin Orland, David Parker, Dixit Patel, Tarunkumar Bagmar

Publisher Resources

ISBN: 9781838986698

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

The Java Workshop

by David Cuartielles, Pradeep Kumar Gupta, Scott Cosentino, Andreas Göransson, Eric Foster-Johnson, Avinash Kate

3. Object-Oriented Programming

Introduction

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.