Table Of Content®
Java™ Programming
About the Author
Poornachandra Sarang (popularly known as Dr. Sarang) has been a Java
programmer since its inception way back in 1996. Over the last 15 years,
Dr. Sarang has conducted many train-the-trainer programs, instructor authorization
tests, and corporate training sessions based on Sun Microsystems’ official
curriculum. He has authored several books and journal articles on Java and
various other similar topics. He has been a regular speaker at many international
conferences, including the recent JavaOne 2011. He is also associated with the
University of Mumbai and a few other universities of repute as a visiting/adjunct
faculty and Ph.D. advisor in Computer Science. Dr. Sarang has been invited to
deliver keynote addresses and technical talks at many international research and
technology conferences. Besides Java coding, Dr. Sarang does some architecture
work and is also well recognized in the Enterprise Architecture space.
®
Java™ Programming
Poornachandra Sarang
New York Chicago San Francisco
Lisbon London Madrid Mexico City Milan
New Delhi San Juan Seoul Singapore Sydney Toronto
Copyright © 2012 by The McGraw-Hill Companies. All rights reserved. Except as permitted under the United States Copyright Act of 1976, no
part of this publication may be reproduced or distributed in any form or by any means, or stored in a database or retrieval system, without the
prior written permission of the publisher.
ISBN: 978-0-07-163361-1
MHID: 0-07-163361-8
The material in this eBook also appears in the print version of this title: ISBN: 978-0-07-163360-4,
MHID: 0-07-163360-X
McGraw-Hill eBooks are available at special quantity discounts to use as premiums and sales promotions, or for use in corporate training pro-
grams. To contact a representative please e-mail us at bulksales@mcgraw-hill.com.
All trademarks are trademarks of their respective owners. Rather than put a trademark symbol after every occurrence of a trademarked name, we
use names in an editorial fashion only, and to the benefit of the trademark owner, with no intention of infringement of the trademark. Where such
designations appear in this book, they have been printed with initial caps.
Information has been obtained by McGraw-Hill from sources believed to be reliable. However, because of the possibility of human or mechanical
error by our sources, McGraw-Hill, or others, McGraw-Hill does not guarantee the accuracy, adequacy, or completeness of any information and
is not responsible for any errors or omissions or the results obtained from the use of such information.
TERMS OF USE
This is a copyrighted work and The McGraw-Hill Companies, Inc. (“McGrawHill”) and its licensors reserve all rights in and to the work. Use
of this work is subject to these terms. Except as permitted under the Copyright Act of 1976 and the right to store and retrieve one copy of the
work, you may not decompile, disassemble, reverse engineer, reproduce, modify, create derivative works based upon, transmit, distribute,
disseminate, sell, publish or sublicense the work or any part of it without McGraw-Hill’s prior consent. You may use the work for your own
noncommercial and personal use; any other use of the work is strictly prohibited. Your right to use the work may be terminated if you fail to
comply with these terms.
THE WORK IS PROVIDED “AS IS.” McGRAW-HILL AND ITS LICENSORS MAKE NO GUARANTEES OR WARRANTIES AS TO THE
ACCURACY, ADEQUACY OR COMPLETENESS OF OR RESULTS TO BE OBTAINED FROM USING THE WORK, INCLUDING ANY
INFORMATION THAT CAN BE ACCESSED THROUGH THE WORK VIA HYPERLINK OR OTHERWISE, AND EXPRESSLY DISCLAIM
ANY WARRANTY, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO IMPLIED WARRANTIES OF MERCHANTABILITY
OR FITNESS FOR A PARTICULAR PURPOSE. McGraw-Hill and its licensors do not warrant or guarantee that the functions contained in the
work will meet your requirements or that its operation will be uninterrupted or error free. Neither McGraw-Hill nor its licensors shall be liable to
you or anyone else for any inaccuracy, error or omission, regardless of cause, in the work or for any damages resulting therefrom. McGraw-Hill has
no responsibility for the content of any information accessed through the work. Under no circumstances shall McGraw-Hill and/or its licensors be
liable for any indirect, incidental, special, punitive, consequential or similar damages that result from the use of or inability to use the work, even if
any of them has been advised of the possibility of such damages. This limitation of liability shall apply to any claim or cause whatsoever whether
such claim or cause arises in contract, tort or otherwise.
A deep reverence to my beloved late father-in-law
Contents at a Glance
1 Introduction to Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
2 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4 Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5 Object Creation and Member Visibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
6 Static Modifier and Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
7 Nested Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
8 Exception Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
9 Java I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
10 Advanced I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
11 Enums, Autoboxing, and Annotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
12 Generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
13 Event Processing and GUI Building . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
14 Creating Layouts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
15 Graphics and User Gestures Processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
16 Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
17 Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
18 Blocking Queues and Synchronizers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473
19 Callables, Futures, Executors, and Fork/Join . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
20 Network Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
21 Utility Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 617
vii
Contents
Foreword ........................................................... xix
Acknowledgments .................................................... xxi
Introduction ......................................................... xxiii
1 Introduction to Java ............................................ 1
Why Java? .......................................................... 2
So What Is Java? ...................................................... 3
Java Virtual Machine .................................................. 3
Features of Java ...................................................... 4
Small ........................................................ 4
Simple ....................................................... 5
Object Oriented ................................................ 5
Compiled and Interpreted ......................................... 5
Platform Independent ............................................ 6
Robust and Secure .............................................. 6
Multithreaded .................................................. 8
Dynamic ..................................................... 8
Java’s Evolution ...................................................... 9
JDK 1.0 (January 23, 1996): Codename Oak ........................... 9
JDK 1.1 (February 19, 1997) ....................................... 10
J2SE 1.2 (December 8, 1998): Codename Playground ................... 11
J2SE 1.3 (May 8, 2000): Codename Kestrel ............................ 13
J2SE 1.4 (Feb 6, 2002): Codename Merlin ............................ 13
J2SE 5.0 (Sept 30, 2004): Codename Tiger ............................ 14
Java SE 6 (Dec 11, 2006): Codename Mustang ......................... 15
Java SE 7 (July 7, 2011): Codename Dolphin .......................... 15
Summary ........................................................... 16
ix
x Java Programming
2 Arrays ...................................................... 17
Arrays .............................................................. 18
Declaring Arrays ................................................ 19
Creating Arrays ................................................. 20
Accessing and Modifying Array Elements ............................. 20
Initializing Arrays ..................................................... 22
Initializing at Runtime ........................................... 22
Initializing Using Array Literals ..................................... 23
The for-each Loop .................................................... 26
Multidimensional Arrays ................................................ 28
Two-dimensional Arrays .......................................... 28
Initializing Two-dimensional Arrays ................................. 29
Looping Using the for-each Construct ................................ 33
N-dimensional Arrays .................................................. 33
Nonrectangular Arrays ................................................. 33
Runtime Initialization ............................................ 34
Initialization Using Array Literals ................................... 35
A Few Goodies ....................................................... 35
Determining the Array Length ...................................... 35
Cloning an Array ............................................... 37
Finding Out the Class of an Array ................................... 38
Summary ........................................................... 40
3 Classes ...................................................... 41
Object-Oriented Programming (OOP) Concepts .............................. 42
OOP Features .................................................. 43
OOP Benefits .................................................. 45
The Class ........................................................... 45
Defining a Class ................................................ 45
Declaring a Point Class ........................................... 46
Using Classes .................................................. 47
Accessing/Modifying Fields ....................................... 48
The Class Example Program ....................................... 48
Declaring Methods .............................................. 49
Memory Representation of Objects .................................. 51
Information Hiding .................................................... 52
Encapsulation ........................................................ 56
Declaring Constructors ................................................. 57
Default Constructor ............................................. 60
Rules for Defining a Constructor .................................... 61
Source File Layout .................................................... 61
The package Statement ........................................... 62
The import Statement ............................................ 63
Directory Layout and Packages ........................................... 64
Summary ........................................................... 65
Contents xi
4 Inheritance ................................................... 67
Why Inheritance? ..................................................... 68
What Is Inheritance? ................................................... 69
Defining Single-level Inheritance ......................................... 72
Capturing Multilevel Inheritance ................................... 73
Writing a Multilevel Inheritance Program ............................. 74
Polymorphism ....................................................... 80
Creating a Heterogeneous Collection of Objects ....................... 81
A Program That Demonstrates a Heterogeneous Collection ............... 81
Detecting the Object Type ........................................ 88
Typecasting Rules on Inheritance Hierarchies .......................... 90
Preventing Method Overriding ..................................... 90
Preventing Subclassing ........................................... 90
Summary ........................................................... 91
5 Object Creation and Member Visibility ............................. 93
Instantiating a Subclass ................................................. 94
The Object-Creation Process ...................................... 95
Calling the super Constructor ...................................... 98
Method Overloading ............................................ 102
Rules of Method Overloading ...................................... 104
Creating a Copy Constructor ............................................. 104
Invoking Constructors: Summary ................................... 105
The final Keyword .................................................... 105
The final Classes ................................................ 106
The final Methods ............................................... 106
The final Variables .............................................. 108
The final Variables of the Class Type ................................ 109
Important Points Related to the final Keyword ......................... 110
Understanding Member Visibility Rules .................................... 111
The public Modifier ............................................. 113
The private Modifier ............................................. 114
The protected Modifier ........................................... 115
The Default Modifier ............................................ 117
A Few Rules on Inheriting ......................................... 119
Summary ........................................................... 120
6 Static Modifier and Interfaces ..................................... 121
The static Keyword .................................................... 122
The Static Fields ................................................ 122
The Static Methods .............................................. 126
The Static Initializers ............................................ 132
Interfaces ........................................................... 135
A Real-life Example of an Interface .................................. 137
Understanding Interface Syntax .................................... 139
Understanding Interfaces Through an Example ......................... 140
