Categories
Bibliography Java Software Engineering

Java Quick Syntax Reference, by Mikael Olsson

See also Java Programming Language, Java Glossary, Java Bibliography, Java Reference materials

Java Quick Syntax Reference, 2nd Edition, by Mikael Olsson, 2018, B079BKJ6CB (JvQSynRf)

Fair Use Source: B079BKJ6CB (JvQSynRf)

About This Book:

Quickly gain the insight necessary to address a multitude of Java coding challenges using this succinct reference guide. Short, focused code examples will help you master Java elements such as modules, boxing/unboxing and more.

You won’t find any technical jargon, bloated samples, drawn out history lessons or witty stories in this book. What you will find is a language reference that is concise, to the point and highly accessible. The book is packed with useful information and is a must-have for any Java programmer.

What You Will Learn

  • Code with Java modules
  • Box/unbox 
  • Utilize exception handling

Who This Book Is For

Those with prior experience with Java who want a quick and handy reference. 

About the Author:

Mikael Olsson is a professional web entrepreneur, programmer, and author. He works for an R&D company in Finland where he specializes in software development. In his spare time he writes books and creates websites that summarize various fields of interest. The books he writes are focused on teaching their subject in the most efficient way possible, by explaining only what is relevant and practical without any unnecessary repetition or theory. The portal to his online businesses and other websites is Siforia.com.

Book Details:

  • ASIN : B079BKJ6CB
  • Publisher : Apress; 2nd edition (January 25, 2018)
  • Publication date : January 25, 2018
  • Print length : 113 pages

Table of Contents:

  1. Cover
  2. Front Matter
  3. 1. Hello World
  4. 2. Compile and Run
  5. 3. Variables
  6. 4. Operators
  7. 5. String
  8. 6. Arrays
  9. 7. Conditionals
  10. 8. Loops
  11. 9. Methods
  12. 10. Class
  13. 11. Static
  14. 12. Inheritance
  15. 13. Overriding
  16. 14. Packages and Import
  17. 15. Access Levels
  18. 16. Constants
  19. 17. Interface
  20. 18. Abstract
  21. 19. Enum
  22. 20. Exception Handling
  23. 21. Boxing and Unboxing
  24. 22. Generics
  25. 23. Lambda Expressions
  26. Back Matter

Sources:

Fair Use Sources:

Cover image
Categories
Bibliography Java Software Engineering

Effective Java, by Joshua Bloch

See also Java Programming Language, Java Glossary, Java Bibliography, Java Reference materials

See: Effective Java, 3rd Edition, by Joshua Bloch, 2017, B078H61SCH (EftJav)

Fair Use Source: B078H61SCH (EftJav)

About This Book:

Java has changed dramatically since the previous edition of Effective Java was published shortly after the release of Java 6. This Jolt award-winning classic has now been thoroughly updated to take full advantage of the latest language and library features. The support in modern Java for multiple paradigms increases the need for specific best-practices advice, and this book delivers.

As in previous editions, each chapter of Effective Java, Third Edition, consists of several “items,” each presented in the form of a short, stand-alone essay that provides specific advice, insight into Java platform subtleties, and updated code examples. The comprehensive descriptions and explanations for each item illuminate what to do, what not to do, and why.

The third edition covers language and library features added in Java 7, 8, and 9, including the functional programming constructs that were added to its object-oriented roots. Many new items have been added, including a chapter devoted to lambdas and streams.

New coverage includes

  • Functional interfaces, lambda expressions, method references, and streams
  • Default and static methods in interfaces
  • Type inference, including the diamond operator for generic types
  • The @SafeVarargs annotation
  • The try-with-resources statement
  • New library features such as the Optional interface, java.time, and the convenience factory methods for collections

About the Author:

Joshua Bloch is a professor at Carnegie Mellon University. He was formerly the chief Java architect at Google, a distinguished engineer at Sun Microsystems, and a senior systems designer at Transarc. He led the design and implementation of numerous Java platform features, including the JDK 5.0 language enhancements and the Java Collections Framework. He holds a Ph.D. in computer science from Carnegie Mellon University and a B.S. in computer science from Columbia University.

Book Details:

  • ASIN : B078H61SCH
  • Publisher : Addison-Wesley Professional; 3rd edition (December 18, 2017)
  • Publication date : December 18, 2017
  • Print length : 414 pages

Table of Contents:

Table of Contents

1 Introduction

2 Creating and Destroying Objects

  1. Item 1: Consider static factory methods instead of constructors
  2. Item 2: Consider a builder when faced with many constructor parameters
  3. Item 3: Enforce the singleton property with a private constructor or an enum type
  4. Item 4: Enforce noninstantiability with a private constructor
  5. Item 5: Prefer dependency injection to hardwiring resources
  6. Item 6: Avoid creating unnecessary objects
  7. Item 7: Eliminate obsolete object references
  8. Item 8: Avoid finalizers and cleaners
  9. Item 9: Prefer try-with-resources to try-finally

3 Methods Common to All Objects

  1. Item 10: Obey the general contract when overriding equals
  2. Item 11: Always override hashCode when you override equals
  3. Item 12: Always override toString
  4. Item 13: Override clone judiciously
  5. Item 14: Consider implementing Comparable

4 Classes and Interfaces

  1. Item 15: Minimize the accessibility of classes and members
  2. Item 16: In public classes, use accessor methods, not public fields
  3. Item 17: Minimize mutability
  4. Item 18: Favor composition over inheritance
  5. Item 19: Design and document for inheritance or else prohibit it
  6. Item 20: Prefer interfaces to abstract classes
  7. Item 21: Design interfaces for posterity
  8. Item 22: Use interfaces only to define types
  9. Item 23: Prefer class hierarchies to tagged classes
  10. Item 24: Favor static member classes over nonstatic
  11. Item 25: Limit source files to a single top-level class

5 Generics

  1. Item 26: Don’t use raw types
  2. Item 27: Eliminate unchecked warnings
  3. Item 28: Prefer lists to arrays
  4. Item 29: Favor generic types
  5. Item 30: Favor generic methods
  6. Item 31: Use bounded wildcards to increase API flexibility
  7. Item 32: Combine generics and varargs judiciously
  8. Item 33: Consider typesafe heterogeneous containers

6 Enums and Annotations

  1. Item 34: Use enums instead of int constants
  2. Item 35: Use instance fields instead of ordinals
  3. Item 36: Use EnumSet instead of bit fields
  4. Item 37: Use EnumMap instead of ordinal indexing
  5. Item 38: Emulate extensible enums with interfaces
  6. Item 39: Prefer annotations to naming patterns
  7. Item 40: Consistently use the Override annotation
  8. Item 41: Use marker interfaces to define types

7 Lambdas and Streams

  1. Item 42: Prefer lambdas to anonymous classes
  2. Item 43: Prefer method references to lambdas
  3. Item 44: Favor the use of standard functional interfaces
  4. Item 45: Use streams judiciously
  5. Item 46: Prefer side-effect-free functions in streams
  6. Item 47: Prefer Collection to Stream as a return type
  7. Item 48: Use caution when making streams parallel

8 Methods

  1. Item 49: Check parameters for validity
  2. Item 50: Make defensive copies when needed
  3. Item 51: Design method signatures carefully
  4. Item 52: Use overloading judiciously
  5. Item 53: Use varargs judiciously
  6. Item 54: Return empty collections or arrays, not nulls
  7. Item 55: Return optionals judiciously
  8. Item 56: Write doc comments for all exposed API elements

9 General Programming

  1. Item 57: Minimize the scope of local variables
  2. Item 58: Prefer for-each loops to traditional for loops
  3. Item 59: Know and use the libraries
  4. Item 60: Avoid float and double if exact answers are required
  5. Item 61: Prefer primitive types to boxed primitives
  6. Item 62: Avoid strings where other types are more appropriate
  7. Item 63: Beware the performance of string concatenation
  8. Item 64: Refer to objects by their interfaces
  9. Item 65: Prefer interfaces to reflection
  10. Item 66: Use native methods judiciously
  11. Item 67: Optimize judiciously
  12. Item 68: Adhere to generally accepted naming conventions

10 Exceptions

  1. Item 69: Use exceptions only for exceptional conditions
  2. Item 70: Use checked exceptions for recoverable conditions and runtime exceptions for programming errors
  3. Item 71: Avoid unnecessary use of checked exceptions
  4. Item 72: Favor the use of standard exceptions
  5. Item 73: Throw exceptions appropriate to the abstraction
  6. Item 74: Document all exceptions thrown by each method
  7. Item 75: Include failure-capture information in detail messages
  8. Item 76: Strive for failure atomicity
  9. Item 77: Don’t ignore exceptions

11 Concurrency

  1. Item 78: Synchronize access to shared mutable data
  2. Item 79: Avoid excessive synchronization
  3. Item 80: Prefer executors, tasks, and streams to threads
  4. Item 81: Prefer concurrency utilities to wait and notify
  5. Item 82: Document thread safety
  6. Item 83: Use lazy initialization judiciously
  7. Item 84: Don’t depend on the thread scheduler

12 Serialization

  1. Item 85: Prefer alternatives to Java serialization
  2. Item 86: Implement Serializable with great caution
  3. Item 87: Consider using a custom serialized form
  4. Item 88: Write readObject methods defensively
  5. Item 89: For instance control, prefer enum types to readResolve
  6. Item 90: Consider serialization proxies instead of serialized instances

Items Corresponding to Second Edition

References

Index

Code Snippets

Sources:

Fair Use Sources:

Categories
Bibliography Java Software Engineering

Core Java – Volume II – Advanced Features, by Cay S. Horstmann

See also Core Java – Volume I – Fundamentals, Java Programming Language, Java Glossary, Java Bibliography, Java Reference materials

See: Core Java – Volume II – Advanced Features, 11th Edition, by Cay S. Horstmann, 2019, B07NCXJR1M (CorJav2)

Fair Use Source: B07NCXJR1M (CorJav2)

About This Book:

The #1 Guide to Advanced Java Programming, Fully Updated for Java 11

Core Java has long been recognized as the leading, no-nonsense tutorial and reference for experienced programmers who want to write robust Java code for real-world applications. Now, Core Java, Volume II—Advanced Features, Eleventh Edition, has been updated for Java 11, with up-to-date coverage of advanced UI and enterprise programming, networking, security, and Java’s powerful new module system.

Cay S. Horstmann explores sophisticated new language and library features with the depth and completeness that readers expect from Core Java. He demonstrates how to use these features to build professional-quality applications, using thoroughly tested examples that reflect modern Java style and best practices, including modularization. Horstmann’s examples are carefully crafted for easy understanding and maximum practical value, so you can consistently use them to jump-start your own code.

  • Master advanced techniques, idioms, and best practices for writing superior Java code
  • Take full advantage of modern Java I/O APIs, object serialization, and regular expressions
  • Efficiently connect to network services, implement network clients and servers, and harvest web data
  • Query databases and manage database connections with the latest version of JDBC
  • Simplify all aspects of date and time programming with the Java Date and Time API
  • Write internationalized programs that localize dates, times, numbers, text, and GUIs
  • Process code in three powerful ways: the scripting API, compiler API, and annotation processing
  • Learn how to migrate legacy code to the Java Platform Module System
  • Leverage the modern Java security features most valuable to application programmers
  • Program advanced client-side user interfaces, and generate images on the server
  • Use JNI to interoperate with native C code

See Core Java, Volume I—Fundamentals, Eleventh Edition (ISBN-13: 978-0-13-516630-7), for expert coverage of fundamental Java and UI programming, including objects, generics, collections, lambda expressions, Swing design, concurrency, and functional programming.

About the Author:

Cay S. Horstmann is a professor of computer science at San Jose State University and a Java Champion. He is also the author of Core Java, Volume I and Core Java, Volume II, Eleventh EditionCore Java SE 9 for the ImpatientSecond Edition (Addison-Wesley, 2018), and Scala for the Impatient, Second Edition (Addison-Wesley, 2017). He has written more than a dozen other books for professional programmers and computer science students.

Book Details:

  • ASIN : B07NCXJR1M
  • Publisher : Pearson; 11th edition (February 11, 2019)
  • Publication date : February 11, 2019
  • Print length : 960 pages

Table of Contents:

Sources:

Fair Use Sources:

Categories
Bibliography Java Software Engineering

Core Java – Volume I – Fundamentals, by Cay S. Horstmann

See also Core Java – Volume II – Advanced Features, Java Programming Language, Java Glossary, Java Bibliography, Java Reference materials

Core Java – Volume I – Fundamentals, 11th Edition, by Cay S. Horstmann, 2020, B07G8DHTSZ (CorJav1)

Fair Use Source: B07G8DHTSZ (CorJav1)

About This Book:

The #1 Guide for Serious Programmers: Fully Updated for Java SE 9, 10 & 11

Cay Horstmann’s Core Java, Volume I—Fundamentals, Eleventh Edition, is the definitive guide to writing robust, maintainable code with the Java SE 9, 10, and 11 language and libraries. Horstmann writes for serious programmers who use Java in production projects, and need a deep, practical understanding of the language and API. Throughout, he delivers what you need most: hundreds of real (non-toy) examples revealing the most powerful, effective ways to get the job done.

Updated examples reflect the new var keyword and take advantage of improvements in the Java API. You’ll learn how to use JShell’s new Read-Eval-Print Loop (REPL) for more rapid and exploratory development, and apply new features of the APIs for streams, input/output, processes, and concurrency.

In this first of two volumes, Horstmann offers in-depth coverage of fundamental Java and UI programming, including object-oriented programming, generics, collections, lambda expressions, Swing design, concurrency, and functional programming. If you’re an experienced programmer moving to Java SE 9, 10, or 11, there’s no better source for expert insight, solutions, and code.

  • Master foundational techniques, idioms, and best practices for writing superior Java code
  • Efficiently implement encapsulation and inheritance
  • Use sound principles of object-oriented design
  • Leverage the full power of objects with interfaces, lambda expressions, and inner classes
  • Harden programs through effective exception handling and debugging
  • Write safer, more reusable code with generic programming
  • Improve performance and efficiency with Java’s standard collections
  • Build cross-platform GUIs with the Swing toolkit
  • Fully utilize multicore processors with Java’s improved concurrency

See Core Java, Volume II—Advanced Features, Eleventh Edition (ISBN-13: 978-0-13-516631-4), for expert coverage of Java 9, 10, and 11 enterprise features, the module system, annotations, networking, security, and advanced UI programming.

About the Author:

Cay S. Horstmann is a professor of computer science at San Jose State University and a Java Champion. He is also the author of Core Java, Volume I and Core Java, Volume II, Eleventh EditionCore Java SE 9 for the ImpatientSecond Edition (Addison-Wesley, 2018), and Scala for the Impatient, Second Edition (Addison-Wesley, 2017). He has written more than a dozen other books for professional programmers and computer science students.

Book Details:

  • ASIN : B07G8DHTSZ
  • Publisher : Pearson; 11th edition (September 28, 2020)
  • Publication date : September 28, 2020
  • Print length : 916 pages

Table of Contents:

Sources:

Fair Use Sources:

Categories
Bibliography Java Software Engineering

Java Pocket Guide – Instant Help for Java Programmers

See also Java Programming Language, Java Glossary, Java Bibliography, Java Reference materials

See: Java Pocket Guide – Instant Help for Java Programmers, 4th Edition, by Robert Liguori, 2017, B0756P3CZD (JvPktGd)

Fair Use Source: B0756P3CZD (JvPktGd)

About This Book:

Any time you need quick answers for developing or debugging Java programs, this pocket guide is the ideal reference to standard features of the Java programming language and its platform. You’ll find helpful programming examples, tables, figures, and lists fast—including Java 9 features such as modular source code and the new JShell interactive command-line REPL. It’s a handy companion, whether you’re in the office, in the lab, or on the road.

This book also provides material to help you prepare for the Oracle Certified Associate Java Programmer exam.

  • Quickly find Java language details, such as naming conventions, types, statements and blocks, and object-oriented programming
  • Get details on the Java SE platform, including development basics, memory management, concurrency, and generics
  • Use new features in Java 9, including modular source code and JShell
  • Browse through information on basic input/output, NIO 2.0, the Java collections framework, and the Java Scripting API
  • Get supplemental references to fluent APIs, third-party tools, and basics of the Unified Modeling Language (UML)

About the Author:

Robert Liguori is an Oracle Certified Java Professional and a software developer / test engineer for several Java-based air traffic management applications. Robert has a Bachelors degree in Computer Science and Information Technology from Richard Stockton College of New Jersey.

Book Details:

  • ASIN : B0756P3CZD
  • Publisher : O’Reilly Media; 4th edition (August 28, 2017)
  • Publication date : August 28, 2017
  • Print length : 360 pages

Preface:

“Designed to be your companion, this Pocket Guide provides a quick reference to the standard features of the Java programming language and its platform.

This Pocket Guide provides you with the information you will need while developing or debugging your Java programs, including helpful programming examples, tables, figures, and lists.

Java coverage in this book is representative through Java SE 9 incorporating a subset of the 80+ JDK Enhancement Proposals (JEPs) slated for the release. This Java coverage includes improvements to the generage language as well as coverage of the new Java Shell and the new Java Module System. This book supercedes the three previous versions: Java Pocket Guide, Java 7 Pocket Guide, and Java 8 Pocket Guide.

For uniformity and enhanced interest, the majority of the code examples in this fourth edition of the Java Pocket Guide have been updated from code segments of the Gliesians Web Application. At the time of this writing, the primary focus of the Gliesians Web Application is to provide free utilities relative to genealogy and small unmanned aerial systems.

The material in this book also provides support in preparing for the Oracle Certified Programmer exams. If you are considering pursuing one of the Java certifications, you may also wish to acquire the OCA Java SE 8 Programmer I Study Guide (Exam 1Z0-808) by Edward Finegan and Robert Liguori (McGraw-Hill Osborne Media, 2015).

Table of Contents:

Preface

Book Structure

Conventions Used in This Book

O’Reilly Safari

How to Contact Us

Acknowledgments

I. Language

  1. Java Naming Conventions
  • Java Acronyms
  • Java Annotation Names
  • Java Class Names
  • Java Constant Names
  • Java Enumeration Names
  • Java Generic Type Parameter Names
  • Java Instance and Static Variable Names
  • Java Interface Names
  • Java Method Names
  • Java Package Names
  • Java Module Names
  • Java Parameter and Local Variable Names
  1. Java Lexical Elements
  • Java Unicode and ASCII
    • Java Printable ASCII Characters
    • Java Nonprintable ASCII Characters
    • Java Compact Strings
  • Java Comments
  • Java Keywords
  • Java Identifiers
  • Java Separators
  • Java Operators
  • Java Literals
    • Java Boolean Literals
    • Java Character Literals
    • Java Integer Literals
    • Java Floating-Point Literals
    • Java String Literals
    • Java Null Literals
  • Java Escape Sequences
  • Java Unicode Currency Symbols
  1. Java Fundamental Types
  • Java Primitive Types
  • Literals for Primitive Types
  • Java Floating-Point Entities
    • Java Operations Involving Special Entities
  • Java Numeric Promotion of Primitive Types
    • Java Unary Numeric Promotion
    • Java Binary Numeric Promotion
    • Java Special Cases for Conditional Operators
  • Java Wrapper Classes
  • Java Autoboxing and Unboxing
    • Java Autoboxing
    • Java Unboxing
  1. Java Reference Types
  • Comparing Java Reference Types to Java Primitive Types
  • Java Default Values
    • Java Instance Variable and Java Local Variable Objects
  • Java Arrays
  • Conversion of Java Reference Types
    • Java Widening Conversions
    • Java Narrowing Conversions
  • Converting Between Java Primitives and Java Reference Types
  • Passing Java Reference Types into Java Methods
  • Comparing Java Reference Types Using the Java Equality Operators
    • Using the Java equals() Method
    • Comparing Java Strings
    • Comparing Java Enumerations
  • Copying Java Reference Types
    • Copying a Java Reference to an Java Object
    • Cloning Java Objects
      • Shallow and deep cloning of Java objects
  • Java Memory Allocation and Java Garbage Collection of Java Reference Types
  1. Java Object-Oriented Programming
  • Java Classes and Java Objects
    • Java Class Syntax
    • Instantiating a Java Class (Creating a Java Object)
    • Java Data Members and Java Methods
    • Accessing Java Data Members and Java Methods in Java Objects
    • Java Overloading
    • Java Overriding
    • Java Constructors
    • Java Superclasses and Java Subclasses
    • The Java this Keyword
  • Java Variable-Length Argument Lists
  • Java Abstract Classes and Java Abstract Methods
    • Java Abstract Classes
    • Java Abstract Methods
  • Java Static Data Members, Java Static Methods, Java Static Constants, and Java Static Initializers
    • Java Static Data Members
    • Java Static Methods
    • Java Static Constants
    • Java Static Initializers
  • Java Interfaces
  • Java Enumerations
  • Java Annotation Types
    • Built-in Java Annotations
    • Developer-Defined Java Annotations
  • Functional Java Interfaces
  1. Java Statements and Blocks
  • Java Expression Statements
  • Java Empty Statement
  • Java Blocks
  • Java Conditional Statements
    • The Java if Statement
    • The Java if else Statement
    • The Java if else if Statement
    • The Java switch Statement
  • Java Iteration Statements
    • The Java for Loop
    • The Java Enhanced for Loop
    • The Java while Loop
    • The Java do while Loop
  • Java Transfer of Control
    • The Java break Statement
    • The Java continue Statement
    • The Java return Statement
  • Java Synchronized Statement
  • Java Assert Statement
  • Java Exception Handling Statements
  1. Java Exception Handling
  • The Java Exception Hierarchy
  • Java Checked Exceptions and Java Unchecked Exceptions and Java Errors
    • Java Checked Exceptions
    • Java Unchecked Exceptions
    • Java Errors
  • Common Java Checked/Unchecked Exceptions and Java Errors
    • Common Java Checked Exceptions
    • Common Java Unchecked Exceptions
    • Common Java Errors
  • Java Exception Handling Keywords
    • The Java throw Keyword
    • The Java try/catch/finally Keywords
    • The Java try-catch Statement
    • The Java try-finally Statement
    • The Java try-catch-finally Statement
    • The Java try-with-resources Statement
    • The Java multi-catch Clause
  • The Java Exception Handling Process
  • Defining Your Own Java Exception Class
  • Printing Information About Java Exceptions
    • The Java getMessage() Method
    • The Java toString() Method
    • The Java printStackTrace() Method
  1. Java Modifiers
  • Java Access Modifiers
  • Other Java (Nonaccess) Modifiers
  • Java Modifiers Encoding

II. Platform

  1. Java Platform, Standard Edition Common Java SE API Libraries Language and Utility Libraries

Base Libraries

Integration Libraries

Miscellaneous User Interface Libraries

JavaFX User Interface Library

Remote Method Invocation (RMI) and CORBA Libraries

Security Libraries

Extensible Markup Language (XML) Libraries

  1. Development Basics Java Runtime Environment

Java Development Kit

Java Program Structure

Command-Line Tools Java Compiler

Java Interpreter

Java Program Packager

JAR File Execution

Classpath

  1. Memory Management Garbage Collectors Serial Collector

Parallel Collector

Parallel Compacting Collector

Concurrent Mark-Sweep Collector

Garbage-First (G1) Collector

Memory Management Tools

Command-Line Options

Resizing the JVM Heap

Metaspace

Interfacing with the GC Explicit Garbage Collection

Finalization

  1. Basic Input and Output Standard Streams in, out, and err

Class Hierarchy for Basic Input and Output

File Reading and Writing Reading Character Data from a File

Reading Binary Data from a File

Writing Character Data to a File

Writing Binary Data to a File

Socket Reading and Writing Reading Character Data from a Socket

Reading Binary Data from a Socket

Writing Character Data to a Socket

Writing Binary Data to a Socket

Serialization Serialize

Deserialize

Zipping and Unzipping Files Compressing and Uncompressing GZIP Files

  1. New I/O API (NIO.2) The Path Interface

The Files Class

Additional Features

  1. Concurrency Creating Threads Extending the Thread Class

Implementing the Runnable Interface

Thread States

Thread Priorities

Common Methods

Synchronization

Concurrent Utilities Executors

Concurrent Collections

Synchronizers

Timing Utility

  1. Java Collections Framework The Collection Interface

Implementations

Collection Framework Methods

Collections Class Algorithms

Algorithm Efficiencies

Comparator Functional Interface

Convenience Factory Methods

  1. Generics Framework Generic Classes and Interfaces

Constructors with Generics

Substitution Principle

Type Parameters, Wildcards, and Bounds

The Get and Put Principle

Generic Specialization

Generic Methods in Raw Types

  1. The Java Scripting API Scripting Languages

Script Engine Implementations Embedding Scripts into Java

Invoking Methods of Scripting Languages

Accessing and Controlling Java Resources from Scripts

Setting Up Scripting Languages and Engines Scripting Language Setup

Scripting Engine Setup

Scripting Engine Validation

  1. Date and Time API Legacy Interoperability

Regional Calendars

ISO Calendar Machine Interface

Durations and Periods

JDBC and XSD Mapping

Formatting

  1. Lambda Expressions λEs Basics λEs Syntax and Example

Method and Constructor References

Specific-Purpose Functional Interfaces

General-Purpose Functional Interfaces

Resources for λEs Tutorials

Community Resources

  1. JShell: the Java Shell Getting Started

Snippets Modifiers

Flow Control Statements

Package Declarations

Using JShell Primary Expressions

Dependencies

Statements and Code Blocks

Method and Class Declarations

Viewing, Deleting, and Modifying Snippets

Saving, Loading, and State

JShell Features Scratch Variables

Tab Auto-Complete

Forward Referencing

Checked Exceptions

Hierarchy and Scope

Summary of JShell Commands

  1. Java Module System Project Jigsaw

Java Modules Automatic Modules

Unnamed Modules

Accessibility

Compiling Modules

Modular JDK

jdeps Identifying Dependencies

Identifying Undocumented JDK Internal Dependencies

Defining a Module

Exporting a Package

Declaring Dependencies

Transitive Dependencies

Defining Service Providers Defining Service API

Implementing Service API

Using Service Providers

jlink

III. Appendixes

A. Fluent APIs

B. Third-Party Tools Development, CM, and Test Tools

Libraries

Integrated Development Environments

Web Application Platforms

Scripting Languages Compatible with JSR-223

C. UML Basics Class Diagrams Name

Attributes

Operations

Visibility

Object Diagrams

Graphical Icon Representation Classes, Abstract Classes, and Interfaces

Notes

Packages

Connectors

Multiplicity Indicators

Role Names

Class Relationships Association

Direct Association

Composition Association

Aggregation Association

Temporary Association

Generalization

Realization

Sequence Diagrams Participant (1)

Found Message (2)

Synchronous Message (3)

Return Call (4)

Asynchronous Message (5)

Message to Self (6)

Lifeline (7)

Activation Bar (8)

Index

Sources:

Fair Use Sources:

Categories
Bibliography Java Software Engineering

Java in a Nutshell – A Desktop Quick Reference

See also Java Programming Language, Java Glossary, Java Bibliography, Java Reference materials

Java in a Nutshell – A Desktop Quick Reference, 7th Edition, by Ben Evans and David Flanagan, 2018, B07L3BFG49 (JvNutSh)

Fair Use Source: B07L3BFG49 (JvNutSh)

About This Book:

This updated edition of Java in a Nutshell not only helps experienced Java programmers get the most out of Java versions 9 through 11, it’s also a learning path for new developers. Chock full of examples that demonstrate how to take complete advantage of modern Java APIs and development best practices, this thoroughly revised book includes new material on Java Concurrency Utilities.

The book’s first section provides a fast-paced, no-fluff introduction to the Java programming language and the core runtime aspects of the Java platform. The second section is a reference to core concepts and APIs that explains how to perform real programming work in the Java environment.

  • Get up to speed on language details, including Java 9-11 changes
  • Learn object-oriented programming, using basic Java syntax
  • Explore generics, enumerations, annotations, and lambda expressions
  • Understand basic techniques used in object-oriented design
  • Examine concurrency and memory, and how they’re intertwined
  • Work with Java collections and handle common data formats
  • Delve into Java’s latest I/O APIs, including asynchronous channels
  • Use Nashorn to execute JavaScript on the Java Virtual Machine
  • Become familiar with development tools in OpenJDK

About the Authors:

Ben Evans is an author, speaker, consultant and educator. He is co-founder of jClarity, a startup which delivers performance tools & services to help development & ops teams. He helps to organize the London Java Community and serves on the Java Community Process Executive Committee, helping define standards for the Java ecosystem. He is a Java Champion, JavaOne Rockstar Speaker and a Java Editor at InfoQ. Ben travels frequently and speaks regularly, all over the world.

David Flanagan is a computer programmer who spends most of his time writing about JavaScript and Java. His books with O’Reilly include Java in a Nutshell, Java Examples in a Nutshell, Java Foundation Classes in a Nutshell, JavaScript: The Definitive Guide, and JavaScript Pocket Reference. David has a degree in computer science and engineering from the Massachusetts Institute of Technology. He lives with his wife and children in the U.S. Pacific Northwest bewteen the cities of Seattle, Washington and Vancouver, British Columbia. David has a blog at www.davidflanagan.com.

Book Details:

  • ASIN : B07L3BFG49
  • Publisher : O’Reilly Media; 7th edition (December 3, 2018)
  • Publication date : December 3, 2018
  • Print length : 760 pages

Table of Contents:

Sources:

Fair Use Sources:

Categories
Java Software Engineering

CodeRanch.com

See also Java Programming Language, Java Glossary, Java Bibliography, Java Reference materials

A friendly place for programming greenhorns

Jump straight into any of our topics and light hearted discussions. Ranging from
java, databases, android, programmer certification, programming jobs and much more…

Java: Find Java topics ranging from beginner’s questions to core Java, features in Java releases, Servlets and JSP, networking, I/O, GUIs with Swing or JavaFX, and more including game development!
Books: Discussions of books and lots of book reviews. You can even contribute your own book review. We even stick in software reviews and upcoming events.
Mobile: Programming for that chip in your life! Join programming discussions on portable devices, iOS vs Android, Mobile apps, UI advice, API guidance and App Store approval hints and tips.

Sources:

Fair Use Sources:

Categories
Java Software Engineering

Herbert Schildt

See also Java: The Complete Reference, Java Programming Language, Java Glossary, Java Bibliography, Java Reference materials

Herbert Schildt is an American computing author, programmer and musician. He has written books about various programming languages. He was also a founding member of the progressive rock band Starcastle.

Called “one of the world’s foremost authors of books about programming” by International Developer magazine, best-selling author Herbert Schildt has written about programming for over three decades. His books have sold millions of copies worldwide and have been widely translated. Featured as one of the rock star programmers in Ed Burns’ book “Secrets of the Rock Star Programmers”, Schildt is interested in all facets of computing, but his primary focus is computer languages. He is the author of numerous books on Java, C, C++, and C#. Schildt holds BA and MCS degrees from the University of Illinois, Urbana/Champaign.

Life

Schildt holds both graduate and undergraduate degrees from the University of Illinois at Urbana-Champaign (UIUC). He claims he was a member of the original ANSI committee that standardized the C language in 1989, and the ANSI/ISO committees that updated that standard in 1999, and standardized C++ in 1998.[1][unreliable source?] Other members of the ANSI C committee have drawn his presence in the committee and the quality of his committee efforts into question.[2][3]

Schildt has written books about DOS,[4] C, C++, C# and other computer languages. His earliest books were published around 1985 and 1986. (The book Advanced Modula-2 from 1987 says on the cover that it is his sixth book.) His books were initially published by Osborne, an early computer book publisher which concentrated on titles for the personal computer. After the acquisition of Osborne by McGraw-Hill, the imprint continued publishing Schildt’s work until the imprint was subsumed completely into the larger company.

Little C

One of Schildt’s most enduring projects is the Little C interpreter, which is a lengthy example of a hand-written recursive-descent parser which interprets a subset of the C language. The program was originally published in Dr. Dobb’s Journal in August, 1989 entitled “Building your own C interpreter”.[5] This example was included in the books Born to Code In C (Osborne, 1989), The Craft of C (Osborne, 1992),[6] and in a later edition of C: The Complete Reference.

Schildt’s book The Art of C++ similarly features an interpreter for a language called Mini-C++. (Mini-C++ does not support the “class” keyword, although minimal and artificial support for cin and cout has been added.) There is also a BASIC interpreter called Small BASIC in Turbo C: The Complete Reference, first edition, written in C, and another in The Art of Java (2003) written in Java.[7]

Code for all these is available for download from the McGraw Hill technical books website, under each book.[8]

Starcastle

In addition to his work as a computer scientist, Schildt is the original multi-keyboardist for the progressive rock band Starcastle, appearing on all of the group’s albums, most of which were produced from 1976-1978. His style is distinguished by extensive use of Oberheim analog sequencers to create ethereal washes of sound colors, a pioneering technique which was quite cutting-edge for the pre-digital synthesizer period. He is also featured on the band’s 2007 album “Song of Times.”[9]

Reception

Schildt is called “one of the world’s foremost authors of books about programming” by International Developer magazine.[10] He is featured as one of the rock star programmers in Ed Burns’ book Secrets of the Rock Star Programmers.[11] His books have sold in the millions, worldwide.[12]

Schildt’s books have a reputation for being riddled with errors.[13] Their technical accuracy has been challenged by many reviewers, including ISO C committee members Peter Seebach[2] and Clive Feather,[14] C FAQ author Steve Summit,[15] and numerous C Vu reviewers from the Association of C and C++ Users (ACCU).[16]

Other reviewers have been more positive, with one ACCU reviewer saying about Schildt’s C: The Complete Reference, Fourth Edition that Schildt “has learnt something, not enough to receive positive acclaim but enough to remove the ‘positively detrimental’ epithet”.[17]

Bibliography (of selected books)

References

  1. ^ “About Herb Schildt”official site. Retrieved 2010-04-25.
  2. a b Seebach, Peter. “C: The Complete Nonsense (4th Edition)”. Retrieved 2010-04-08.
  3. ^ Clive Feather (18 January 2008). “Re: To Richard Heathfield from spinoza1111”. Retrieved 28 September 2013.
  4. ^ Shannon, L.R. (August 6, 1991). “PERIPHERALS; MS-DOS: The Latest Literature Helps Out”The New York Times. New York, New York. Retrieved 2010-04-29.
  5. ^ Herb Schildt (August 1, 1989). “Building Your Own C Interpreter”Dr. Dobb’s Journal. Retrieved 2010-04-25.
  6. ^ Ian Ormesher (Sep 1993). “ACCU Reviews: The Craft of C”C VuACCU. Archived from the original on 2011-07-16. Retrieved 2010-04-25.
  7. ^ The Art of Java, page 88, online at Google Books.
  8. ^ “Free Downloads: Samples and Code” McGraw-Hill Professional website. Retrieved April 26, 2010.
  9. ^ “Starcastle History – Prog rock”Starcastle official site. Retrieved 2010-04-25.
  10. ^https://web.archive.org/web/20060820041249/http://internationaldeveloper.com/contact_us.htm
  11. ^ Burns, Ed (2008). Secrets of the Rock Star Programmers: Riding the IT CrestISBN 978-0071490832.
  12. ^ http://ridingthecrest.com/interviews.html
  13. ^ Seebach, Peter. “C: The Complete Nonsense (3rd Edition)”. Retrieved 2010-04-22.
  14. ^ Feather, Clive. “The Annotated Annotated C Standard”.
  15. ^ Summit, Steve (1996). C Programming FAQs. Addison-Wesley. pp. 169–170ISBN 0-201-84519-9Unfortunately, the book contains numerous errors and omissions, primarily in the annotations, and a few pages of the standard itself are missing. Many people on the Internet recommend ignoring the annotations entirely.http://c-faq.com/ansi/avail.html
  16. ^ “Schildt” Reviews in C Vu, from the ACCU, last updated 13 May 2001. Retrieved 2010-04-22.
  17. ^ Francis Glassborow. “Book Review: C: The Complete Reference 4ed”ACCU. Retrieved 28 September 2013.

External links

Categories

Sources:

Fair Use Sources:

Categories
Bibliography Java Software Engineering

Java – The Complete Reference, by Herbert Schildt

See also: Java – A Beginner’s Guide, Java Programming Language, Java Glossary, Java Bibliography, Java Reference materials

Java: The Complete Reference, 11th Edition, by Herbert Schildt, 2018, B07KSQ9RKF (JvCmRf)

Fair Use Source: B07KSQ9RKF (JvCmRf)

About This Book:

The Definitive Java Programming Guide – Fully updated for Java SE 11, Java: The Complete Reference, Eleventh Edition explains how to develop, compile, debug, and run Java programs. Best-selling programming author Herb Schildt covers the entire Java language, including its syntax, keywords, and fundamental programming principles. You’ll also find information on key portions of the Java API library, such as I/O, the Collections Framework, the stream library, and the concurrency utilities. Swing, JavaBeans, and servlets are examined and numerous examples demonstrate Java in action. Of course, the very important module system is discussed in detail. This Oracle Press resource also offers an introduction to JShell, Java’s interactive programming tool. Best of all, the book is written in the clear, crisp, uncompromising style that has made Schildt the choice of millions worldwide.
Coverage includes:

  • Data types, variables, arrays, and operators
  • Control statements
  • Classes, objects, and methods
  • Method overloading and overriding
  • Inheritance
  • Local variable type inference
  • Interfaces and packages
  • Exception handling
  • Multithreaded programming
  • Enumerations, autoboxing, and annotations
  • The I/O classes
  • Generics
  • Lambda expressions
  • Modules
  • String handling
  • The Collections Framework
  • Networking
  • Event handling
  • AWT
  • Swing
  • The Concurrent API
  • The Stream API
  • Regular expressions
  • JavaBeans
  • Servlets
  • Much, much more

Code examples in the book are available for download at www.OraclePressBooks.com.

About the Author:

Herbert Schildt is one of the world’s leading programming authors and has written extensively on Java, C, C++, and C#. His books have sold millions of copies worldwide. Herb’s acclaimed books include Java: The Complete Reference, Java: A Beginner’s Guide, C: The Complete Reference, C++: The Complete Reference and C#: The Complete Reference.  

Book Details:

  • ASIN : B07KSQ9RKF
  • Publisher : McGraw-Hill Education; 11th edition (December 14, 2018)
  • Publication date : December 14, 2018
  • Print length : 1248 pages
  • Page numbers source ISBN : 9390491622

Table of Contents:

Table of Contents

Part I The Java Language

  1. Chapter 1 The History and Evolution of Java
    1. Java’s Lineage
      1. The Birth of Modern Programming: C
      2. C++: The Next Step
      3. The Stage Is Set for Java
    2. The Creation of Java
      1. The C# Connection
    3. How Java Impacted the Internet
      1. Java Applets
      2. Security
      3. Portability
    4. Java’s Magic: The Bytecode
    5. Moving Beyond Applets
    6. A Faster Release Schedule
    7. Servlets: Java on the Server Side
    8. The Java Buzzwords
      1. Simple
      2. Object-Oriented
      3. Robust
      4. Multithreaded
      5. Architecture-Neutral
      6. Interpreted and High Performance
      7. Distributed
      8. Dynamic
    9. The Evolution of Java
    10. A Culture of Innovation
  2. Chapter 2 An Overview of Java
    1. Object-Oriented Programming
      1. Two Paradigms
      2. Abstraction
      3. The Three OOP Principles
    2. A First Simple Program
      1. Entering the Program
      2. Compiling the Program
      3. A Closer Look at the First Sample Program
    3. A Second Short Program
    4. Two Control Statements
      1. The if Statement
      2. The for Loop
    5. Using Blocks of Code
    6. Lexical Issues
      1. Whitespace
      2. Identifiers
      3. Literals
      4. Comments
      5. Separators
      6. The Java Keywords
    7. The Java Class Libraries
  3. Chapter 3 Data Types, Variables, and Arrays
    1. Java Is a Strongly Typed Language
    2. The Primitive Types
    3. Integers
      1. byte
      2. short
      3. int
      4. long
    4. Floating-Point Types
      1. float
      2. double
    5. Characters
    6. Booleans
    7. A Closer Look at Literals
      1. Integer Literals
      2. Floating-Point Literals
      3. Boolean Literals
      4. Character Literals
      5. String Literals
    8. Variables
      1. Declaring a Variable
      2. Dynamic Initialization
      3. The Scope and Lifetime of Variables
    9. Type Conversion and Casting
      1. Java’s Automatic Conversions
      2. Casting Incompatible Types
    10. Automatic Type Promotion in Expressions
      1. The Type Promotion Rules
    11. Arrays
      1. One-Dimensional Arrays
      2. Multidimensional Arrays
      3. Alternative Array Declaration Syntax
    12. Introducing Type Inference with Local Variables
      1. Some var Restrictions
    13. A Few Words About Strings
  4. Chapter 4 Operators
    1. Arithmetic Operators
      1. The Basic Arithmetic Operators
      2. The Modulus Operator
      3. Arithmetic Compound Assignment Operators
      4. Increment and Decrement
    2. The Bitwise Operators
      1. The Bitwise Logical Operators
      2. The Left Shift
      3. The Right Shift
      4. The Unsigned Right Shift
      5. Bitwise Operator Compound Assignments
    3. Relational Operators
    4. Boolean Logical Operators
      1. Short-Circuit Logical Operators
    5. The Assignment Operator
    6. The ? Operator
    7. Operator Precedence
    8. Using Parentheses
  5. Chapter 5 Control Statements
    1. Java’s Selection Statements
      1. if
      2. switch
    2. Iteration Statements
      1. while
      2. do-while
      3. for
      4. The For-Each Version of the for Loop
      5. Local Variable Type Inference in a for Loop
      6. Nested Loops
    3. Jump Statements
      1. Using break
      2. Using continue
  6. Chapter 6 Introducing Classes
    1. Class Fundamentals
      1. The General Form of a Class
      2. A Simple Class
    2. Declaring Objects
      1. A Closer Look at new
    3. Assigning Object Reference Variables
    4. Introducing Methods
      1. Adding a Method to the Box Class
      2. Returning a Value
      3. Adding a Method That Takes Parameters
    5. Constructors
      1. Parameterized Constructors
    6. The this Keyword
      1. Instance Variable Hiding
    7. Garbage Collection
    8. A Stack Class
  7. Chapter 7 A Closer Look at Methods and Classes
    1. Overloading Methods
      1. Overloading Constructors
    2. Using Objects as Parameters
    3. A Closer Look at Argument Passing
    4. Returning Objects
    5. Recursion
    6. Introducing Access Control
    7. Understanding static
    8. Introducing final
    9. Arrays Revisited
    10. Introducing Nested and Inner Classes
    11. Exploring the String Class
    12. Using Command-Line Arguments
    13. Varargs: Variable-Length Arguments
      1. Overloading Vararg Methods
      2. Varargs and Ambiguity
    14. Local Variable Type Inference with Reference Types
  8. Chapter 8 Inheritance
    1. Inheritance Basics
      1. Member Access and Inheritance
      2. A More Practical Example
      3. A Superclass Variable Can Reference a Subclass Object
    2. Using super
      1. Using super to Call Superclass Constructors
      2. A Second Use for super
    3. Creating a Multilevel Hierarchy
    4. When Constructors Are Executed
    5. Method Overriding
    6. Dynamic Method Dispatch
      1. Why Overridden Methods?
      2. Applying Method Overriding
    7. Using Abstract Classes
    8. Using final with Inheritance
      1. Using final to Prevent Overriding
      2. Using final to Prevent Inheritance
    9. Local Variable Type Inference and Inheritance
    10. The Object Class
  9. Chapter 9 Packages and Interfaces
    1. Packages
      1. Defining a Package
      2. Finding Packages and CLASSPATH
      3. A Short Package Example
    2. Packages and Member Access
      1. An Access Example
    3. Importing Packages
    4. Interfaces
      1. Defining an Interface
      2. Implementing Interfaces
      3. Nested Interfaces
      4. Applying Interfaces
      5. Variables in Interfaces
      6. Interfaces Can Be Extended
    5. Default Interface Methods
      1. Default Method Fundamentals
      2. A More Practical Example
      3. Multiple Inheritance Issues
    6. Use static Methods in an Interface
    7. Private Interface Methods
    8. Final Thoughts on Packages and Interfaces
  10. Chapter 10 Exception Handling
    1. Exception-Handling Fundamentals
    2. Exception Types
    3. Uncaught Exceptions
    4. Using try and catch
      1. Displaying a Description of an Exception
    5. Multiple catch Clauses
    6. Nested try Statements
    7. throw
    8. throws
    9. finally
    10. Java’s Built-in Exceptions
    11. Creating Your Own Exception Subclasses
    12. Chained Exceptions
    13. Three Additional Exception Features
    14. Using Exceptions
  11. Chapter 11 Multithreaded Programming
    1. The Java Thread Model
      1. Thread Priorities
      2. Synchronization
      3. Messaging
      4. The Thread Class and the Runnable Interface
    2. The Main Thread
    3. Creating a Thread
      1. Implementing Runnable
      2. Extending Thread
      3. Choosing an Approach
    4. Creating Multiple Threads
    5. Using isAlive( ) and join( )
    6. Thread Priorities
    7. Synchronization
      1. Using Synchronized Methods
      2. The synchronized Statement
    8. Interthread Communication
      1. Deadlock
    9. Suspending, Resuming, and Stopping Threads
    10. Obtaining a Thread’s State
    11. Using a Factory Method to Create and Start a Thread
    12. Using Multithreading
  12. Chapter 12 Enumerations, Autoboxing, and Annotations
    1. Enumerations
      1. Enumeration Fundamentals
      2. The values( ) and valueOf( ) Methods
      3. Java Enumerations Are Class Types
      4. Enumerations Inherit Enum
      5. Another Enumeration Example
    2. Type Wrappers
      1. Character
      2. Boolean
      3. The Numeric Type Wrappers
    3. Autoboxing
      1. Autoboxing and Methods
      2. Autoboxing/Unboxing Occurs in Expressions
      3. Autoboxing/Unboxing Boolean and Character Values
      4. Autoboxing/Unboxing Helps Prevent Errors
      5. A Word of Warning
    4. Annotations
      1. Annotation Basics
      2. Specifying a Retention Policy
      3. Obtaining Annotations at Run Time by Use of Reflection
      4. The AnnotatedElement Interface
      5. Using Default Values
      6. Marker Annotations
      7. Single-Member Annotations
      8. The Built-In Annotations
    5. Type Annotations
    6. Repeating Annotations
    7. Some Restrictions
  13. Chapter 13 I/O, Try-with-Resources, and Other Topics
    1. I/O Basics
      1. Streams
      2. Byte Streams and Character Streams
      3. The Predefined Streams
    2. Reading Console Input
      1. Reading Characters
      2. Reading Strings
    3. Writing Console Output
    4. The PrintWriter Class
    5. Reading and Writing Files
    6. Automatically Closing a File
    7. The transient and volatile Modifiers
    8. Using instanceof
    9. strictfp
    10. Native Methods
    11. Using assert
      1. Assertion Enabling and Disabling Options
    12. Static Import
    13. Invoking Overloaded Constructors Through this( )
    14. A Word About Compact API Profiles
  14. Chapter 14 Generics
    1. What Are Generics?
    2. A Simple Generics Example
      1. Generics Work Only with Reference Types
      2. Generic Types Differ Based on Their Type Arguments
      3. How Generics Improve Type Safety
    3. A Generic Class with Two Type Parameters
    4. The General Form of a Generic Class
    5. Bounded Types
    6. Using Wildcard Arguments
      1. Bounded Wildcards
    7. Creating a Generic Method
      1. Generic Constructors
    8. Generic Interfaces
    9. Raw Types and Legacy Code
    10. Generic Class Hierarchies
      1. Using a Generic Superclass
      2. A Generic Subclass
      3. Run-Time Type Comparisons Within a Generic Hierarchy
      4. Casting
      5. Overriding Methods in a Generic Class
    11. Type Inference with Generics
    12. Local Variable Type Inference and Generics
    13. Erasure
      1. Bridge Methods
    14. Ambiguity Errors
    15. Some Generic Restrictions
      1. Type Parameters Can’t Be Instantiated
      2. Restrictions on Static Members
      3. Generic Array Restrictions
      4. Generic Exception Restriction
  15. Chapter 15 Lambda Expressions
    1. Introducing Lambda Expressions
      1. Lambda Expression Fundamentals
      2. Functional Interfaces
      3. Some Lambda Expression Examples
    2. Block Lambda Expressions
    3. Generic Functional Interfaces
    4. Passing Lambda Expressions as Arguments
    5. Lambda Expressions and Exceptions
    6. Lambda Expressions and Variable Capture
    7. Method References
      1. Method References to static Methods
      2. Method References to Instance Methods
      3. Method References with Generics
    8. Constructor References
    9. Predefined Functional Interfaces
  16. Chapter 16 Modules
    1. Module Basics
      1. A Simple Module Example
      2. Compile and Run the First Module Example
      3. A Closer Look at requires and exports
    2. java.base and the Platform Modules
    3. Legacy Code and the Unnamed Module
    4. Exporting to a Specific Module
    5. Using requires transitive
    6. Use Services
      1. Service and Service Provider Basics
      2. The Service-Based Keywords
      3. A Module-Based Service Example
    7. Module Graphs
    8. Three Specialized Module Features
      1. Open Modules
      2. The opens Statement
      3. requires static
    9. Introducing jlink and Module JAR Files
      1. Linking Files in an Exploded Directory
      2. Linking Modular JAR Files
      3. JMOD Files
    10. A Brief Word About Layers and Automatic Modules
    11. Final Thoughts on Modules

Part II The Java Library

  1. Chapter 17 String Handling
    1. The String Constructors
    2. String Length
    3. Special String Operations
      1. String Literals
      2. String Concatenation
      3. String Concatenation with Other Data Types
      4. String Conversion and toString( )
    4. Character Extraction
      1. charAt( )
      2. getChars( )
      3. getBytes( )
      4. toCharArray( )
    5. String Comparison
      1. equals( ) and equalsIgnoreCase( )
      2. regionMatches( )
      3. startsWith( ) and endsWith( )
      4. equals( ) Versus ==
      5. compareTo( )
    6. Searching Strings
    7. Modifying a String
      1. substring( )
      2. concat( )
      3. replace( )
      4. trim( ) and strip( )
    8. Data Conversion Using valueOf( )
    9. Changing the Case of Characters Within a String
    10. Joining Strings
    11. Additional String Methods
    12. StringBuffer
      1. StringBuffer Constructors
      2. length( ) and capacity( )
      3. ensureCapacity( )
      4. setLength( )
      5. charAt( ) and setCharAt( )
      6. getChars( )
      7. append( )
      8. insert( )
      9. reverse( )
      10. delete( ) and deleteCharAt( )
      11. replace( )
      12. substring( )
      13. Additional StringBuffer Methods
    13. StringBuilder
  2. Chapter 18 Exploring java.lang
    1. Primitive Type Wrappers
      1. Number
      2. Double and Float
      3. Understanding isInfinite( ) and isNaN( )
      4. Byte, Short, Integer, and Long
      5. Character
      6. Additions to Character for Unicode Code Point Support
      7. Boolean
    2. Void
    3. Process
    4. Runtime
      1. Memory Management
      2. Executing Other Programs
    5. Runtime.Version
    6. ProcessBuilder
    7. System
      1. Using currentTimeMillis( ) to Time Program Execution
      2. Using arraycopy( )
      3. Environment Properties
    8. System.Logger and System.LoggerFinder
    9. Object
    10. Using clone( ) and the Cloneable Interface
    11. Class
    12. ClassLoader
    13. Math
      1. Trigonometric Functions
      2. Exponential Functions
      3. Rounding Functions
      4. Miscellaneous Math Methods
    14. StrictMath
    15. Compiler
    16. Thread, ThreadGroup, and Runnable
      1. The Runnable Interface
      2. Thread
      3. ThreadGroup
    17. ThreadLocal and InheritableThreadLocal
    18. Package
    19. Module
    20. ModuleLayer
    21. RuntimePermission
    22. Throwable
    23. SecurityManager
    24. StackTraceElement
    25. StackWalker and StackWalker.StackFrame
    26. Enum
    27. ClassValue
    28. The CharSequence Interface
    29. The Comparable Interface
    30. The Appendable Interface
    31. The Iterable Interface
    32. The Readable Interface
    33. The AutoCloseable Interface
    34. The Thread.UncaughtExceptionHandler Interface
    35. The java.lang Subpackages
      1. java.lang.annotation
      2. java.lang.instrument
      3. java.lang.invoke
      4. java.lang.management
      5. java.lang.module
      6. java.lang.ref
      7. java.lang.reflect
  3. Chapter 19 java.util Part 1: The Collections Framework
    1. Collections Overview
    2. The Collection Interfaces
      1. The Collection Interface
      2. The List Interface
      3. The Set Interface
      4. The SortedSet Interface
      5. The NavigableSet Interface
      6. The Queue Interface
      7. The Deque Interface
    3. The Collection Classes
      1. The ArrayList Class
      2. The LinkedList Class
      3. The HashSet Class
      4. The LinkedHashSet Class
      5. The TreeSet Class
      6. The PriorityQueue Class
      7. The ArrayDeque Class
      8. The EnumSet Class
    4. Accessing a Collection via an Iterator
      1. Using an Iterator
      2. The For-Each Alternative to Iterators
    5. Spliterators
    6. Storing User-Defined Classes in Collections
    7. The RandomAccess Interface
    8. Working with Maps
      1. The Map Interfaces
      2. The Map Classes
    9. Comparators
      1. Using a Comparator
    10. The Collection Algorithms
    11. Arrays
    12. The Legacy Classes and Interfaces
      1. The Enumeration Interface
      2. Vector
      3. Stack
      4. Dictionary
      5. Hashtable
      6. Properties
      7. Using store( ) and load( )
    13. Parting Thoughts on Collections
  4. Chapter 20 java.util Part 2: More Utility Classes
    1. StringTokenizer
    2. BitSet
    3. Optional, OptionalDouble, OptionalInt, and OptionalLong
    4. Date
    5. Calendar
    6. GregorianCalendar
    7. TimeZone
    8. SimpleTimeZone
    9. Locale
    10. Random
    11. Timer and TimerTask
    12. Currency
    13. Formatter
      1. The Formatter Constructors
      2. The Formatter Methods
      3. Formatting Basics
      4. Formatting Strings and Characters
      5. Formatting Numbers
      6. Formatting Time and Date
      7. The %n and %% Specifiers
      8. Specifying a Minimum Field Width
      9. Specifying Precision
      10. Using the Format Flags
      11. Justifying Output
      12. The Space, +, 0, and ( Flags
      13. The Comma Flag
      14. The # Flag
      15. The Uppercase Option
      16. Using an Argument Index
      17. Closing a Formatter
      18. The Java printf( ) Connection
    14. Scanner
      1. The Scanner Constructors
      2. Scanning Basics
      3. Some Scanner Examples
      4. Setting Delimiters
      5. Other Scanner Features
    15. The ResourceBundle, ListResourceBundle, and PropertyResourceBundle Classes
    16. Miscellaneous Utility Classes and Interfaces
    17. The java.util Subpackages
      1. java.util.concurrent, java.util.concurrent.atomic, and java.util.concurrent.locks
      2. java.util.function
      3. java.util.jar
      4. java.util.logging
      5. java.util.prefs
      6. java.util.regex
      7. java.util.spi
      8. java.util.stream
      9. java.util.zip
  5. Chapter 21 Input/Output: Exploring java.io
    1. The I/O Classes and Interfaces
    2. File
      1. Directories
      2. Using FilenameFilter
      3. The listFiles( ) Alternative
      4. Creating Directories
    3. The AutoCloseable, Closeable, and Flushable Interfaces
    4. I/O Exceptions
    5. Two Ways to Close a Stream
    6. The Stream Classes
    7. The Byte Streams
      1. InputStream
      2. OutputStream
      3. FileInputStream
      4. FileOutputStream
      5. ByteArrayInputStream
      6. ByteArrayOutputStream
      7. Filtered Byte Streams
      8. Buffered Byte Streams
      9. SequenceInputStream
      10. PrintStream
      11. DataOutputStream and DataInputStream
      12. RandomAccessFile
    8. The Character Streams
      1. Reader
      2. Writer
      3. FileReader
      4. FileWriter
      5. CharArrayReader
      6. CharArrayWriter
      7. BufferedReader
      8. BufferedWriter
      9. PushbackReader
      10. PrintWriter
    9. The Console Class
    10. Serialization
      1. Serializable
      2. Externalizable
      3. ObjectOutput
      4. ObjectOutputStream
      5. ObjectInput
      6. ObjectInputStream
      7. A Serialization Example
    11. Stream Benefits
  6. Chapter 22 Exploring NIO
    1. The NIO Classes
    2. NIO Fundamentals
      1. Buffers
      2. Channels
      3. Charsets and Selectors
    3. Enhancements Added by NIO.2
      1. The Path Interface
      2. The Files Class
      3. The Paths Class
      4. The File Attribute Interfaces
      5. The FileSystem, FileSystems, and FileStore Classes
    4. Using the NIO System
      1. Use NIO for Channel-Based I/O
      2. Use NIO for Stream-Based I/O
      3. Use NIO for Path and File System Operations
  7. Chapter 23 Networking
    1. Networking Basics
    2. The java.net Networking Classes and Interfaces
    3. InetAddress
      1. Factory Methods
      2. Instance Methods
    4. Inet4Address and Inet6Address
    5. TCP/IP Client Sockets
    6. URL
    7. URLConnection
    8. HttpURLConnection
    9. The URI Class
    10. Cookies
    11. TCP/IP Server Sockets
    12. Datagrams
      1. DatagramSocket
      2. DatagramPacket
      3. A Datagram Example
    13. Introducing java.net.http
      1. Three Key Elements
      2. A Simple HTTP Client Example
      3. Things to Explore in java.net.http
  8. Chapter 24 Event Handling
    1. Two Event Handling Mechanisms
    2. The Delegation Event Model
      1. Events
      2. Event Sources
      3. Event Listeners
    3. Event Classes
      1. The ActionEvent Class
      2. The AdjustmentEvent Class
      3. The ComponentEvent Class
      4. The ContainerEvent Class
      5. The FocusEvent Class
      6. The InputEvent Class
      7. The ItemEvent Class
    4. The KeyEvent Class
      1. The MouseEvent Class
      2. The MouseWheelEvent Class
      3. The TextEvent Class
      4. The WindowEvent Class
    5. Sources of Events
    6. Event Listener Interfaces
      1. The ActionListener Interface
      2. The AdjustmentListener Interface
      3. The ComponentListener Interface
      4. The ContainerListener Interface
      5. The FocusListener Interface
      6. The ItemListener Interface
      7. The KeyListener Interface
      8. The MouseListener Interface
      9. The MouseMotionListener Interface
      10. The MouseWheelListener Interface
      11. The TextListener Interface
      12. The WindowFocusListener Interface
      13. The WindowListener Interface
    7. Using the Delegation Event Model
      1. Some Key AWT GUI Concepts
      2. Handling Mouse Events
      3. Handling Keyboard Events
    8. Adapter Classes
    9. Inner Classes
      1. Anonymous Inner Classes
  9. Chapter 25 Introducing the AWT: Working with Windows, Graphics, and Text
    1. AWT Classes
    2. Window Fundamentals
      1. Component
      2. Container
      3. Panel
      4. Window
      5. Frame
      6. Canvas
    3. Working with Frame Windows
      1. Setting the Window’s Dimensions
      2. Hiding and Showing a Window
      3. Setting a Window’s Title
      4. Closing a Frame Window
      5. The paint( ) Method
      6. Displaying a String
      7. Setting the Foreground and Background Colors
      8. Requesting Repainting
      9. Creating a Frame-Based Application
    4. Introducing Graphics
      1. Drawing Lines
      2. Drawing Rectangles
      3. Drawing Ellipses and Circles
      4. Drawing Arcs
      5. Drawing Polygons
      6. Demonstrating the Drawing Methods
      7. Sizing Graphics
    5. Working with Color
      1. Color Methods
      2. Setting the Current Graphics Color
      3. A Color Demonstration Program
    6. Setting the Paint Mode
    7. Working with Fonts
      1. Determining the Available Fonts
      2. Creating and Selecting a Font
      3. Obtaining Font Information
    8. Managing Text Output Using FontMetrics
  10. Chapter 26 Using AWT Controls, Layout Managers, and Menus
    1. AWT Control Fundamentals
      1. Adding and Removing Controls
      2. Responding to Controls
      3. The HeadlessException
    2. Labels
    3. Using Buttons
      1. Handling Buttons
    4. Applying Check Boxes
      1. Handling Check Boxes
    5. CheckboxGroup
    6. Choice Controls
      1. Handling Choice Lists
    7. Using Lists
      1. Handling Lists
    8. Managing Scroll Bars
      1. Handling Scroll Bars
    9. Using a TextField
      1. Handling a TextField
    10. Using a TextArea
    11. Understanding Layout Managers
      1. FlowLayout
      2. BorderLayout
      3. Using Insets
      4. GridLayout
      5. CardLayout
      6. GridBagLayout
    12. Menu Bars and Menus
    13. Dialog Boxes
    14. A Word About Overriding paint( )
  11. Chapter 27 Images
    1. File Formats
    2. Image Fundamentals: Creating, Loading, and Displaying
      1. Creating an Image Object
      2. Loading an Image
      3. Displaying an Image
    3. Double Buffering
    4. ImageProducer
      1. MemoryImageSource
    5. ImageConsumer
      1. PixelGrabber
    6. ImageFilter
      1. CropImageFilter
      2. RGBImageFilter
    7. Additional Imaging Classes
  12. Chapter 28 The Concurrency Utilities
    1. The Concurrent API Packages
      1. java.util.concurrent
      2. java.util.concurrent.atomic
      3. java.util.concurrent.locks
    2. Using Synchronization Objects
      1. Semaphore
      2. CountDownLatch
      3. CyclicBarrier
      4. Exchanger
      5. Phaser
    3. Using an Executor
      1. A Simple Executor Example
      2. Using Callable and Future
    4. The TimeUnit Enumeration
    5. The Concurrent Collections
    6. Locks
    7. Atomic Operations
    8. Parallel Programming via the Fork/Join Framework
      1. The Main Fork/Join Classes
      2. The Divide-and-Conquer Strategy
      3. A Simple First Fork/Join Example
      4. Understanding the Impact of the Level of Parallelism
      5. An Example that Uses RecursiveTask<V>
      6. Executing a Task Asynchronously
      7. Cancelling a Task
      8. Determining a Task’s Completion Status
      9. Restarting a Task
      10. Things to Explore
      11. Some Fork/Join Tips
    9. The Concurrency Utilities Versus Java’s Traditional Approach
  13. Chapter 29 The Stream API
    1. Stream Basics
      1. Stream Interfaces
      2. How to Obtain a Stream
      3. A Simple Stream Example
    2. Reduction Operations
    3. Using Parallel Streams
    4. Mapping
    5. Collecting
    6. Iterators and Streams
      1. Use an Iterator with a Stream
      2. Use Spliterator
    7. More to Explore in the Stream API
  14. Chapter 30 Regular Expressions and Other Packages
    1. Regular Expression Processing
      1. Pattern
      2. Matcher
      3. Regular Expression Syntax
      4. Demonstrating Pattern Matching
      5. Two Pattern-Matching Options
      6. Exploring Regular Expressions
    2. Reflection
    3. Remote Method Invocation (RMI)
      1. A Simple Client/Server Application Using RMI
    4. Formatting Date and Time with java.text
      1. DateFormat Class
      2. SimpleDateFormat Class
    5. The java.time Time and Date API
      1. Time and Date Fundamentals
      2. Formatting Date and Time
      3. Parsing Date and Time Strings
      4. Other Things to Explore in java.time

Part III Introducing GUI Programming with Swing

  1. Chapter 31 Introducing Swing
    1. The Origins of Swing
    2. Swing Is Built on the AWT
    3. Two Key Swing Features
      1. Swing Components Are Lightweight
      2. Swing Supports a Pluggable Look and Feel
    4. The MVC Connection
    5. Components and Containers
      1. Components
      2. Containers
      3. The Top-Level Container Panes
    6. The Swing Packages
    7. A Simple Swing Application
    8. Event Handling
    9. Painting in Swing
      1. Painting Fundamentals
      2. Compute the Paintable Area
      3. A Paint Example
  2. Chapter 32 Exploring Swing
    1. JLabel and ImageIcon
    2. JTextField
    3. The Swing Buttons
      1. JButton
      2. JToggleButton
      3. Check Boxes
      4. Radio Buttons
    4. JTabbedPane
    5. JScrollPane
    6. JList
    7. JComboBox
    8. Trees
    9. JTable
  3. Chapter 33 Introducing Swing Menus
    1. Menu Basics
    2. An Overview of JMenuBar, JMenu, and JMenuItem
      1. JMenuBar
      2. JMenu
      3. JMenuItem
    3. Create a Main Menu
    4. Add Mnemonics and Accelerators to Menu Items
    5. Add Images and Tooltips to Menu Items
    6. Use JRadioButtonMenuItem and JCheckBoxMenuItem
    7. Create a Popup Menu
    8. Create a Toolbar
    9. Use Actions
    10. Put the Entire MenuDemo Program Together
    11. Continuing Your Exploration of Swing

Part IV Applying Java

  1. Chapter 34 Java Beans
    1. What Is a Java Bean?
    2. Advantages of Beans
    3. Introspection
      1. Design Patterns for Properties
      2. Design Patterns for Events
      3. Methods and Design Patterns
      4. Using the BeanInfo Interface
    4. Bound and Constrained Properties
    5. Persistence
    6. Customizers
    7. The JavaBeans API
      1. Introspector
      2. PropertyDescriptor
      3. EventSetDescriptor
      4. MethodDescriptor
    8. A Bean Example
  2. Chapter 35 Introducing Servlets
    1. Background
    2. The Life Cycle of a Servlet
    3. Servlet Development Options
    4. Using Tomcat
    5. A Simple Servlet
      1. Create and Compile the Servlet Source Code
      2. Start Tomcat
      3. Start a Web Browser and Request the Servlet
    6. The Servlet API
    7. The javax.servlet Package
      1. The Servlet Interface
      2. The ServletConfig Interface
      3. The ServletContext Interface
      4. The ServletRequest Interface
      5. The ServletResponse Interface
      6. The GenericServlet Class
      7. The ServletInputStream Class
      8. The ServletOutputStream Class
      9. The Servlet Exception Classes
    8. Reading Servlet Parameters
    9. The javax.servlet.http Package
      1. The HttpServletRequest Interface
      2. The HttpServletResponse Interface
      3. The HttpSession Interface
      4. The Cookie Class
      5. The HttpServlet Class
    10. Handling HTTP Requests and Responses
      1. Handling HTTP GET Requests
      2. Handling HTTP POST Requests
    11. Using Cookies
    12. Session Tracking

Part V Appendixes

  1. Appendix A Using Java’s Documentation Comments
    1. The javadoc Tags
      1. @author
      2. {@code}
      3. @deprecated
      4. {@docRoot}
      5. @exception
      6. @hidden
      7. {@index}
      8. {@inheritDoc}
      9. {@link}
      10. {@linkplain}
      11. {@literal}
      12. @param
      13. @provides
      14. @return
      15. @see
      16. @serial
      17. @serialData
      18. @serialField
      19. @since
      20. {@summary}
      21. @throws
      22. @uses
      23. {@value}
      24. @version
    2. The General Form of a Documentation Comment
    3. What javadoc Outputs
    4. An Example that Uses Documentation Comments
  2. Appendix B Introducing JShell
    1. JShell Basics
    2. List, Edit, and Rerun Code
    3. Add a Method
    4. Create a Class
    5. Use an Interface
    6. Evaluate Expressions and Use Built-in Variables
    7. Importing Packages
    8. Exceptions
    9. Some More JShell Commands
    10. Exploring JShell Further
  3. Appendix C Compile and Run Simple Single-File Programs in One Step

Index

Sources:

Fair Use Sources:

Categories
Java Software Engineering

Java documentation

See also Java Programming Language, Java Glossary, Java Bibliography, Java Reference materials

Whether you are working on a new cutting edge app or simply ramping up on new technology, Java documentation has all the information you need to make your project a smashing success. Use the rich set of code samples, tutorials, developer guides, API documentation, and more to quickly develop your prototype and scale it up to a real world application.

Java Platform, Standard Edition (Java SE)

Java SE lets you develop and deploy Java applications on desktops and servers. Java SE and component technologies offer the rich user interface, performance, versatility, portability, and security that today’s applications require.Java SE Documentation

Java Embedded

Java ME Embedded is designed for resource-constrained devices like wireless modules for M2M, industrial control, smart-grid infrastructure, environmental sensors and tracking, and more.Java ME Embedded documentationOracle Java SE Embedded delivers a secure, optimized runtime environment ideal for network-based devices.Oracle Java SE Embedded and JDK for ARM documentationJava Card technology provides a secure environment for applications that run on smart cards and other devices with very limited memory and processing capabilities. Java Card documentation

Java Platform, Enterprise Edition (Java EE)

Java EE provides an API and runtime environment for developing and running large, multi-tiered, reliable, and secure enterprise applications that are portable and scalable and that integrate easily with legacy applications and data.

Java EE documentation

Sources:

Fair Use Sources:

Categories
Java Software Engineering

Java Reference Materials

See also Java Bibliography, Java Programming Language or Java Glossary

Best Java programming reference books: Full list at Java Bibliography

Best reference sites for Java programming:

Sources:

Fair Use Sources:

Categories
Java Software Engineering

Java Bibliography

See also: Java Reference Materials, Java Programming Language or Java Glossary

  1. Java official documentation: https://docs.oracle.com/en/java (JavDoc)
  2. Learning Java, Fifth Edition, by Marc Loy, Patrick Niemeyer, and Daniel Leuck, 2020, 978-1-492-05627-0, B086L2NYWR (LerJav)
  3. Java: The Complete Reference, 11th Edition, by Herbert Schildt, 2018, B07KSQ9RKF (JvCmRf)
  4. Java in a Nutshell – A Desktop Quick Reference, 7th Edition, by Ben Evans and David Flanagan, 2018, B07L3BFG49 (JvNutSh)
  5. Java Pocket Guide – Instant Help for Java Programmers, 4th Edition, by Robert Liguori, 2017, B0756P3CZD (JvPktGd)
  6. Head First Java, 3rd Edition, by Kathy Sierra and Bert Bates, 2021, 1491910771 (HFJav)
  7. Java – A Beginner’s Guide, 8th Edition, by Herbert Schildt, 2018, B07J2ZZ29H (JvBgnGd)
  8. Effective Java, 3rd Edition, by Joshua Bloch, 2017, B078H61SCH (EftJav)
  9. Modern Java in Action – Lambdas, streams, functional and reactive programming, 2nd Edition, by Raoul-Gabriel Urma, Mario Fusco, Alan Mycroft, 2018, 1617293563 (ModJavAc)
  10. Java Cookbook – Problems and Solutions for Java Developers, 4th Edition, by Ian F. Darwin, 2020, B08651PDL6 (JvCkbk)
  11. Java for Absolute Beginners – Learn to Program the Fundamentals the Java 9+ Way, by Iuliana Cosmina, 2018, B07L5C7GHH (JvAbBgn)
  12. Think Java – How to Think Like a Computer Scientist, 2nd Edition, by Allen B. Downey and Chris Mayfield, 2019, B08234FFCX (TnkJav)
  13. OCA Java SE 11 Programmer I Certification Guide, Exam 1Z0-815, by Mala Gupta, 2021, 9781617297465 (OCA11Gup)
  14. OCA Java SE 8 Programmer I Certification Guide, by Mala Gupta, 2016, 1617293253 (OCA8Gup)
  15. The Well-Grounded Java Developer, Second Edition, by Benjamin Evans, Jason Clark, and Martijn Verburg, 2021, 1617298875 (WelGrJvDv)
  16. Core Java – Volume I – Fundamentals, 11th Edition, by Cay S. Horstmann, 2020, B07G8DHTSZ (CorJav1)
  17. Core Java – Volume II – Advanced Features, 11th Edition, by Cay S. Horstmann, 2019, B07NCXJR1M (CorJav2)
  18. Java Quick Syntax Reference, 2nd Edition, by Mikael Olsson, 2018, B079BKJ6CB (JvQSynRf)
  19. Gosling, James; Joy, Bill; Steele, Guy; Bracha, Gilad; Buckley, Alex, 2014. The Java® Language Specification (PDF) (Java SE 8 ed.).
  20. Gosling, James; Joy, BillSteele, Guy L., Jr.Bracha, Gilad, 2005. The Java Language Specification (3rd ed.). Addison-Wesley. ISBN 0-321-24678-0.
  21. Lindholm, Tim; Yellin, Frank, 1999. The Java Virtual Machine Specification (2nd ed.). Addison-Wesley. ISBN 0-201-43294-3.

Sources:

Fair Use Sources:

Categories
Bibliography Java Software Engineering

Learning Java: An Introduction to Real-World Programming with Java

See also Java Programming Language, Java Glossary, Java Bibliography, Java Reference materials

Fair Use Source: B086L2NYWR (LerJav)

By Marc Loy, Patrick Niemeyer, and Daniel Leuck

Learning Java, Fifth Edition, by Marc Loy, Patrick Niemeyer, and Daniel Leuck, 2020, 978-1-492-05627-0, B086L2NYWR (LerJav)

“If you’re new to Java—or new to programming—this best-selling book will guide you through the language features and APIs of Java 11. With fun, compelling, and realistic examples, authors Marc Loy, Patrick Niemeyer, and Daniel Leuck introduce you to Java fundamentals—including its class libraries, programming techniques, and idioms—with an eye toward building real applications.

You’ll learn powerful new ways to manage resources and exceptions in your applications—along with core language features included in recent Java versions.

  • Develop with Java, using the compiler, interpreter, and other tools
  • Explore Java’s built-in thread facilities and concurrency package
  • Learn text processing and the powerful regular expressions API
  • Write advanced networked or web-based applications and services

About the Author

Marc Loy started with Java training at Sun Microsystems in the early days (shout out to HotJava!) and never looked back. He authored a number of early Java books and training courses, working with a wide variety of companies across the US, Europe and Asia along the way. For O’Reilly, Marc has served as co-author on Java Swing and Learning GNU Emacs. Currently in Ohio, Marc is a software developer and trainer specializing in user experience design and mobile applications.

Patrick Niemeyer became involved with Oak (Java’s predecessor) while working at Southwestern Bell Technology Resources. He is an independent consultant and author in the areas of networking and distributed applications. Pat is the author of BeanShell, a popular Java scripting language, as well as various other free goodies on the Net. Most recently, Pat has been developing enterprise architecture for A.G. Edwards. He currently lives in the Central West End area of St. Louis with various creatures.

Dan Leuck is the CEO of Ikayzo, a Tokyo and Honolulu-based interactive design and software development firm with customers including Sony, Oracle, Nomura, PIMCO and the federal government. He previously served as Senior Vice President of Research and Development for Tokyo-based ValueCommerce, Asia’s largest online marketing company, Global Head of Development for London-based LastMinute.com, Europe’s largest B2C website, and President of the US division of DML. Daniel has extensive experience managing teams of 150+ developers in five countries. He has served on numerous advisory boards and panels for companies such as Macromedia and Sun Microsystems. Daniel is active in the Java community, is a contributor to BeanShell, the project lead for SDL, and sits on numerous Java Community Process expert groups.

Product details

  • Print length : 848 pages
  • Publication date : March 30, 2020
  • Publisher : O’Reilly Media; 5th edition (March 30, 2020)
  • ASIN : B086L2NYWR

Preface

“This book is about the Java programming language and environment. Whether you are a software developer or just someone who uses the internet in your daily life, you’ve undoubtedly heard about Java. Its introduction was one of the most exciting developments in the history of the web, and Java applications have powered much of the growth of business on the internet. Java is, arguably, the most popular programming language in the world, used by millions of developers on almost every kind of computer imaginable. Java has surpassed languages such as C++ and Visual Basic in terms of developer demand and has become the de facto language for certain kinds of development — especially for web-based services. Most universities are now using Java in their introductory courses alongside the other important modern languages. Perhaps you are using this text in one of your classes right now!

This book gives you a thorough grounding in Java fundamentals and APIs. Learning Java, Fifth Edition, attempts to live up to its name by mapping out the Java language and its class libraries, programming techniques, and idioms. We’ll dig deep into interesting areas and at least scratch the surface of other popular topics. Other titles from O’Reilly pick up where we leave off and provide more comprehensive information on specific areas and applications of Java.

Whenever possible, we provide compelling, realistic, and fun examples and avoid merely cataloging features. The examples are simple, but hint at what can be done. We won’t be developing the next great “killer app” in these pages, but we hope to give you a starting point for many hours of experimentation and inspired tinkering that will lead you to develop one yourself.

Web page for this book where they list errata and any additional information. You can access this page at https://oreil.ly/Java_5e.” (B086L2NYWR)

Who Should Read This Book

“This book is for computer professionals, students, technical people, and Finnish hackers. It’s for everyone who has a need for hands-on experience with the Java language with an eye toward building real applications. This book could also be considered a crash course in object-oriented programming, networking, and user interfaces. As you learn about Java, you’ll also learn a powerful and practical approach to software development, beginning with a deep understanding of the fundamentals of Java and its APIs.

Superficially, Java looks like C or C++, so you’ll have a tiny headstart in using this book if you have some experience with one of these languages. If you do not, don’t worry. Don’t make too much of the syntactic similarities between Java and C or C++. In many respects, Java acts like more dynamic languages such as Smalltalk and Lisp. Knowledge of another object-oriented programming language should certainly help, although you may have to change some ideas and unlearn a few habits. Java is considerably simpler than languages such as C++ and Smalltalk. If you learn well from concise examples and personal experimentation, we think you’ll like this book.

The last part of this book branches out to discuss Java in the context of web applications, web services, and request processing, so you should be familiar with the basic ideas behind web browsers, servers, and documents.” (B086L2NYWR)

New Developments

“This edition of Learning Java is actually the seventh edition — updated and retitled — of our original, popular Exploring Java. With each edition, we’ve taken great care not only to add new material covering additional features, but to thoroughly revise and update the existing content to synthesize the coverage and add years of real-world perspective and experience to these pages.

One noticeable change in recent editions is that we’ve de-emphasized the use of applets, reflecting their diminished role in recent years in creating interactive web pages. In contrast, we’ve greatly expanded our coverage of Java web applications and web services, which are now mature technologies.

We cover all of the important features of the latest “long-term support” release of Java, officially called Java Standard Edition (SE) 11, OpenJDK 11, but we also add in a few details from the “feature” releases of Java 12, Java 13, and Java 14. Sun Microsystems (Java’s keeper before Oracle) has changed the naming scheme many times over the years. Sun coined the term Java 2 to cover the major new features introduced in Java version 1.2 and dropped the term JDK in favor of SDK. With the sixth release, Sun skipped from Java version 1.4 to Java 5.0, but reprieved the term JDK and kept its numbering convention there. After that, we had Java 6, Java 7, and so on, and now we are at Java 14.

This release of Java reflects a mature language with occasional syntactic changes and updates to APIs and libraries. We’ve tried to capture these new features and update every example in this book to reflect not only the current Java practice, but style as well.” (B086L2NYWR)

New in This Edition (Java 11, 12, 13, 14)

“This edition of the book continues our tradition of rework to be as complete and up-to-date as possible. It incorporates changes from both the Java 11 — again, the long-term support version — and Java 12, 13, and 14 feature releases. (More on the specifics of the Java features included and excluded in recent releases in Chapter 13.) New topics in this edition include:

New language features, including type inference in generics and improved exception handling and automatic resource management syntax

New interactive playground, jshell, for trying out code snippets

The proposed switch expression

Basic lambda expressions

Updated examples and analysis throughout the book” (B086L2NYWR)

Using This Book

“This book is organized roughly as follows:

Chapters 1 and 2 provide a basic introduction to Java concepts and a tutorial to give you a jump-start on Java programming.

Chapter 3 discusses fundamental tools for developing with Java (the compiler, the interpreter, jshell, and the JAR file package).

Chapters 4 and 5 introduce programming fundamentals, then describe the Java language itself, beginning with the basic syntax and then covering classes and objects, exceptions, arrays, enumerations, annotations, and much more.

Chapter 6 covers exceptions, errors, and the logging facilities native to Java.

Chapter 7 covers collections alongside generics and parameterized types in Java.

Chapter 8 covers text processing, formatting, scanning, string utilities, and much of the core API utilities.

Chapter 9 covers the language’s built-in thread facilities.

Chapter 10 covers the basics of graphical user interface (GUI) development with Swing.

Chapter 11 covers Java I/O, streams, files, sockets, networking, and the NIO package.

Chapter 12 covers web applications using servlets, servlet filters, and WAR files, as well as web services.

Chapter 13 introduces the Java Community Process and highlights how to track future changes to Java while helping you retrofit existing code with new features, such as the lambda expressions introduced in Java 8.

If you’re like us, you don’t read books from front to back. If you’re really like us, you usually don’t read the preface at all. However, on the off chance that you will see this in time, here are a few suggestions:

If you are already a programmer and just need to learn Java in the next five minutes, you are probably looking for the examples. You might want to start by glancing at the tutorial in Chapter 2. If that doesn’t float your boat, you should at least look at the information in Chapter 3, which explains how to use the compiler and interpreter. This should get you started.

Chapters 11 and 12 are the places to head if you are interested in writing network or web-based applications and services. Networking remains one of the more interesting and important parts of Java.

Chapter 10 discusses Java’s graphics features and component architecture. You should read this if you are interested in writing desktop graphical Java applications.

Chapter 13 discusses how to stay on top of changes to the Java language itself, regardless of your particular focus.” (B086L2NYWR)

Online Resources

“There are many online sources for information about Java.

Oracle’s official website for Java topics is https://oreil.ly/Lo8QZ; look here for the software, updates, and Java releases. This is where you’ll find the reference implementation of the JDK, which includes the compiler, the interpreter, and other tools.

Oracle also maintains the OpenJDK site. This is the primary open source version of Java and the associated tools. We’ll be using the OpenJDK for all the examples in this book.

You should also visit O’Reilly’s site at http://oreilly.com/. There you’ll find information about other O’Reilly books for both Java and a growing array of other topics. You should also check out the online learning and conference options — O’Reilly is a real champion for education in all its forms.

And of course, you can check the home page for Learning Java!” (B086L2NYWR)

Conventions Used in This Book

“The font conventions used in this book are quite simple.

Italic is used for:

Pathnames, filenames, and program names

Internet addresses, such as domain names and URLs

New terms where they are defined

Program names, compilers, interpreters, utilities, and commands

Threads

Constant width is used for:

Anything that might appear in a Java program, including method names, variable names, and class names

Tags that might appear in an HTML or XML document

Keywords, objects, and environment variables

Constant width bold is used for:

Text that is typed by the user on the command line or in a dialog

Constant width italic is used for:

Replaceable items in code

In the main body of text, we always use a pair of empty parentheses after a method name to distinguish methods from variables and other creatures.

In the Java source listings, we follow the coding conventions most frequently used in the Java community. Class names begin with capital letters; variable and method names begin with lowercase. All the letters in the names of constants are capitalized. We don’t use underscores to separate words in a long name; following common practice, we capitalize individual words (after the first) and run the words together. For example: thisIsAVariable, thisIsAMethod(), ThisIsAClass, and THIS_IS_A_CONSTANT. Also, note that we differentiate between static and nonstatic methods when we refer to them. Unlike some books, we never write Foo.bar() to mean the bar() method of Foo unless bar() is a static method (paralleling the Java syntax in that case).” (B086L2NYWR)

Table of Contents:

(B086L2NYWR)

Preface Who Should Read This Book

New Developments New in This Edition (Java 11, 12, 13, 14)

Using This Book

Online Resources

Conventions Used in This Book

Using Code Examples

O’Reilly Online Learning

How to Contact Us

Acknowledgments

  1. A Modern Language Enter Java Java’s Origins

Growing Up

A Virtual Machine

Java Compared with Other Languages

Safety of Design Simplify, Simplify, Simplify…

Type Safety and Method Binding

Incremental Development

Dynamic Memory Management

Error Handling

Threads

Scalability

Safety of Implementation The Verifier

Class Loaders

Security Managers

Application and User-Level Security

A Java Road Map The Past: Java 1.0–Java 11

The Present: Java 14

The Future

Availability

  1. A First Application Java Tools and Environment Installing the JDK

Installing OpenJDK on Linux

Installing OpenJDK on macOS

Installing OpenJDK on Windows

Configuring IntelliJ IDEA and Creating a Project

Running the Project

Grabbing the Learning Java Examples

HelloJava Classes

The main() Method

Classes and Objects

Variables and Class Types

HelloComponent

Inheritance

The JComponent Class

Relationships and Finger-Pointing

Package and Imports

The paintComponent() Method

HelloJava2: The Sequel Instance Variables

Constructors

Events

The repaint() Method

Interfaces

Goodbye and Hello Again

  1. Tools of the Trade JDK Environment

The Java VM

Running Java Applications System Properties

The Classpath javap

Modules

The Java Compiler

Trying Java

JAR Files and Java JAR File Compression

The jar Utility

The pack200 Utility

Building Up

  1. The Java Language Text Encoding

Comments Javadoc Comments

Variables and Constants

Types Primitive Types

Reference Types

Inferring Types

Passing References

A Word About Strings

Statements and Expressions Statements

Expressions

Arrays Array Types

Array Creation and Initialization

Using Arrays

Anonymous Arrays

Multidimensional Arrays

Types and Classes and Arrays, Oh My!

  1. Objects in Java Classes Declaring and Instantiating Classes

Accessing Fields and Methods

Static Members

Methods Local Variables

Shadowing

Static Methods

Initializing Local Variables

Argument Passing and References

Wrappers for Primitive Types

Method Overloading

Object Creation Constructors

Working with Overloaded Constructors

Object Destruction Garbage Collection

Packages Importing Classes

Custom Packages

Member Visibility and Access

Compiling with Packages

Advanced Class Design Subclassing and Inheritance

Interfaces

Inner Classes

Anonymous Inner Classes

Organizing Content and Planning for Failure

  1. Error Handling and Logging Exceptions Exceptions and Error Classes

Exception Handling

Bubbling Up

Stack Traces

Checked and Unchecked Exceptions

Throwing Exceptions

try Creep

The finally Clause

try with Resources

Performance Issues

Assertions Enabling and Disabling Assertions

Using Assertions

The Logging API Overview

Logging Levels

A Simple Example

Logging Setup Properties

The Logger

Performance

Real-World Exceptions

  1. Collections and Generics Collections The Collection Interface

Collection Types

The Map Interface

Type Limitations Containers: Building a Better Mousetrap

Can Containers Be Fixed?

Enter Generics Talking About Types

“There Is No Spoon” Erasure

Raw Types

Parameterized Type Relationships Why Isn’t a List a List

Colophon

The animals on the cover of Learning Java, Fifth Edition are a Bengal tiger and her cubs. (B086L2NYWR)

Sources:

Fair Use Sources: