book

Java

Name: Java
ISBN: 9781806118434

by Rheinwerk Publishing, Inc, Christian Ullenboom

June 2025

Intermediate to advanced

1129 pages

53h

English

Packt Publishing

Read now

Unlock full access

Dear Reader
Notes on Usage
Table of Contents
Preface
Target Group What This Book Is Not My Life and Java, Or “Why a Java Book?” Software and Versions Which Java Version to Use Using This Book to Learn Personal Learning Strategies Focusing on the Essentials Special Sections Tasks Structure of This Book Conventions Program Listings Application Programming Interface Documentation in This Book Executable Programs Acknowledgments Resources for This Book Feedback
1 Introduction
1.1 Historical Background
1.2 On the Popularity of Java: The Key Features
1.2.1 Bytecode1.2.2 Executing the Bytecode via a Virtual Machine1.2.3 Platform Independence1.2.4 Java as a Language, Runtime Environment, and Standard Library1.2.5 Object Orientation in Java1.2.6 Java Is Widespread and Well Known1.2.7 Java Is Fast: Optimization and Just-In-Time Compilation1.2.8 Pointers and References1.2.9 Take Out the Trash, Garbage Collector!1.2.10 Exception Handling1.2.11 The Range of Libraries and Tools1.2.12 Comparably Simple Syntax1.2.13 Abandoning Controversial Concepts1.2.14 Java Is Open Source1.2.15 What Java Is Less Suitable for
1.3 Java versus Other Languages*
1.3.1 Java and C(++)1.3.2 Java and JavaScript1.3.3 A Word about Microsoft, Java, and J++1.3.4 Java and C#/.NET
1.4 Further Development and Losses
1.4.1 The Development of Java and Its Future Prospects1.4.2 Features, Enhancements, and Specification Requests1.4.3 Applets1.4.4 JavaFX
1.5 Java Platforms
1.5.1 Java Platform, Standard Edition1.5.2 Java Platform, Micro Edition: Java for the Little Ones1.5.3 Java for the Very, Very Little Ones1.5.4 Java for the Big Ones: Jakarta EE (Formerly Java Platform, Enterprise Edition)1.5.5 Real-Time Java
1.6 Java Platform, Standard Edition, Implementations
1.6.1 OpenJDK1.6.2 Oracle JDK

1.7 Installing the Java Development Kit
1.7.1 Installing Oracle JDK on Windows
1.8 Compiling and Testing the First Program
1.8.1 A Square Numbers Program1.8.2 The Compiler Run1.8.3 The Runtime Environment1.8.4 Common Compiler and Interpreter Issues
1.9 Development Environments
1.9.1 IntelliJ IDEA1.9.2 Eclipse Integrated Development Environment1.9.3 NetBeans
1.10 Further Reading
2 Imperative Language Concepts
2.1 Elements of the Java Programming Language2.1.1 Tokens2.1.2 Text Encoding by Unicode Characters2.1.3 Identifiers2.1.4 Literals2.1.5 (Reserved) Keywords2.1.6 Summary of the Lexical Analysis2.1.7 Comments
2.2 From Classes to Statements
2.2.1 What Are Statements?2.2.2 Class Declaration2.2.3 The Journey Begins with main(String[])2.2.4 The First Method Call: println(...)2.2.5 Atomic Statements and Statement Sequences2.2.6 More about print(...), println(...), and printf(...) for Screen Output2.2.7 Application Programming Interface Documentation2.2.8 Expressions2.2.9 Expression Statements2.2.10 First Insights into Object Orientation2.2.11 Modifiers2.2.12 Grouping Statements with Blocks
2.3 Data Types, Typing, Variables, and Assignments
2.3.1 Overview of Primitive Data Types2.3.2 Variable Declarations2.3.3 Automatic Type Detection with var2.3.4 Final Variables and the final Modifier2.3.5 Console Inputs2.3.6 Truth Values2.3.7 Integer Data Types2.3.8 Underscores in Numbers2.3.9 Alphanumeric Characters2.3.10 The float and double Data Types2.3.11 Good Names, Bad Names2.3.12 No Automatic Initialization of Local Variables
2.4 Expressions, Operands, and Operators
2.4.1 Assignment Operator2.4.2 Arithmetic Operators2.4.3 Unary Minus and Plus2.4.4 Prefix or Postfix Increment and Decrement2.4.5 Assignment with Operation (Compound Assignment Operator)2.4.6 Relational Operators and Equality Operators2.4.7 Logical Operators: NOT, AND, OR, and XOR2.4.8 Short-Circuit Operators2.4.9 The Rank of Operators in Evaluation Order2.4.10 Typecasting (Casting )2.4.11 Overloaded Plus for Strings2.4.12 Operators Missing*
2.5 Conditional Statements or Case Distinctions
2.5.1 Branching with the if Statement2.5.2 Choosing the Alternative with an if-else Statement2.5.3 The Condition Operator2.5.4 The Switch Statement Provides an Alternative2.5.5 Switch Expressions
2.6 Always the Same with Loops
2.6.1 The while Loop2.6.2 The do-while Loop2.6.3 The for Loop2.6.4 Loop Conditions and Comparisons with ==*2.6.5 Loop Termination with break and back to Test with continue2.6.6 break and continue with Labels*
2.7 Methods of a Class
2.7.1 Components of a Method2.7.2 Signature Description in the Java Application Programming Interface Documentation2.7.3 Calling a Method2.7.4 Declaring Methods without Parameters2.7.5 Static Methods (Class Methods )2.7.6 Parameters, Arguments, and Value Transfers2.7.7 Ending Methods Prematurely with return2.7.8 Unreachable Source Code for Methods*2.7.9 Methods with Returns2.7.10 Overloading Methods2.7.11 Scope2.7.12 Default Values for Unlisted Arguments*2.7.13 Recursive Methods*2.7.14 Towers of Hanoi*
2.8 Further Reading
3 Classes and Objects
3.1 Object-Oriented Programming3.1.1 Why Object-Oriented Programming at All?3.1.2 When I Think of Java, I Think of Reusability
3.2 Members of a Class
3.3 Natural Modeling Using Unified Modeling Language*
3.4 Creating New Objects
3.4.1 Creating an Instance of a Class Using the new Keyword3.4.2 Declaring Reference Variables3.4.3 Let’s Get to the Point: Accessing Object Variables and Methods3.4.4 The Connection between new, the Heap, and the Garbage Collector3.4.5 Overview of Point Methods3.4.6 Using Constructors
3.5 ZZZZZnake
3.6 Tying Packages, Imports, and Compilation Units
3.6.1 Java Packages3.6.2 Packages in the Standard Library3.6.3 Full Qualification and Import Declaration3.6.4 Reaching All Types of a Package with Type-Import-on-Demand3.6.5 Hierarchical Structures across Packages and Mirroring in the File System3.6.6 The Package Declaration3.6.7 Unnamed Package (Default Package)3.6.8 Compilation Unit3.6.9 Static Import*
3.7 Using References, Diversity, Identity, and Equality
3.7.1 null References and the Question of Philosophy3.7.2 Everything to null? Testing References3.7.3 Assignments with References3.7.4 Methods with Reference Types as Parameters3.7.5 Identity of Objects3.7.6 Equivalence and the equals(...) Method
3.8 Further Reading
4 Arrays and Their Areas of Use
4.1 Simple Field Work4.1.1 Basic Components4.1.2 Declaring Array Variables4.1.3 Creating Array Objects with new4.1.4 Arrays with { contents }4.1.5 Reading the Length of an Array via the Object Variable Length4.1.6 Accessing the Elements via the Index4.1.7 Typical Array Errors4.1.8 Passing Arrays to Methods4.1.9 Multiple Return Values*4.1.10 Preinitialized Arrays
4.2 The Extended for Loop
4.2.1 Using Anonymous Arrays in the Extended for Loop4.2.2 Example: Searching Arrays with Strings4.2.3 Creating Random Player Positions
4.3 A Method with a Variable Number of Arguments
4.3.1 System.out.printf(...) Accepts Any Number of Arguments4.3.2 Finding the Average of Variable Arguments4.3.3 Vararg Design Tips*
4.4 Multidimensional Arrays*
4.4.1 Nonrectangular Arrays*
4.5 Library Support for Arrays
4.5.1 Cloning Can Be Worthwhile: Propagating Arrays4.5.2 Why Can Arrays “Do” So Little?4.5.3 Copying Array Contents
4.6 Using the Arrays Class for Comparing, Filling, Searching, and Sorting
4.6.1 String Representation of an Array4.6.2 Sorting4.6.3 Parallel Sorting4.6.4 Comparing Arrays of Primitives with Arrays.equals(...) and Arrays.deepEquals(...)*4.6.5 Comparing Object Arrays Using Arrays.equals(...) and Arrays.deepEquals(...)*4.6.6 Searching Differences Using Mismatch (...)*4.6.7 Filling Arrays*4.6.8 Copying Array Sections*4.6.9 Binary Search*4.6.10 Lexicographic Array Comparisons Using compare(...) and compareUnsigned(...)4.6.11 Arrays for Lists with Arrays.asList(...): Convenient for Searching and Comparing*4.6.12 A Long Snake
4.7 The Entry Point for the Runtime System: main(...)
4.7.1 Correct Declaration of the Start Method4.7.2 Processing Command Line Arguments4.7.3 The Return Type of main(...) and System.exit(int)*
4.8 Further Reading
5 Handling Characters and Strings
5.1 From ASCII via ISO-8859-1 to Unicode5.1.1 ASCII5.1.2 ISO/IEC 8859-15.1.3 Unicode5.1.4 Unicode Character Encoding5.1.5 Escape Sequences5.1.6 Notation for Unicode Characters and Unicode Escapes5.1.7 Java Versions Go Hand in Hand with the Unicode Standard*
5.2 Data Types for Characters and Strings
5.3 The Character Class
5.3.1 Is That So?5.3.2 Converting Characters to Uppercase/Lowercase5.3.3 From Character to String5.3.4 From char to int: From Character to Number*
5.4 Strings
5.5 The String Class and Its Methods
5.5.1 String Literals as String Objects for Constant Strings5.5.2 Concatenation with +5.5.3 Multiline Text Blocks with “””5.5.4 String Length and Testing for Empty Strings5.5.5 Accessing a Specific Character with charAt(int)5.5.6 Searching for Contained Characters and Strings5.5.7 The Hangman Game5.5.8 Good That We Have Compared5.5.9 Extracting String Sections5.5.10 Appending Strings, Merging Strings, Case Sensitivity, and Whitespace5.5.11 Searched, Found, and Replaced5.5.12 Creating String Objects with Constructors and from Repeats*
5.6 Mutable Strings with StringBuilder and StringBuffer
5.6.1 Creating StringBuilder Objects5.6.2 Converting StringBuilder to Other String Formats5.6.3 Requesting Characters or Strings5.6.4 Appending Data5.6.5 Setting, Deleting, and Reversing Characters and Strings5.6.6 Length and Capacity of a StringBuilder Object*5.6.7 Comparison of StringBuilder Instances and Strings with StringBuilder5.6.8 hashCode() with StringBuilder*
5.7 CharSequence as Base Type
5.7.1 Basic Operations of the Interface5.7.2 Static compare(...) Method in CharSequence5.7.3 Default Methods in the CharSequence Interface*
5.8 Converting Primitives and Strings
5.8.1 Converting Different Types to String Representations5.8.2 Converting String Contents to a Primitive Value5.8.3 String Representation in Binary, Hex, and Octal Formats*5.8.4 parse*(...) and print*() Methods in DatatypeConverter*
5.9 Concatenating Strings
5.9.1 Concatenating Strings with StringJoiner
5.10 Decomposing Strings
5.10.1 Splitting Strings via split(...)5.10.2 Yes We Can, Yes We Scan: The Scanner Class
5.11 Formatting Outputs
5.11.1 Formatting and Outputting via format()
5.12 Further Reading
6 Writing Custom Classes
6.1 Declaring Custom Classes with Members6.1.1 Minimum Class6.1.2 Declaring Object Variables6.1.3 Declaring Methods6.1.4 Shadowed Variables6.1.5 The this Reference
6.2 Privacy and Visibility
6.2.1 For the Public: public6.2.2 Not Public: Passwords Are private6.2.3 Why Not Free Methods and Variables for All?6.2.4 private Is Not Quite Private: It Depends on Who Sees It*6.2.5 Declaring Access Methods for Object Variables6.2.6 Setters and Getters according to the JavaBeans Specification6.2.7 Package-Visibility6.2.8 Visibility Summary
6.3 One for All: Static Methods and Class Variables
6.3.1 Why Static Members Are Useful6.3.2 Static Members with static6.3.3 Using Static Members via References?*6.3.4 Why Case Sensitivity Is Important*6.3.5 Static Variables for Data Exchange*6.3.6 Static Members and Object Members*
6.4 Constants and Enumerations
6.4.1 Constants via Static Final Variables6.4.2 Type-Unsafe Enumerations6.4.3 Enumeration Types: Type-Safe Enumerations with enum
6.5 Creating and Destroying Objects
6.5.1 Writing Constructors6.5.2 Relationship of Method and Constructor6.5.3 The Default Constructor6.5.4 Parameterized and Overloaded Constructors6.5.5 Copy Constructors6.5.6 Calling Another Constructor of the Same Class via this(...)6.5.7 Immutable Objects and Wither Methods6.5.8 We Don’t Miss You: The Garbage Collector
6.6 Class and Object Initialization*
6.6.1 Initializing Object Variables6.6.2 Static Blocks as Class Initializers6.6.3 Initializing Class Variables6.6.4 Compiled Assignments of the Class Variables6.6.5 Instance Initializer6.6.6 Setting Final Values in the Constructor and Static Blocks
6.7 Conclusion
7 Object-Oriented Relationship
7.1 Associations between Objects7.1.1 Association Types7.1.2 Unidirectional 1-to-1 Relationship7.1.3 Becoming Friends: Bidirectional 1-to-1 Relationships7.1.4 Unidirectional 1-to-n Relationships
7.2 Inheritance
7.2.1 Inheritance in Java7.2.2 Modeling Events7.2.3 The Implicit Base Class java.lang.Object7.2.4 Single and Multiple Inheritance*7.2.5 Do Children See Everything? The Protected Visibility7.2.6 Constructors in Inheritance and super(...)
7.3 Types in Hierarchies
7.3.1 Automatic and Explicit Typecasting7.3.2 The Substitution Principle7.3.3 Testing Types with the instanceof Operator7.3.4 Pattern Matching for instanceof
7.4 Overriding Methods
7.4.1 Providing Methods in Subclasses with a New Behavior7.4.2 With super to the Parents
7.5 Testing Dynamic Bindings
7.5.1 Bound to toString()7.5.2 Implementing System.out.println(Object)
7.6 Final Classes and Final Methods
7.6.1 Final Classes7.6.2 Non-Overridable (final) Methods
7.7 Abstract Classes and Abstract Methods
7.7.1 Abstract Classes7.7.2 Abstract Methods
7.8 Further Information on Overriding and Dynamic Binding
7.8.1 No Dynamic Binding for Private, Static, and final Methods7.8.2 Covariant Return Types7.8.3 Array Types and Covariance*7.8.4 Dynamic Binding even with Constructor Calls*7.8.5 No Dynamic Binding for Covered Object Variables*
7.9 A Programming Task
8 Interfaces, Enumerations, Sealed Classes, Records
8.1 Interfaces8.1.1 Interfaces Are New Types8.1.2 Declaring Interfaces8.1.3 Abstract Methods in Interfaces8.1.4 Implementing Interfaces8.1.5 A Polymorphism Example with Interfaces8.1.6 Multiple Inheritance with Interfaces8.1.7 No Risk of Collision with Multiple Inheritance*8.1.8 Extending Interfaces: Subinterfaces8.1.9 Constant Declarations for Interfaces8.1.10 Subsequent Implementation of Interfaces*8.1.11 Static Programmed Methods in Interfaces8.1.12 Extending and Modifying Interfaces8.1.13 Default Methods8.1.14 Declaring and Using Extended Interfaces8.1.15 Public and Private Interface Methods8.1.16 Extended Interfaces, Multiple Inheritance, and Ambiguities*8.1.17 Creating Building Blocks with Default Methods*8.1.18 Marker Interfaces*8.1.19 (Abstract) Classes and Interfaces in Comparison
8.2 Enumeration Types
8.2.1 Methods on Enum Objects8.2.2 Enumerations with Custom Methods, Constructors, and Initializers*
8.3 Sealed Classes and Interfaces
8.3.1 Sealed Classes and Interfaces8.3.2 Subclasses Are Final, Sealed, and Non-Sealed8.3.3 Abbreviated Notations
8.4 Records
8.4.1 Simple Records8.4.2 Records with Methods8.4.3 Customizing Record Constructors8.4.4 Adding Constructors8.4.5 Sealed Interfaces and Records8.4.6 Records: Summary
9 There Must Be Exceptions
9.1 Fencing In Problem Areas9.1.1 Exceptions in Java with try and catch9.1.2 Checked and Unchecked Exceptions9.1.3 A NumberFormatException (Unchecked Exception)9.1.4 Appending a Date/Timestamp to a Text File (Checked Exception)9.1.5 Repeating Canceled Sections*9.1.6 Empty catch Blocks9.1.7 Catching Multiple Exceptions9.1.8 Combining Identical catch Blocks with Multi-Catch
9.2 Redirecting Exceptions and throws at the Head of Methods/Constructors
9.2.1 throws in Constructors and Methods
9.3 The Class Hierarchy of Exceptions
9.3.1 Members of the Exception Object9.3.2 Base Type Throwable9.3.3 The Exception Hierarchy9.3.4 Catching Super-Exceptions9.3.5 Already Caught?9.3.6 Procedure of an Exceptional Situation9.3.7 No General Catching!9.3.8 Known RuntimeException Classes9.3.9 Interception Is Possible, but Not Mandatory
9.4 Final Handling Using finally
9.4.1 The Ignorant Version9.4.2 The Well-Intentioned Attempt9.4.3 From Now On, Closing Is Part of the Agenda9.4.4 Summary9.4.5 A try without a catch, but a try-finally
9.5 Triggering Custom Exceptions
9.5.1 Triggering Exceptions via throw9.5.2 Knowing and Using Existing Runtime Exception Types9.5.3 Testing Parameters and Good Error Messages9.5.4 Declaring New Exception Classes9.5.5 Custom Exceptions as Subclasses of Exception or RuntimeException?9.5.6 Catching and Redirecting Exceptions*9.5.7 Changing the Call Stack of Exceptions*9.5.8 Nested Exceptions*
9.6 try with Resources (Automatic Resource Management)
9.6.1 try with Resources9.6.2 The AutoCloseable Interface9.6.3 Exceptions to close()9.6.4 Types That Are AutoCloseable and Closeable9.6.5 Using Multiple Resources9.6.6 Suppressed Exceptions*
9.7 Special Features of Exception Handling*
9.7.1 Return Values for Thrown Exceptions9.7.2 Exceptions and Returns Disappear: The Duo return and finally9.7.3 throws on Overridden Methods9.7.4 Unreachable catch Clauses
9.8 Hard Errors: Error*
9.9 Assertions*
9.9.1 Using Assertions in Custom Programs9.9.2 Enabling Assertions and Runtime Errors9.9.3 Enabling or Disabling Assertions More Detailed
9.10 Conclusion
10 Nested Types
10.1 Nested Classes, Interfaces, and Enumerations
10.2 Static Nested Types
10.2.1 Modifiers and Visibility10.2.2 Records as Containers10.2.3 Implementing Static Nested Types*
10.3 Non-Static Nested Types
10.3.1 Creating Instances of Inner Classes10.3.2 The this Reference10.3.3 Class Files Generated by the Compiler*
10.4 Local Classes
10.4.1 Example with a Custom Declaration10.4.2 Using a Local Class for a Timer
10.5 Anonymous Inner Classes
10.5.1 Using an Anonymous Inner Class for the Timer10.5.2 Implementing Anonymous Inner Classes*10.5.3 Constructors of Anonymous Inner Classes10.5.4 Accessing Local Variables from Local and Anonymous Classes*10.5.5 Nested Classes Access Private Members
10.6 Nests
10.7 Conclusion
11 Special Types of Java SE
11.1 Object Is the Mother of All Classes11.1.1 Class Objects11.1.2 Object Identification with toString()11.1.3 Object Equivalence with equals(...) and Identity11.1.4 Cloning an Object Using clone()*11.1.5 Returning Hash Values via hashCode()*11.1.6 System.identityHashCode(...) and the Problem of Non-Unique Object References*11.1.7 Synchronization*
11.2 Weak References and Cleaners
11.3 The java.util.Objects Utility Class
11.3.1 Built-In Null Tests for equals(...)/hashCode()11.3.2 Objects.toString(…)11.3.3 null Checks with Built-In Exception Handling11.3.4 Tests for null11.3.5 Checking Index-Related Program Arguments for Correctness
11.4 Comparing Objects and Establishing Order
11.4.1 Naturally Ordered or Not?11.4.2 compare*() Method of the Comparable and Comparator Interfaces11.4.3 Return Values Encode the Order11.4.4 Sorting Candy by Calories Using a Sample Comparator11.4.5 Tips for Comparator and Comparable Implementations11.4.6 Static and Default Methods in Comparator
11.5 Wrapper Classes and Autoboxing
11.5.1 Creating Wrapper Objects11.5.2 Conversions to a String Representation11.5.3 Parsing from a String Representation11.5.4 The Number Base Class for Numeric Wrapper Objects11.5.5 Performing Comparisons with compare*(...), compareTo(...), equals(...), and Hash Values11.5.6 Static Reduction Methods in Wrapper Classes11.5.7 Constants for the Size of a Primitive Type*11.5.8 Handling Unsigned Numbers*11.5.9 The Integer and Long Classes11.5.10 The Double and Float Classes for Floats11.5.11 The Boolean Class11.5.12 Autoboxing: Boxing and Unboxing
11.6 Iterator, Iterable*
11.6.1 The Iterator Interface11.6.2 The Supplier of the Iterator11.6.3 The Iterable Interface11.6.4 Extended for and Iterable11.6.5 Internal Iteration11.6.6 Implementing a Custom Iterable*
11.7 Annotations in Java Platform, Standard Edition
11.7.1 Places for Annotations11.7.2 Annotation Types from java.lang11.7.3 @Deprecated11.7.4 Annotations with Additional Information11.7.5 @SuppressWarnings
11.8 Further Reading
12 Generics<T>
12.1 Introduction to Java Generics12.1.1 Man versus Machine: Type Checking of the Compiler and the Runtime Environment12.1.2 Rockets12.1.3 Declaring Generic Types12.1.4 Using Generics12.1.5 Diamonds Are Forever12.1.6 Generic Interfaces12.1.7 Generic Methods/Constructors and Type Inference
12.2 Implementing Generics, Type Erasure, and Raw Types
12.2.1 Implementation Options12.2.2 Type Erasure12.2.3 Problems with Type Erasure12.2.4 Raw Types
12.3 Restricting Types via Bounds
12.3.1 Simple Restrictions with extends12.3.2 Other Supertypes with &
12.4 Type Parameters in the throws Clause*
12.4.1 Declaring a Class with Type Variable <E extends Exception>12.4.2 Parameterized Type for Type Variable <E extends Exception>
12.5 Inheritance and Invariance with Generics
12.5.1 Arrays Are Covariant12.5.2 Generics Aren’t Covariant, but Invariant12.5.3 Wildcards with ?12.5.4 Bounded Wildcards12.5.5 Bounded Wildcard Types and Bounded Type Variables12.5.6 The PECS Principle
12.6 Consequences of Type Erasure: Type Tokens, Arrays*
12.6.1 Type Tokens12.6.2 Supertype Tokens12.6.3 Generics and Arrays
12.7 Further Reading
13 Lambda Expressions and Functional Programming
13.1 Functional Interfaces and Lambda Expressions13.1.1 Classes Implement Interfaces13.1.2 Lambda Expressions Implement Interfaces13.1.3 Functional Interfaces13.1.4 The Type of a Lambda Expression Depends on the Target Type13.1.5 @FunctionalInterface Annotations13.1.6 Syntax for Lambda Expressions13.1.7 The Environment of Lambda Expressions and Variable Accesses13.1.8 Exceptions in Lambda Expressions13.1.9 Classes with an Abstract Method as a Functional Interface?*
13.2 Method References
13.2.1 Motivation13.2.2 Method References with ::13.2.3 Variations of Method References
13.3 Constructor References
13.3.1 Writing Constructor References13.3.2 Parameterless and Parameterized Constructors13.3.3 Useful Predefined Interfaces for Constructor References
13.4 Functional Programming
13.4.1 Code = Data13.4.2 Programming Paradigms: Imperative or Declarative13.4.3 Principles of Functional Programming13.4.4 Imperative Programming and Functional Programming13.4.5 Comparator as an Example of Higher-Order Functions13.4.6 Viewing Lambda Expressions as Mappings or Functions
13.5 Functional Interfaces from the java.util.function Package
13.5.1 Blocks with Code and the Functional Interface Consumer13.5.2 Supplier13.5.3 Predicates and java.util.function.Predicate13.5.4 Functions via the Functional Interface java.util.function.Function13.5.5 I Take Two13.5.6 Functional Interfaces with Primitives
13.6 Optional Is Not a Non-Starter
13.6.1 Using null13.6.2 The Optional Type13.6.3 Starting Functional Interfaces with Optional13.6.4 Primitive-Optional with Special Optional* Classes
13.7 What Is So Functional Now?
13.7.1 Recyclability13.7.2 Stateless, Immutable
13.8 Further Reading
14 Architecture, Design, and Applied Object Orientation
14.1 SOLID Modeling14.1.1 Three Rules14.1.2 SOLID14.1.3 Don’t Be STUPID
14.2 Architecture, Design, and Implementation
14.3 Design Patterns
14.3.1 Motivation for Design Patterns14.3.2 Singleton14.3.3 Factory Methods14.3.4 Implementing the Observer Pattern with Listeners
14.4 Further Reading
15 Java Platform Module System
15.1 Class Loader and Module/Classpath15.1.1 Loading Classes per Request15.1.2 Watching the Class Loader at Work15.1.3 JMOD Files and JAR Files15.1.4 Where the Classes Come from: Search Locations and Special Class Loaders15.1.5 Setting the Search Path
15.2 Importing Modules
15.2.1 Who Sees Whom?15.2.2 Platform Modules and a JMOD Example15.2.3 Using Internal Platform Features: --add-exports15.2.4 Integrating New Modules
15.3 Developing Custom Modules
15.3.1 Module com.tutego.candytester15.3.2 Module Declaration with module-info.java and Exports15.3.3 Module com.tutego.main15.3.4 Module info File with requires15.3.5 Writing Module Inserters: Java Virtual Machine Switches -p and -m15.3.6 Experiments with the Module Info File15.3.7 Automatic Modules15.3.8 Unnamed Modules15.3.9 Readability and Accessibility15.3.10 Module Migration
15.4 Further Reading
16 The Class Library
16.1 The Java Class Philosophy16.1.1 Modules, Packages, and Types16.1.2 Overview of the Packages of the Standard Library
16.2 Simple Time Measurement and Profiling*
16.2.1 Profilers
16.3 The Class Class
16.3.1 Obtaining a Class Object16.3.2 A Class Is a Type
16.4 The Utility Classes System and Members
16.4.1 Memory of the Java Virtual Machine16.4.2 Number of CPUs or Cores16.4.3 System Properties of the Java Environment16.4.4 Setting Custom Properties from the Console*16.4.5 Newline Characters and line.separator16.4.6 Environment Variables of the Operating System
16.5 The Languages of Different Countries
16.5.1 Regional Languages via Locale Objects
16.6 Overview of Important Date Classes
16.6.1 Unix Time: January 1, 197016.6.2 System.currentTimeMillis()16.6.3 Simple Time Conversions via TimeUnit
16.7 Date-Time API
16.7.1 Initial Overview16.7.2 Human Time and Machine Time16.7.3 The LocalDate Date Class
16.8 Logging with Java
16.8.1 Logging Application Programming Interfaces16.8.2 Logging with java.util.logging
16.9 Maven: Resolving Build Management and Dependencies
16.9.1 Dependency to Be Accepted16.9.2 Local and the Remote Repository16.9.3 Lifecycles, Stages, and Maven Plugins
16.10 Further Reading
17 Introduction to Concurrent Programming
17.1 Concurrency and Parallelism17.1.1 Multitasking, Processes, and Threads17.1.2 Threads and Processes17.1.3 How Concurrent Programs Can Increase Speed17.1.4 How Java Can Provide for Concurrency
17.2 Generating Existing Threads and New Threads
17.2.1 Main Thread17.2.2 Who Am I?17.2.3 Implementing the Runnable Interface17.2.4 Starting Thread with Runnable17.2.5 Parameterizing Runnable17.2.6 Extending the Thread Class*
17.3 Thread Members and States
17.3.1 The Name of a Thread17.3.2 The States of a Thread*17.3.3 Sleepers Wanted17.3.4 When Threads Are Finished17.3.5 Terminating a Thread Politely Using Interrupts17.3.6 Unhandled Exceptions, Thread End, and UncaughtExceptionHandler17.3.7 The stop() from the Outside and the Rescue with ThreadDeath*17.3.8 Stopping and Resuming the Work*17.3.9 Priority*
17.4 Enter the Executor
17.4.1 The Executor Interface17.4.2 Happy as a Group: The Thread Pools17.4.3 Threads with return via Callable17.4.4 Memories of the Future: The Future Return17.4.5 Processing Multiple Callable Objects17.4.6 CompletionService and ExecutorCompletionService17.4.7 ScheduledExecutorService: Repetitive Tasks and Time Controls17.4.8 Asynchronous Programming with CompletableFuture (CompletionStage)
17.5 Further Reading
18 Introduction to Data Structures and Algorithms
18.1 Lists18.1.1 First List Example18.1.2 Selection Criterion ArrayList or LinkedList18.1.3 The List Interface18.1.4 ArrayList18.1.5 LinkedList18.1.6 The Array Adapter Arrays.asList(...)18.1.7 ListIterator*18.1.8 Understanding toArray(...) of Collection: Recognizing Traps18.1.9 Managing Primitive Elements in Data Structures
18.2 Sets
18.2.1 A First Example of a Set18.2.2 Methods of the Set Interface18.2.3 HashSet18.2.4 TreeSet: The Sorted Set18.2.5 The Interfaces NavigableSet and SortedSet18.2.6 LinkedHashSet
18.3 Associative Memory
18.3.1 The HashMap and TreeMap Classes and Static Map Methods18.3.2 Inserting and Querying the Associative Memory
18.4 The Stream API
18.4.1 Declarative Programming18.4.2 Internal versus External Iteration18.4.3 What Is a Stream?
18.5 Creating a Stream
18.5.1 Stream.of*(…)18.5.2 Stream.generate(…)18.5.3 Stream.iterate(…)18.5.4 Parallel or Sequential Streams
18.6 Terminal Operations
18.6.1 Number of Elements18.6.2 And Now All: forEach*(…)18.6.3 Getting Individual Elements from the Stream18.6.4 Existence Tests with Predicates18.6.5 Reducing a Stream to Its Smallest or Largest Element18.6.6 Reducing a Stream with Its Own Functions18.6.7 Writing Results to a Container, Part 1: collect(...)18.6.8 Writing Results to a Container, Part 2: Collector and Collectors18.6.9 Writing Results to a Container, Part 3: Groupings18.6.10 Transferring Stream Elements to an Array or an Iterator
18.7 Intermediary Operations
18.7.1 Element Previews18.7.2 Filtering Elements18.7.3 Stateful Intermediary Operations18.7.4 Prefix Operations18.7.5 Transformation
18.8 Further Reading
19 Files and Data Streams
19.1 Old and New Worlds in java.io and java.nio19.1.1 java.io Package with the File Class19.1.2 NIO.2 and the java.nio Package
19.2 File Systems and Paths
19.2.1 FileSystem and Path19.2.2 The Files Utility Class
19.3 Random Access Files
19.3.1 Opening a RandomAccessFile for Reading and Writing19.3.2 Reading from RandomAccessFile19.3.3 Writing with RandomAccessFile19.3.4 The Length of the RandomAccessFile19.3.5 Back and Forth within the File
19.4 Base Classes for Input/Output
19.4.1 The Four Abstract Base Classes19.4.2 The Abstract Base Class OutputStream19.4.3 The Abstract Base Class InputStream19.4.4 The Abstract Base Class Writer19.4.5 The Appendable Interface*19.4.6 The Abstract Base Class Reader19.4.7 The Interfaces Closeable, AutoCloseable, and Flushable
19.5 Reading from Files and Writing to Files
19.5.1 Obtaining Byte-Oriented Data Streams via Files19.5.2 Obtaining Character-Oriented Data Streams via Files19.5.3 The Function of OpenOption in the Files.new*(...) Methods19.5.4 Loading Resources from the Module Path and from JAR Files
19.6 Further Reading
20 Introduction to Database Management with JDBC
20.1 Relational Databases and Java Access20.1.1 The Relational Model20.1.2 Java Application Programming Interfaces for Accessing Relational Databases20.1.3 The JDBC API and Implementations: The JDBC Driver20.1.4 H2 Is the Tool in Java
20.2 A Sample Query
20.2.1 Steps to Query the Database20.2.2 Accessing the Relational Database with Java
20.3 Further Reading
21 Bits and Bytes, Mathematics and Money
21.1 Bits and Bytes21.1.1 The Bit Operators: Complement, AND, OR, and XOR21.1.2 Representation of Integers in Java: Two’s Complement21.1.3 The Binary, Octal, and Hexadecimal Place Value Systems21.1.4 Effect of Typecasting on Bit Patterns21.1.5 Working without Signs21.1.6 The Shift Operators21.1.7 Setting, Clearing, Reversing, and Testing a Bit21.1.8 Bit Methods of the Integer and Long Classes
21.2 Floating Point Arithmetic in Java
21.2.1 Special Values for Infinity, Zero, and Not a Number21.2.2 Standard Notation and Scientific Notation for Floats*21.2.3 Mantissas and Exponents*
21.3 The Members of the Math Class
21.3.1 Object Variables of the Math Class21.3.2 Absolute Values and Signs21.3.3 Maximums /Minimums21.3.4 Rounding Values21.3.5 Remainder of an Integer Division*21.3.6 Division with Rounding toward Negative Infinity and Alternative Remainders*21.3.7 Multiply-Accumulate21.3.8 Square Root and Exponential Methods21.3.9 The Logarithm*21.3.10 Angle Methods*21.3.11 Random Numbers
21.4 Accuracy and the Value Range of Type and Overflow Control*
21.4.1 The Largest and Smallest Values21.4.2 Overflow and Everything Entirely Exact21.4.3 What in the World Does the ulp Method Do?
21.5 Random Numbers: Random, ThreadLocalRandom, and SecureRandom
21.5.1 The Random Class21.5.2 ThreadLocalRandom21.5.3 The SecureRandom Class*
21.6 Large Numbers*
21.6.1 The BigInteger Class21.6.2 Example: Quite Long Factorials with BigInteger21.6.3 Large Floats with BigDecimal21.6.4 Conveniently Setting the Calculation Accuracy via MathContext21.6.5 Calculating even Faster with Mutable Implementations
21.7 Money and Currency
21.7.1 Representing Amounts of Money21.7.2 ISO 421721.7.3 Representing Currencies in Java
21.8 Further Reading
22 Testing with JUnit
22.1 Software Tests22.1.1 Procedure for Writing Test Cases
22.2 The JUnit Testing Framework
22.2.1 JUnit Versions22.2.2 Integrating JUnit22.2.3 Test-Driven Development and the Test-First Approach22.2.4 Test, Implement, Test, Implement, Test, Rejoice22.2.5 Running JUnit Tests22.2.6 assert*(...) Methods of the Assertions Class22.2.7 Testing Exceptions22.2.8 Setting Limits for Execution Times22.2.9 Labels with @DisplayName22.2.10 Nested Tests22.2.11 Ignoring Tests22.2.12 Canceling Tests with Methods of the Assumptions Class22.2.13 Parameterized Tests
22.3 Java Assertion Libraries and AssertJ
22.3.1 AssertJ
22.4 Structure of Large Test Cases
22.4.1 Fixtures22.4.2 Collections of Test Classes and Class Organization
22.5 Good Design Enables Effective Testing
22.6 Dummy, Fake, Stub, and Mock
22.7 JUnit Extensions and Testing Add-Ons
22.7.1 Web Tests22.7.2 Testing the Database Interface
22.8 Further Reading
23 The Tools of the JDK
23.1 Overview23.1.1 Structure and Common Switches
23.2 Translating Java Sources
23.2.1 The Java Compiler of the Java Development Kit23.2.2 Native Compilers
23.3 The Java Runtime Environment
23.3.1 Switches of the Java Virtual Machine23.3.2 The Difference between java.exe and javaw.exe
23.4 Documentation Comments with Javadoc
23.4.1 Setting a Documentation Comment23.4.2 Creating Documentation with the javadoc Tool23.4.3 HTML Tags in Documentation Comments*23.4.4 Generated Files23.4.5 Documentation Comments at a Glance*23.4.6 Javadoc and Doclets*23.4.7 Deprecated Types and Members23.4.8 Javadoc Verification with DocLint
23.5 The JAR Archive Format
23.5.1 Using the jar Utility23.5.2 The Manifest23.5.3 Launching Applications in Java Archives: Executable JAR Files
23.6 Further Reading
Index
Service Pages
Legal Notes

Content preview from Java

10.5 Anonymous Inner Classes

Anonymous classes go one step further than local classes: These inner classes have no names and always automatically create an object; class declaration and object creation are combined into one language construct. The general notation is as follows:

new 
            ClassOrInterface() { /* Members of the inner class */ }

New methods and object variables can be declared, and methods can be overridden in the block of curly brackets. new is followed by the name of a class or interface, with the following options:

new Class name ( Optional Arguments ) { ... }: If new is followed by a class type, then the anonymous class is a subclass of Class name . Possible arguments for the constructor of the base class can be specified ...

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

Publisher Resources

ISBN: 9781806118434

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills