book

Core Java® Volume I—Fundamentals, Tenth Edition

Name: Core Java® Volume I—Fundamentals, Tenth Edition
Author: Cay S. Horstmann
ISBN: 9780134177335

by Cay S. Horstmann

December 2015

Intermediate to advanced

1032 pages

29h 4m

English

Pearson

Read now

Unlock full access

About This E-Book
Title Page
Copyright Page
Contents
Preface
To the ReaderA Tour of This BookConventionsSample Code
Acknowledgments
Chapter 1. An Introduction to Java
1.1 Java as a Programming Platform1.2 The Java “White Paper” Buzzwords1.2.1 Simple1.2.2 Object-Oriented1.2.3 Distributed1.2.4 Robust1.2.5 Secure1.2.6 Architecture-Neutral1.2.7 Portable1.2.8 Interpreted1.2.9 High-Performance1.2.10 Multithreaded1.2.11 Dynamic1.3 Java Applets and the Internet1.4 A Short History of Java1.5 Common Misconceptions about Java
Chapter 2. The Java Programming Environment
2.1 Installing the Java Development Kit2.1.1 Downloading the JDK2.1.2 Setting up the JDK2.1.3 Installing Source Files and Documentation2.2 Using the Command-Line Tools2.3 Using an Integrated Development Environment2.4 Running a Graphical Application2.5 Building and Running Applets
Chapter 3. Fundamental Programming Structures in Java
3.1 A Simple Java Program3.2 Comments3.3 Data Types3.3.1 Integer Types3.3.2 Floating-Point Types3.3.3 The char Type3.3.4 Unicode and the char Type3.3.5 The boolean Type3.4 Variables3.4.1 Initializing Variables3.4.2 Constants3.5 Operators3.5.1 Mathematical Functions and Constants3.5.2 Conversions between Numeric Types3.5.3 Casts3.5.4 Combining Assignment with Operators3.5.5 Increment and Decrement Operators3.5.6 Relational and boolean Operators3.5.7 Bitwise Operators3.5.8 Parentheses and Operator Hierarchy3.5.9 Enumerated Types3.6 Strings3.6.1 Substrings3.6.2 Concatenation3.6.3 Strings Are Immutable3.6.4 Testing Strings for Equality3.6.5 Empty and Null Strings3.6.6 Code Points and Code Units3.6.7 The String API3.6.8 Reading the Online API Documentation3.6.9 Building Strings3.7 Input and Output3.7.1 Reading Input3.7.2 Formatting Output3.7.3 File Input and Output3.8 Control Flow3.8.1 Block Scope3.8.2 Conditional Statements3.8.3 Loops3.8.4 Determinate Loops3.8.5 Multiple Selections—The switch Statement3.8.6 Statements That Break Control Flow3.9 Big Numbers3.10 Arrays3.10.1 The “for each” Loop3.10.2 Array Initializers and Anonymous Arrays3.10.3 Array Copying3.10.4 Command-Line Parameters3.10.5 Array Sorting3.10.6 Multidimensional Arrays3.10.7 Ragged Arrays
Chapter 4. Objects and Classes
4.1 Introduction to Object-Oriented Programming4.1.1 Classes4.1.2 Objects4.1.3 Identifying Classes4.1.4 Relationships between Classes4.2 Using Predefined Classes4.2.1 Objects and Object Variables4.2.2 The LocalDate Class of the Java Library4.2.3 Mutator and Accessor Methods4.3 Defining Your Own Classes4.3.1 An Employee Class4.3.2 Use of Multiple Source Files4.3.3 Dissecting the Employee Class4.3.4 First Steps with Constructors4.3.5 Implicit and Explicit Parameters4.3.6 Benefits of Encapsulation4.3.7 Class-Based Access Privileges4.3.8 Private Methods4.3.9 Final Instance Fields4.4 Static Fields and Methods4.4.1 Static Fields4.4.2 Static Constants4.4.3 Static Methods4.4.4 Factory Methods4.4.5 The main Method4.5 Method Parameters4.6 Object Construction4.6.1 Overloading4.6.2 Default Field Initialization4.6.3 The Constructor with No Arguments4.6.4 Explicit Field Initialization4.6.5 Parameter Names4.6.6 Calling Another Constructor4.6.7 Initialization Blocks4.6.8 Object Destruction and the finalize Method4.7 Packages4.7.1 Class Importation4.7.2 Static Imports4.7.3 Addition of a Class into a Package4.7.4 Package Scope4.8 The Class Path4.8.1 Setting the Class Path4.9 Documentation Comments4.9.1 Comment Insertion4.9.2 Class Comments4.9.3 Method Comments4.9.4 Field Comments4.9.5 General Comments4.9.6 Package and Overview Comments4.9.7 Comment Extraction4.10 Class Design Hints

Chapter 5. Inheritance
5.1 Classes, Superclasses, and Subclasses5.1.1 Defining Subclasses5.1.2 Overriding Methods5.1.3 Subclass Constructors5.1.4 Inheritance Hierarchies5.1.5 Polymorphism5.1.6 Understanding Method Calls5.1.7 Preventing Inheritance: Final Classes and Methods5.1.8 Casting5.1.9 Abstract Classes5.1.10 Protected Access5.2 Object: The Cosmic Superclass5.2.1 The equals Method5.2.2 Equality Testing and Inheritance5.2.3 The hashCode Method5.2.4 The toString Method5.3 Generic Array Lists5.3.1 Accessing Array List Elements5.3.2 Compatibility between Typed and Raw Array Lists5.4 Object Wrappers and Autoboxing5.5 Methods with a Variable Number of Parameters5.6 Enumeration Classes5.7 Reflection5.7.1 The Class Class5.7.2 A Primer on Catching Exceptions5.7.3 Using Reflection to Analyze the Capabilities of Classes5.7.4 Using Reflection to Analyze Objects at Runtime5.7.5 Using Reflection to Write Generic Array Code5.7.6 Invoking Arbitrary Methods5.8 Design Hints for Inheritance
Chapter 6. Interfaces, Lambda Expressions, and Inner Classes
6.1 Interfaces6.1.1 The Interface Concept6.1.2 Properties of Interfaces6.1.3 Interfaces and Abstract Classes6.1.4 Static Methods6.1.5 Default Methods6.1.6 Resolving Default Method Conflicts6.2 Examples of Interfaces6.2.1 Interfaces and Callbacks6.2.2 The Comparator Interface6.2.3 Object Cloning6.3 Lambda Expressions6.3.1 Why Lambdas?6.3.2 The Syntax of Lambda Expressions6.3.3 Functional Interfaces6.3.4 Method References6.3.5 Constructor References6.3.6 Variable Scope6.3.7 Processing Lambda Expressions6.3.8 More about Comparators6.4 Inner Classes6.4.1 Use of an Inner Class to Access Object State6.4.2 Special Syntax Rules for Inner Classes6.4.3 Are Inner Classes Useful? Actually Necessary? Secure?6.4.4 Local Inner Classes6.4.5 Accessing Variables from Outer Methods6.4.6 Anonymous Inner Classes6.4.7 Static Inner Classes6.5 Proxies6.5.1 When to Use Proxies6.5.2 Creating Proxy Objects6.5.3 Properties of Proxy Classes
Chapter 7. Exceptions, Assertions, and Logging
7.1 Dealing with Errors7.1.1 The Classification of Exceptions7.1.2 Declaring Checked Exceptions7.1.3 How to Throw an Exception7.1.4 Creating Exception Classes7.2 Catching Exceptions7.2.1 Catching an Exception7.2.2 Catching Multiple Exceptions7.2.3 Rethrowing and Chaining Exceptions7.2.4 The finally Clause7.2.5 The Try-with-Resources Statement7.2.6 Analyzing Stack Trace Elements7.3 Tips for Using Exceptions7.4 Using Assertions7.4.1 The Assertion Concept7.4.2 Assertion Enabling and Disabling7.4.3 Using Assertions for Parameter Checking7.4.4 Using Assertions for Documenting Assumptions7.5 Logging7.5.1 Basic Logging7.5.2 Advanced Logging7.5.3 Changing the Log Manager Configuration7.5.4 Localization7.5.5 Handlers7.5.6 Filters7.5.7 Formatters7.5.8 A Logging Recipe7.6 Debugging Tips
Chapter 8. Generic Programming
8.1 Why Generic Programming?8.1.1 The Advantage of Type Parameters8.1.2 Who Wants to Be a Generic Programmer?8.2 Defining a Simple Generic Class8.3 Generic Methods8.4 Bounds for Type Variables8.5 Generic Code and the Virtual Machine8.5.1 Type Erasure8.5.2 Translating Generic Expressions8.5.3 Translating Generic Methods8.5.4 Calling Legacy Code8.6 Restrictions and Limitations8.6.1 Type Parameters Cannot Be Instantiated with Primitive Types8.6.2 Runtime Type Inquiry Only Works with Raw Types8.6.3 You Cannot Create Arrays of Parameterized Types8.6.4 Varargs Warnings8.6.5 You Cannot Instantiate Type Variables8.6.6 You Cannot Construct a Generic Array8.6.7 Type Variables Are Not Valid in Static Contexts of Generic Classes8.6.8 You Cannot Throw or Catch Instances of a Generic Class8.6.9 You Can Defeat Checked Exception Checking8.6.10 Beware of Clashes after Erasure8.7 Inheritance Rules for Generic Types8.8 Wildcard Types8.8.1 The Wildcard Concept8.8.2 Supertype Bounds for Wildcards8.8.3 Unbounded Wildcards8.8.4 Wildcard Capture8.9 Reflection and Generics8.9.1 The Generic Class Class8.9.2 Using Class<T> Parameters for Type Matching8.9.3 Generic Type Information in the Virtual Machine
Chapter 9. Collections
9.1 The Java Collections Framework9.1.1 Separating Collection Interfaces and Implementation9.1.2 The Collection Interface9.1.3 Iterators9.1.4 Generic Utility Methods9.1.5 Interfaces in the Collections Framework9.2 Concrete Collections9.2.1 Linked Lists9.2.2 Array Lists9.2.3 Hash Sets9.2.4 Tree Sets9.2.5 Queues and Deques9.2.6 Priority Queues9.3 Maps9.3.1 Basic Map Operations9.3.2 Updating Map Entries9.3.3 Map Views9.3.4 Weak Hash Maps9.3.5 Linked Hash Sets and Maps9.3.6 Enumeration Sets and Maps9.3.7 Identity Hash Maps9.4 Views and Wrappers9.4.1 Lightweight Collection Wrappers9.4.2 Subranges9.4.3 Unmodifiable Views9.4.4 Synchronized Views9.4.5 Checked Views9.4.6 A Note on Optional Operations9.5 Algorithms9.5.1 Sorting and Shuffling9.5.2 Binary Search9.5.3 Simple Algorithms9.5.4 Bulk Operations9.5.5 Converting between Collections and Arrays9.5.6 Writing Your Own Algorithms9.6 Legacy Collections9.6.1 The Hashtable Class9.6.2 Enumerations9.6.3 Property Maps9.6.4 Stacks9.6.5 Bit Sets
Chapter 10. Graphics Programming
10.1 Introducing Swing10.2 Creating a Frame10.3 Positioning a Frame10.3.1 Frame Properties10.3.2 Determining a Good Frame Size10.4 Displaying Information in a Component10.5 Working with 2D Shapes10.6 Using Color10.7 Using Special Fonts for Text10.8 Displaying Images
Chapter 11. Event Handling
11.1 Basics of Event Handling11.1.1 Example: Handling a Button Click11.1.2 Specifying Listeners Concisely11.1.3 Example: Changing the Look-and-Feel11.1.4 Adapter Classes11.2 Actions11.3 Mouse Events11.4 The AWT Event Hierarchy11.4.1 Semantic and Low-Level Events
Chapter 12. User Interface Components with Swing
12.1 Swing and the Model-View-Controller Design Pattern12.1.1 Design Patterns12.1.2 The Model-View-Controller Pattern12.1.3 A Model-View-Controller Analysis of Swing Buttons12.2 Introduction to Layout Management12.2.1 Border Layout12.2.2 Grid Layout12.3 Text Input12.3.1 Text Fields12.3.2 Labels and Labeling Components12.3.3 Password Fields12.3.4 Text Areas12.3.5 Scroll Panes12.4 Choice Components12.4.1 Checkboxes12.4.2 Radio Buttons12.4.3 Borders12.4.4 Combo Boxes12.4.5 Sliders12.5 Menus12.5.1 Menu Building12.5.2 Icons in Menu Items12.5.3 Checkbox and Radio Button Menu Items12.5.4 Pop-Up Menus12.5.5 Keyboard Mnemonics and Accelerators12.5.6 Enabling and Disabling Menu Items12.5.7 Toolbars12.5.8 Tooltips
12.6 Sophisticated Layout Management
12.6.1 The Grid Bag Layout12.6.2 Group Layout12.6.3 Using No Layout Manager12.6.4 Custom Layout Managers12.6.5 Traversal Order12.7 Dialog Boxes12.7.1 Option Dialogs12.7.2 Creating Dialogs12.7.3 Data Exchange12.7.4 File Dialogs12.7.5 Color Choosers12.8 Troubleshooting GUI Programs12.8.1 Debugging Tips12.8.2 Letting the AWT Robot Do the Work
Chapter 13. Deploying Java Applications
13.1 JAR Files13.1.1 Creating JAR files13.1.2 The Manifest13.1.3 Executable JAR Files13.1.4 Resources13.1.5 Sealing13.2 Storage of Application Preferences13.2.1 Property Maps13.2.2 The Preferences API13.3 Service Loaders13.4 Applets13.4.1 A Simple Applet13.4.2 The applet HTML Tag and Its Attributes13.4.3 Use of Parameters to Pass Information to Applets13.4.4 Accessing Image and Audio Files13.4.5 The Applet Context13.4.6 Inter-Applet Communication13.4.7 Displaying Items in the Browser13.4.8 The Sandbox13.4.9 Signed Code13.5 Java Web Start13.5.1 Delivering a Java Web Start Application13.5.2 The JNLP API
Chapter 14. Concurrency
14.1 What Are Threads?14.1.1 Using Threads to Give Other Tasks a Chance14.2 Interrupting Threads14.3 Thread States14.3.1 New Threads14.3.2 Runnable Threads14.3.3 Blocked and Waiting Threads14.3.4 Terminated Threads14.4 Thread Properties14.4.1 Thread Priorities14.4.2 Daemon Threads14.4.3 Handlers for Uncaught Exceptions14.5 Synchronization14.5.1 An Example of a Race Condition14.5.2 The Race Condition Explained14.5.3 Lock Objects14.5.4 Condition Objects14.5.5 The synchronized Keyword14.5.6 Synchronized Blocks14.5.7 The Monitor Concept14.5.8 Volatile Fields14.5.9 Final Variables14.5.10 Atomics14.5.11 Deadlocks14.5.12 Thread-Local Variables14.5.13 Lock Testing and Timeouts14.5.14 Read/Write Locks14.5.15 Why the stop and suspend Methods Are Deprecated
14.6 Blocking Queues
14.7 Thread-Safe Collections14.7.1 Efficient Maps, Sets, and Queues14.7.2 Atomic Update of Map Entries14.7.3 Bulk Operations on Concurrent Hash Maps14.7.4 Concurrent Set Views14.7.5 Copy on Write Arrays14.7.6 Parallel Array Algorithms14.7.7 Older Thread-Safe Collections14.8 Callables and Futures14.9 Executors14.9.1 Thread Pools14.9.2 Scheduled Execution14.9.3 Controlling Groups of Tasks14.9.4 The Fork-Join Framework14.9.5 Completable Futures14.10 Synchronizers14.10.1 Semaphores14.10.2 Countdown Latches14.10.3 Barriers14.10.4 Exchangers14.10.5 Synchronous Queues14.11 Threads and Swing14.11.1 Running Time-Consuming Tasks14.11.2 Using the Swing Worker14.11.3 The Single-Thread Rule
Appendix A. Java Keywords
Index
Code Snippets

Content preview from Core Java® Volume I—Fundamentals, Tenth Edition

12.6 Sophisticated Layout Management

So far we’ve been using only the border layout, flow layout, and grid layout for the user interface of our sample applications. For more complex tasks, this is not going to be enough. In this section, we will discuss advanced layout management in detail.

Windows programmers may well wonder why Java makes so much fuss about layout managers. After all, in Windows, layout management is not a big deal; you just use a dialog editor to drag and drop your components onto the surface of a dialog, and then use editor tools to line up components, to space them equally, to center them, and so on. If you are working on a big project, you probably don’t have to worry about component layout at all—a skilled user interface ...

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

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

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

Julian F.

Head of Cybersecurity

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

Addison B.

Field Engineer

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

Amir M.

Data Platform Tech Lead

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

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9780134177335Other

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills