Contents

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Previous Chapter

Contents at a Glance

Contents

Part I The Java Language

Chapter 1 The History and Evolution of Java

Java’s Lineage

The Birth of Modern Programming: C

C++: The Next Step

The Stage Is Set for Java

The Creation of Java

The C# Connection

How Java Impacted the Internet

Java’s Magic: The Bytecode

Moving Beyond Applets

Servlets: Java on the Server Side

The Java Buzzwords

Object-Oriented

Architecture-Neutral

Interpreted and High Performance

The Evolution of Java

A Culture of Innovation

Chapter 2 An Overview of Java

Object-Oriented Programming

The Three OOP Principles

A First Simple Program

Entering the Program

Compiling the Program

A Closer Look at the First Sample Program

A Second Short Program

Two Control Statements

The if Statement

Using Blocks of Code

The Java Keywords

The Java Class Libraries

Chapter 3 Data Types, Variables, and Arrays

Java Is a Strongly Typed Language

The Primitive Types

Floating-Point Types

A Closer Look at Literals

Integer Literals

Floating-Point Literals

Boolean Literals

Character Literals

String Literals

Declaring a Variable

Dynamic Initialization

The Scope and Lifetime of Variables

Type Conversion and Casting

Java’s Automatic Conversions

Casting Incompatible Types

Automatic Type Promotion in Expressions

The Type Promotion Rules

One-Dimensional Arrays

Multidimensional Arrays

Alternative Array Declaration Syntax

A Few Words About Strings

Chapter 4 Operators

Arithmetic Operators

The Basic Arithmetic Operators

The Modulus Operator

Arithmetic Compound Assignment Operators

Increment and Decrement

The Bitwise Operators

The Bitwise Logical Operators

The Right Shift

The Unsigned Right Shift

Bitwise Operator Compound Assignments

Relational Operators

Boolean Logical Operators

Short-Circuit Logical Operators

The Assignment Operator

Operator Precedence

Using Parentheses

Chapter 5 Control Statements

Java’s Selection Statements

Iteration Statements

The For-Each Version of the for Loop

Jump Statements

Chapter 6 Introducing Classes

Class Fundamentals

The General Form of a Class

Declaring Objects

A Closer Look at new

Assigning Object Reference Variables

Introducing Methods

Adding a Method to the Box Class

Returning a Value

Adding a Method That Takes Parameters

Parameterized Constructors

The this Keyword

Instance Variable Hiding

Garbage Collection

Chapter 7 A Closer Look at Methods and Classes

Overloading Methods

Overloading Constructors

Using Objects as Parameters

A Closer Look at Argument Passing

Returning Objects

Introducing Access Control

Understanding static

Introducing final

Arrays Revisited

Introducing Nested and Inner Classes

Exploring the String Class

Using Command-Line Arguments

Varargs: Variable-Length Arguments

Overloading Vararg Methods

Varargs and Ambiguity

Chapter 8 Inheritance

Inheritance Basics

Member Access and Inheritance

A More Practical Example

A Superclass Variable Can Reference a Subclass Object

Using super to Call Superclass Constructors

A Second Use for super

Creating a Multilevel Hierarchy

When Constructors Are Executed

Method Overriding

Dynamic Method Dispatch

Why Overridden Methods?

Applying Method Overriding

Using Abstract Classes

Using final with Inheritance

Using final to Prevent Overriding

Using final to Prevent Inheritance

The Object Class

Chapter 9 Packages and Interfaces

Defining a Package

Finding Packages and CLASSPATH

A Short Package Example

Packages and Member Access

An Access Example

Importing Packages

Defining an Interface

Implementing Interfaces

Nested Interfaces

Applying Interfaces

Variables in Interfaces

Interfaces Can Be Extended

Default Interface Methods

Default Method Fundamentals

A More Practical Example

Multiple Inheritance Issues

Use static Methods in an Interface

Private Interface Methods

Final Thoughts on Packages and Interfaces

Chapter 10 Exception Handling

Exception-Handling Fundamentals

Exception Types

Uncaught Exceptions

Using try and catch

Displaying a Description of an Exception

Multiple catch Clauses

Nested try Statements

Java’s Built-in Exceptions

Creating Your Own Exception Subclasses

Chained Exceptions

Three Additional Exception Features

Using Exceptions

Chapter 11 Multithreaded Programming

The Java Thread Model

Thread Priorities

Synchronization

The Thread Class and the Runnable Interface

The Main Thread

Creating a Thread

Implementing Runnable

Extending Thread

Choosing an Approach

Creating Multiple Threads

Using isAlive( ) and join( )

Thread Priorities

Synchronization

Using Synchronized Methods

The synchronized Statement

Interthread Communication

Suspending, Resuming, and Stopping Threads

Obtaining a Thread’s State

Using a Factory Method to Create and Start a Thread

Using Multithreading

Chapter 12 Enumerations, Autoboxing, and Annotations

Enumeration Fundamentals

The values( ) and valueOf( ) Methods

Java Enumerations Are Class Types

Enumerations Inherit Enum

Another Enumeration Example

The Numeric Type Wrappers

Autoboxing and Methods

Autoboxing/Unboxing Occurs in Expressions

Autoboxing/Unboxing Boolean and Character Values

Autoboxing/Unboxing Helps Prevent Errors

A Word of Warning

Annotation Basics

Specifying a Retention Policy

Obtaining Annotations at Run Time by Use of Reflection

The AnnotatedElement Interface

Using Default Values

Marker Annotations

Single-Member Annotations

The Built-In Annotations

Type Annotations

Repeating Annotations

Some Restrictions

Chapter 13 I/O, Try-with-Resources, and Other Topics

Byte Streams and Character Streams

The Predefined Streams

Reading Console Input

Reading Characters

Reading Strings

Writing Console Output

The PrintWriter Class

Reading and Writing Files

Automatically Closing a File

The transient and volatile Modifiers

Using instanceof

Assertion Enabling and Disabling Options

Invoking Overloaded Constructors Through this( )

A Word About Compact API Profiles

Chapter 14 Generics

What Are Generics?

A Simple Generics Example

Generics Work Only with Reference Types

Generic Types Differ Based on Their Type Arguments

How Generics Improve Type Safety

A Generic Class with Two Type Parameters

The General Form of a Generic Class

Using Wildcard Arguments

Bounded Wildcards

Creating a Generic Method

Generic Constructors

Generic Interfaces

Raw Types and Legacy Code

Generic Class Hierarchies

Using a Generic Superclass

A Generic Subclass

Run-Time Type Comparisons Within a Generic Hierarchy

Overriding Methods in a Generic Class

Type Inference with Generics

Ambiguity Errors

Some Generic Restrictions

Type Parameters Can’t Be Instantiated

Restrictions on Static Members

Generic Array Restrictions

Generic Exception Restriction

Chapter 15 Lambda Expressions

Introducing Lambda Expressions

Lambda Expression Fundamentals

Functional Interfaces

Some Lambda Expression Examples

Block Lambda Expressions

Generic Functional Interfaces

Passing Lambda Expressions as Arguments

Lambda Expressions and Exceptions

Lambda Expressions and Variable Capture

Method References

Method References to static Methods

Method References to Instance Methods

Method References with Generics

Constructor References

Predefined Functional Interfaces

Chapter 16 Modules

A Simple Module Example

Compile and Run the First Module Example

A Closer Look at requires and exports

java.base and the Platform Modules

Legacy Code and the Unnamed Module

Exporting to a Specific Module

Using requires transitive

Service and Service Provider Basics

The Service-Based Keywords

A Module-Based Service Example

Three Specialized Module Features

The opens Statement

requires static

Introducing jlink and Module JAR Files

Linking Files in an Exploded Directory

Linking Modular JAR Files

A Brief Word About Layers and Automatic Modules

Final Thoughts on Modules

Part II The Java Library

Chapter 17 String Handling

The String Constructors

Special String Operations

String Literals

String Concatenation

String Concatenation with Other Data Types

String Conversion and toString( )

Character Extraction

String Comparison

equals( ) and equalsIgnoreCase( )

regionMatches( )

startsWith( ) and endsWith( )

equals( ) Versus ==

Searching Strings

Modifying a String

Data Conversion Using valueOf( )

Changing the Case of Characters Within a String

Joining Strings

Additional String Methods

StringBuffer Constructors

length( ) and capacity( )

ensureCapacity( )

charAt( ) and setCharAt( )

delete( ) and deleteCharAt( )

Additional StringBuffer Methods

Chapter 18 Exploring java.lang

Primitive Type Wrappers

Double and Float

Understanding isInfinite( ) and isNaN( )

Byte, Short, Integer, and Long

Additions to Character for Unicode Code Point Support

Memory Management

Executing Other Programs

Runtime.Version

Using currentTimeMillis( ) to Time Program Execution

Using arraycopy( )

Environment Properties

System.Logger and System.LoggerFinder

Using clone( ) and the Cloneable Interface

Trigonometric Functions

Exponential Functions

Rounding Functions

Miscellaneous Math Methods

Thread, ThreadGroup, and Runnable

The Runnable Interface

ThreadLocal and InheritableThreadLocal

RuntimePermission

SecurityManager

StackTraceElement

StackWalker and StackWalker.StackFrame

The CharSequence Interface

The Comparable Interface

The Appendable Interface

The Iterable Interface

The Readable Interface

The AutoCloseable Interface

The Thread.UncaughtExceptionHandler Interface

The java.lang Subpackages

java.lang.annotation

java.lang.instrument

java.lang.invoke

java.lang.module

java.lang.management

java.lang.reflect

Chapter 19 java.util Part 1: The Collections Framework

Collections Overview

The Collection Interfaces

The Collection Interface

The List Interface

The Set Interface

The SortedSet Interface

The NavigableSet Interface

The Queue Interface

The Deque Interface

The Collection Classes

The ArrayList Class

The LinkedList Class

The HashSet Class

The LinkedHashSet Class

The TreeSet Class

The PriorityQueue Class

The ArrayDeque Class

The EnumSet Class

Accessing a Collection via an Iterator

Using an Iterator

The For-Each Alternative to Iterators

Storing User-Defined Classes in Collections

The RandomAccess Interface

Working with Maps

The Map Interfaces

The Map Classes

Using a Comparator

The Collection Algorithms

The Legacy Classes and Interfaces

The Enumeration Interface

Using store( ) and load( )

Parting Thoughts on Collections

Chapter 20 java.util Part 2: More Utility Classes

StringTokenizer

Optional, OptionalDouble, OptionalInt, and OptionalLong

GregorianCalendar

Timer and TimerTask

The Formatter Constructors

The Formatter Methods

Formatting Basics

Formatting Strings and Characters

Formatting Numbers

Formatting Time and Date

The %n and %% Specifiers

Specifying a Minimum Field Width

Specifying Precision

Using the Format Flags

Justifying Output

The Space, +, 0, and ( Flags

The Uppercase Option

Using an Argument Index

Closing a Formatter

The Java printf( ) Connection

The Scanner Constructors

Scanning Basics

Some Scanner Examples

Setting Delimiters

Other Scanner Features

The ResourceBundle, ListResourceBundle, and PropertyResourceBundle Classes

Miscellaneous Utility Classes and Interfaces

The java.util Subpackages

java.util.concurrent, java.util.concurrent.atomic, and java.util.concurrent.locks

java.util.function

java.util.logging

java.util.prefs

java.util.regex

java.util.stream

Chapter 21 Input/Output: Exploring java.io

The I/O Classes and Interfaces

Using FilenameFilter

The listFiles( ) Alternative

Creating Directories

The AutoCloseable, Closeable, and Flushable Interfaces

Two Ways to Close a Stream

The Stream Classes

The Byte Streams

FileInputStream

FileOutputStream

ByteArrayInputStream

ByteArrayOutputStream

Filtered Byte Streams

Buffered Byte Streams

SequenceInputStream

DataOutputStream and DataInputStream

RandomAccessFile

The Character Streams

CharArrayReader

CharArrayWriter

The Console Class

ObjectOutputStream

ObjectInputStream

A Serialization Example

Stream Benefits

Chapter 22 Exploring NIO

The NIO Classes

NIO Fundamentals

Charsets and Selectors

Enhancements Added by NIO.2

The Path Interface

The Files Class

The Paths Class

The File Attribute Interfaces

The FileSystem, FileSystems, and FileStore Classes

Using the NIO System

Use NIO for Channel-Based I/O

Use NIO for Stream-Based I/O

Use NIO for Path and File System Operations

Chapter 23 Networking

Networking Basics

The Networking Classes and Interfaces

Factory Methods

Instance Methods

Inet4Address and Inet6Address

TCP/IP Client Sockets

HttpURLConnection

TCP/IP Server Sockets

A Datagram Example

Chapter 24 Event Handling

Two Event Handling Mechanisms

The Delegation Event Model

Event Listeners

The ActionEvent Class

The AdjustmentEvent Class

The ComponentEvent Class

The ContainerEvent Class

The FocusEvent Class

The InputEvent Class

The ItemEvent Class

The KeyEvent Class

The MouseEvent Class

The MouseWheelEvent Class

The TextEvent Class

The WindowEvent Class

Sources of Events

Event Listener Interfaces

The ActionListener Interface

The AdjustmentListener Interface

The ComponentListener Interface

The ContainerListener Interface

The FocusListener Interface

The ItemListener Interface

The KeyListener Interface

The MouseListener Interface

The MouseMotionListener Interface

The MouseWheelListener Interface

The TextListener Interface

The WindowFocusListener Interface

The WindowListener Interface

Using the Delegation Event Model

Some Key AWT GUI Concepts

Handling Mouse Events

Handling Keyboard Events

Adapter Classes

Anonymous Inner Classes

Chapter 25 Introducing the AWT: Working with Windows, Graphics, and Text

Window Fundamentals

Working with Frame Windows

Setting the Window’s Dimensions

Hiding and Showing a Window

Setting a Window’s Title

Closing a Frame Window

The paint( ) Method

Displaying a String

Setting the Foreground and Background Colors

Requesting Repainting

Creating a Frame-Based Application

Introducing Graphics

Drawing Rectangles

Drawing Ellipses and Circles

Drawing Polygons

Demonstrating the Drawing Methods

Sizing Graphics

Working with Color

Setting the Current Graphics Color

A Color Demonstration Program

Setting the Paint Mode

Working with Fonts

Determining the Available Fonts

Creating and Selecting a Font

Obtaining Font Information

Managing Text Output Using FontMetrics

Chapter 26 Using AWT Controls, Layout Managers, and Menus

AWT Control Fundamentals

Adding and Removing Controls

Responding to Controls

The HeadlessException

Handling Buttons

Applying Check Boxes

Handling Check Boxes

Choice Controls

Handling Choice Lists

Managing Scroll Bars

Handling Scroll Bars

Using a TextField

Handling a TextField

Using a TextArea

Understanding Layout Managers

Menu Bars and Menus

A Word About Overriding paint( )

Chapter 27 Images

Image Fundamentals: Creating, Loading, and Displaying

Creating an Image Object

Loading an Image

Displaying an Image

Double Buffering

MemoryImageSource

CropImageFilter

Additional Imaging Classes

Chapter 28 The Concurrency Utilities

The Concurrent API Packages

java.util.concurrent

java.util.concurrent.atomic

java.util.concurrent.locks

Using Synchronization Objects

Using an Executor

A Simple Executor Example

Using Callable and Future

The TimeUnit Enumeration

The Concurrent Collections

Atomic Operations

Parallel Programming via the Fork/Join Framework

The Main Fork/Join Classes

The Divide-and-Conquer Strategy

A Simple First Fork/Join Example

Understanding the Impact of the Level of Parallelism

An Example that Uses RecursiveTask<V>

Executing a Task Asynchronously

Cancelling a Task

Determining a Task’s Completion Status

Restarting a Task

Things to Explore

Some Fork/Join Tips

The Concurrency Utilities Versus Java’s Traditional Approach

Chapter 29 The Stream API

Stream Interfaces

How to Obtain a Stream

A Simple Stream Example

Reduction Operations

Using Parallel Streams

Iterators and Streams

Use an Iterator with a Stream

Use Spliterator

More to Explore in the Stream API

Chapter 30 Regular Expressions and Other Packages

Regular Expression Processing

Regular Expression Syntax

Demonstrating Pattern Matching

Two Pattern-Matching Options

Exploring Regular Expressions

Remote Method Invocation (RMI)

A Simple Client/Server Application Using RMI

Formatting Date and Time with java.text

DateFormat Class

SimpleDateFormat Class

The java.time Time and Date API

Time and Date Fundamentals

Formatting Date and Time

Parsing Date and Time Strings

Other Things to Explore in java.time

Part III Introducing GUI Programming with Swing

Chapter 31 Introducing Swing

The Origins of Swing

Swing Is Built on the AWT

Two Key Swing Features

Swing Components Are Lightweight

Swing Supports a Pluggable Look and Feel

The MVC Connection

Components and Containers

The Top-Level Container Panes

The Swing Packages

A Simple Swing Application

Painting in Swing

Painting Fundamentals

Compute the Paintable Area

A Paint Example

Chapter 32 Exploring Swing

JLabel and ImageIcon

The Swing Buttons

Chapter 33 Introducing Swing Menus

An Overview of JMenuBar, JMenu, and JMenuItem

Create a Main Menu

Add Mnemonics and Accelerators to Menu Items

Add Images and Tooltips to Menu Items

Use JRadioButtonMenuItem and JCheckBoxMenuItem

Create a Popup Menu

Create a Toolbar

Put the Entire MenuDemo Program Together

Continuing Your Exploration of Swing

Part IV Introducing GUI Programming with JavaFX

Chapter 34 Introducing JavaFX GUI Programming

JavaFX Basic Concepts

The JavaFX Packages

The Stage and Scene Classes

Nodes and Scene Graphs

The Application Class and the Life-cycle Methods

Launching a JavaFX Application

A JavaFX Application Skeleton

Compiling and Running a JavaFX Program

The Application Thread

A Simple JavaFX Control: Label

Using Buttons and Events

Introducing the Button Control

Demonstrating Event Handling and the Button

Drawing Directly on a Canvas

Chapter 35 Exploring JavaFX Controls

Using Image and ImageView

Adding an Image to a Label

Using an Image with a Button

Handling Change Events in a Toggle Group

An Alternative Way to Handle Radio Buttons

ListView Scroll Bars

Enabling Multiple Selections

Introducing Effects and Transforms

Demonstrating Effects and Transforms

Adding Tooltips

Disabling a Control

Chapter 36 Introducing JavaFX Menus

An Overview of MenuBar, Menu, and MenuItem

Create a Main Menu

Add Mnemonics and Accelerators to Menu Items

Add Images to Menu Items

Use RadioMenuItem and CheckMenuItem

Create a Context Menu

Create a Toolbar

Put the Entire MenuDemo Program Together

Continuing Your Exploration of JavaFX

Part V Applying Java

Chapter 37 Java Beans

What Is a Java Bean?

Advantages of Java Beans

Design Patterns for Properties

Design Patterns for Events

Methods and Design Patterns

Using the BeanInfo Interface

Bound and Constrained Properties

The Java Beans API

PropertyDescriptor

EventSetDescriptor

MethodDescriptor

Chapter 38 Introducing Servlets

The Life Cycle of a Servlet

Servlet Development Options

A Simple Servlet

Create and Compile the Servlet Source Code

Start a Web Browser and Request the Servlet

The Servlet API

The javax.servlet Package

The Servlet Interface

The ServletConfig Interface

The ServletContext Interface

The ServletRequest Interface

The ServletResponse Interface

The GenericServlet Class

The ServletInputStream Class

The ServletOutputStream Class

The Servlet Exception Classes

Reading Servlet Parameters

The javax.servlet.http Package

The HttpServletRequest Interface

The HttpServletResponse Interface

The HttpSession Interface

The Cookie Class

The HttpServlet Class

Handling HTTP Requests and Responses

Handling HTTP GET Requests

Handling HTTP POST Requests

Session Tracking

Part VI Appendixes

Appendix A Using Java’s Documentation Comments

The javadoc Tags

The General Form of a Documentation Comment

What javadoc Outputs

An Example that Uses Documentation Comments

Appendix B An Overview of Java Web Start

What Is Java Web Start?

Four Key Java Web Start Essentials

Java Web Start Apps Require a JAR File

Java Web Start Apps Are Signed

Java Web Start Relies on JNLP

Linking to the Java Web Start JNLP File

Experimenting with Java Web Start Using the Local File System

Create a JAR File for ToggleButtonDemo

Create a Keystore and Sign ToggleButtonDemo.jar

Create a JNLP File for ToggleButtonDemo

Create a Short HTML File Called StartTBD.html

Add ToggleButtonDemo.jnlp to the Exception Site List in the Java Control Panel

Execute ToggleButtonDemo via Your Browser

Running a Java Web Start Application Using javaws

Using Java Web Start with an Applet

Appendix C Introducing JShell

List, Edit, and Rerun Code

Use an Interface

Evaluate Expressions and Use Built-in Variables

Importing Packages

Some More JShell Commands

Exploring JShell Further

Appendix D Applet Basics

Two Types of Applets

The Applet Class

Applet Architecture

An Applet Skeleton

Applet Initialization and Termination

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.

18.218.78.102