100% found this document useful (3 votes)

51 views

Instant Download Java Programming Joyce Farrell PDF All Chapter

ebook

Uploaded by

lowriljusi

Available Formats

Download as PDF, TXT or read online on Scribd

100% found this document useful (3 votes)

51 views

Instant Download Java Programming Joyce Farrell PDF All Chapter

ebook

Uploaded by

lowriljusi

Available Formats

Download as PDF, TXT or read online on Scribd

You are on page 1/ 53

Full download test bank at ebook textbookfull.

com

Java Programming Joyce Farrell

CLICK LINK TO DOWLOAD

https://textbookfull.com/product/java-
programming-joyce-farrell/

textbookfull
More products digital (pdf, epub, mobi) instant
download maybe you interests ...

Java Programming Joyce Farrell

https://textbookfull.com/product/java-programming-joyce-
farrell-2/

Practical Numerical C Programming 1st Edition Philip

Joyce

https://textbookfull.com/product/practical-numerical-c-
programming-1st-edition-philip-joyce/

Programming in Java Sachin Malhotra

https://textbookfull.com/product/programming-in-java-sachin-
malhotra/

Murach s Java Programming Joel Murach

https://textbookfull.com/product/murach-s-java-programming-joel-
murach/
Practical Numerical C Programming: Finance,
Engineering, and Physics Applications Philip Joyce

https://textbookfull.com/product/practical-numerical-c-
programming-finance-engineering-and-physics-applications-philip-
joyce/

Learning Java An Introduction to Real World Programming

with Java Marc Loy

https://textbookfull.com/product/learning-java-an-introduction-
to-real-world-programming-with-java-marc-loy/

Learning Java Beginning programming with java for

dummies First Edition John Bach

https://textbookfull.com/product/learning-java-beginning-
programming-with-java-for-dummies-first-edition-john-bach/

Java Network Programming Fourth Edition Harold Elliotte

https://textbookfull.com/product/java-network-programming-fourth-
edition-harold-elliotte/

Computer Graphics Programming in OpenGL with Java

Gordon

https://textbookfull.com/product/computer-graphics-programming-
in-opengl-with-java-gordon/
TM

JAVA PROGRAMMING

JOYCE FARRELL

Australia • Brazil • Japan • Korea • Mexico • Singapore • Spain • United Kingdom • United States

Important Notice: Media content referenced within the product description or the product text may not be available in the eBook version.

Copyright 2016 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
Java Programming, © 2016, 2014, 2012 Cengage Learning
Eighth Edition WCN: 02-200-203
Joyce Farrell
ALL RIGHTS RESERVED. No part of this work covered by the copyright
Product Director: herein may be reproduced, transmitted, stored, or used in any form or
Kathleen McMahon by any means graphic, electronic, or mechanical, including but not
Senior Content Developer: limited to photocopying, recording, scanning, digitizing, taping, Web
Alyssa Pratt distribution, information networks, or information storage and
retrieval systems, except as permitted under Section 107 or 108 of the
Development Editor: Dan Seiter
1976 United States Copyright Act, without the prior written
Marketing Manager: Eric LaScola permission of the publisher.
Manufacturing Planner:
Julio Esperas
For product information and technology assistance, contact us at
Art Director: Jack Pendleton Cengage Learning Customer & Sales Support, 1-800-354-9706
Production Management,
For permission to use material from this text or product,
Copyediting, Composition,
Proofreading, and Indexing: submit all requests online at www.cengage.com/permissions.
Integra Software Services Pvt. Ltd. Further permissions questions can be emailed to
Cover Photo: [email protected].
©Maram/Shutterstock.com

Library of Congress Control Number: 2014956152

ISBN: 978-1-285-85691-9
Cengage Learning
20 Channel Center Street
Boston, MA 02210
USA

Cengage Learning is a leading provider of customized learning

solutions with office locations around the globe, including Singapore,
the United Kingdom, Australia, Mexico, Brazil, and Japan. Locate your
local office at www.cengage.com/global.

Cengage Learning products are represented in Canada by Nelson

Education, Ltd.

All images © 2016 Cengage Learning®. All rights reserved.

To learn more about Cengage Learning Solutions, visit
www.cengage.com.
Purchase any of our products at your local college store
or at our preferred online store www.cengagebrain.com.

Printed in the U nited States of America

Print N umber: 01 Print Year: 2015

Preface . . . . . . . . . . . . . . . . . . . . . . xxi
CHAPTER 1 Creating Java Programs . . . . . . . . . . . . . . . . 1
CHAPTER 2 Using Data . . . . . . . . . . . . . . . . . . . . . 53
CHAPTER 3 Using Methods, Classes, and Objects . . . . . . . 119
CHAPTER 4 More Object Concepts . . . . . . . . . . . . . . . 183
CHAPTER 5 Making Decisions . . . . . . . . . . . . . . . . . 245
CHAPTER 6 Looping . . . . . . . . . . . . . . . . . . . . . 301
CHAPTER 7 Characters, Strings, and the StringBuilder . . . 353
CHAPTER 8 Arrays . . . . . . . . . . . . . . . . . . . . . . 393
CHAPTER 9 Advanced Array Concepts . . . . . . . . . . . . . 439
CHAPTER 10 Introduction to Inheritance . . . . . . . . . . . . . 491
CHAPTER 11 Advanced Inheritance Concepts . . . . . . . . . . 537
CHAPTER 12 Exception Handling . . . . . . . . . . . . . . . . 593
CHAPTER 13 File Input and Output . . . . . . . . . . . . . . . 665
CHAPTER 14 Introduction to Swing Components . . . . . . . . 729
CHAPTER 15 Advanced GUI Topics . . . . . . . . . . . . . . . 791
CHAPTER 16 Graphics . . . . . . . . . . . . . . . . . . . . . 861
APPENDIX A Working with the Java Platform . . . . . . . . . . . 919
APPENDIX B Data Representation . . . . . . . . . . . . . . . 925
APPENDIX C Formatting Output . . . . . . . . . . . . . . . . 931
APPENDIX D Generating Random Numbers . . . . . . . . . . . 941
APPENDIX E Javadoc . . . . . . . . . . . . . . . . . . . . . 949
Glossary . . . . . . . . . . . . . . . . . . . . 957
Index . . . . . . . . . . . . . . . . . . . . . . 979

Preface . . . . . . . . . . . . . . . . . . xxi

CHAPT ER 1 Creating Java Programs . . . . . . . . . . . 1

Learning Programming Terminology . . . . . . . . . . . . . . 2
Comparing Procedural and Object-Oriented
Programming Concepts . . . . . . . . . . . . . . . . . . 6
Procedural Programming . . . . . . . . . . . . . . . . . . 6
Object-Oriented Programming . . . . . . . . . . . . . . . . 6
Understanding Classes, Objects, and Encapsulation . . . . . . 7
Understanding Inheritance and Polymorphism . . . . . . . . . 9
Features of the Java Programming Language . . . . . . . . . . 11
Java Program Types . . . . . . . . . . . . . . . . . . . . 12
Analyzing a Java Application that Produces Console Output . . . . 13
Understanding the Statement that Produces the Output . . . . . 14
Understanding the First Class . . . . . . . . . . . . . . . 15
Indent Style . . . . . . . . . . . . . . . . . . . . . . . 18
Understanding the main() Method . . . . . . . . . . . . . 19
Saving a Java Class . . . . . . . . . . . . . . . . . . . . 21
Compiling a Java Class and Correcting Syntax Errors . . . . . . . 23
Compiling a Java Class . . . . . . . . . . . . . . . . . . . 23
Correcting Syntax Errors . . . . . . . . . . . . . . . . . . 24
Running a Java Application and Correcting Logic Errors . . . . . . 29
Running a Java Application . . . . . . . . . . . . . . . . . 29
Modifying a Compiled Java Class . . . . . . . . . . . . . . 30
Correcting Logic Errors . . . . . . . . . . . . . . . . . . 31
Adding Comments to a Java Class . . . . . . . . . . . . . . . 32
Creating a Java Application that Produces GUI Output . . . . . . 35
Finding Help . . . . . . . . . . . . . . . . . . . . . . . . 38
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . . 39
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . . 41

CHAPT ER 2 Using Data . . . . . . . . . . . . . . . . . 53

Declaring and Using Constants and Variables . . . . . . . . . . 54
Declaring Variables . . . . . . . . . . . . . . . . . . . . 55
Declaring Named Constants . . . . . . . . . . . . . . . . 56
The Scope of Variables and Constants . . . . . . . . . . . . 58
Concatenating Strings to Variables and Constants . . . . . . . 58
Pitfall: Forgetting that a Variable Holds
One Value at a Time . . . . . . . . . . . . . . . . . . . 60
Learning About Integer Data Types . . . . . . . . . . . . . . 64
Using the boolean Data Type . . . . . . . . . . . . . . . . . 70
Learning About Floating-Point Data Types . . . . . . . . . . . . 71
Using the char Data Type . . . . . . . . . . . . . . . . . . 72
Using the Scanner Class to Accept Keyboard Input . . . . . . . 78
Pitfall: Using nextLine() Following One of the
Other Scanner Input Methods . . . . . . . . . . . . . . 81
Using the JOptionPane Class to Accept GUI Input . . . . . . . 87
Using Input Dialog Boxes . . . . . . . . . . . . . . . . . . 87
Using Confirm Dialog Boxes . . . . . . . . . . . . . . . . 91
Performing Arithmetic . . . . . . . . . . . . . . . . . . . . 93
Associativity and Precedence . . . . . . . . . . . . . . . . 95
Writing Arithmetic Statements Efficiently . . . . . . . . . . . 96
Pitfall: Not Understanding Imprecision
in Floating-Point Numbers . . . . . . . . . . . . . . . . 96
Understanding Type Conversion . . . . . . . . . . . . . . . 101
Automatic Type Conversion . . . . . . . . . . . . . . . . 101
Explicit Type Conversions . . . . . . . . . . . . . . . . 102
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 106
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 107

Chapter Summary . . . . . . . . . . . . . . . . . . . . . 111

Review Questions . . . . . . . . . . . . . . . . . . . . . 111
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 114
Programming Exercises . . . . . . . . . . . . . . . . . 114
viii Debugging Exercises . . . . . . . . . . . . . . . . . . 116
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 117
Case Problems . . . . . . . . . . . . . . . . . . . . . 118

CHAPT ER 3 Using Methods, Classes, and Objects . . . . 119

Understanding Method Calls and Placement . . . . . . . . . . 120
Understanding Method Construction . . . . . . . . . . . . . 123
Access Specifiers . . . . . . . . . . . . . . . . . . . . 123
Return Type . . . . . . . . . . . . . . . . . . . . . . 124
Method Name . . . . . . . . . . . . . . . . . . . . . 125
Parentheses . . . . . . . . . . . . . . . . . . . . . . 125
Adding Parameters to Methods . . . . . . . . . . . . . . . 129
Creating a Method that Receives a Single Parameter . . . . . 130
Creating a Method that Requires Multiple Parameters . . . . . 133
Creating Methods that Return Values . . . . . . . . . . . . . 136
Chaining Method Calls . . . . . . . . . . . . . . . . . . 138
Learning About Classes and Objects . . . . . . . . . . . . . 142
Creating a Class . . . . . . . . . . . . . . . . . . . . . 145
Creating Instance Methods in a Class . . . . . . . . . . . . 147
Organizing Classes . . . . . . . . . . . . . . . . . . . 150
Declaring Objects and Using their Methods . . . . . . . . . . 154
Understanding Data Hiding . . . . . . . . . . . . . . . . 156
An Introduction to Using Constructors . . . . . . . . . . . . 159
Understanding that Classes Are Data Types . . . . . . . . . . 163
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 168
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 168
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 170
Review Questions . . . . . . . . . . . . . . . . . . . . . 171
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 174
Programming Exercises . . . . . . . . . . . . . . . . . 174
Debugging Exercises . . . . . . . . . . . . . . . . . . 177
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 178
Case Problems . . . . . . . . . . . . . . . . . . . . . 179

Creating and Calling Constructors with Parameters . . . . . . . 200

Overloading Constructors . . . . . . . . . . . . . . . . 201
Learning About the this Reference . . . . . . . . . . . . . 205
Using the this Reference to Make Overloaded Constructors
More Efficient . . . . . . . . . . . . . . . . . . . . . 209
Using static Fields . . . . . . . . . . . . . . . . . . . 213
Using Constant Fields . . . . . . . . . . . . . . . . . . 215
Using Automatically Imported, Prewritten Constants
and Methods . . . . . . . . . . . . . . . . . . . . . . 220
The Math Class . . . . . . . . . . . . . . . . . . . . 221
Importing Classes that Are Not Imported Automatically . . . . 223
Using the LocalDate Class . . . . . . . . . . . . . . . 224
Understanding Composition and Nested Classes . . . . . . . . 230
Composition . . . . . . . . . . . . . . . . . . . . . . 230
Nested Classes . . . . . . . . . . . . . . . . . . . . . 232
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 234
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 234
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 236
Review Questions . . . . . . . . . . . . . . . . . . . . . 236
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 239
Programming Exercises . . . . . . . . . . . . . . . . . 239
Debugging Exercises . . . . . . . . . . . . . . . . . . 242
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 242
Case Problems . . . . . . . . . . . . . . . . . . . . . 243

CHAPT ER 5 Making Decisions . . . . . . . . . . . . . 245

Planning Decision-Making Logic . . . . . . . . . . . . . . . 246
The if and if…else Statements . . . . . . . . . . . . . . 248
The if Statement . . . . . . . . . . . . . . . . . . . . 248
Pitfall: Misplacing a Semicolon in an if Statement . . . . . . 249
Pitfall: Using the Assignment Operator Instead
of the Equivalency Operator . . . . . . . . . . . . . . 250

Pitfall: Attempting to Compare Objects

Using the Relational Operators . . . . . . . . . . . . . 251
The if…else Statement . . . . . . . . . . . . . . . . . 251
Using Multiple Statements in if and if…else Clauses . . . . 254
x Nesting if and if…else Statements . . . . . . . . . . . . 260
Using Logical AND and OR Operators . . . . . . . . . . . . 263
The AND Operator . . . . . . . . . . . . . . . . . . . . 263
The OR Operator . . . . . . . . . . . . . . . . . . . . 265
Short-Circuit Evaluation . . . . . . . . . . . . . . . . . . 266
Making Accurate and Efficient Decisions . . . . . . . . . . . 269
Making Accurate Range Checks . . . . . . . . . . . . . . 270
Making Efficient Range Checks . . . . . . . . . . . . . . 272
Using && and || Appropriately . . . . . . . . . . . . . . 273
Using the switch Statement . . . . . . . . . . . . . . . . 274
Using the Conditional and NOT Operators . . . . . . . . . . . 280
Using the NOT Operator . . . . . . . . . . . . . . . . . 281
Understanding Operator Precedence . . . . . . . . . . . . . 282
Adding Decisions and Constructors
to Instance Methods . . . . . . . . . . . . . . . . . . . 285
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 289
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 289
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 291
Review Questions . . . . . . . . . . . . . . . . . . . . . 291
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 294
Programming Exercises . . . . . . . . . . . . . . . . . 294
Debugging Exercises . . . . . . . . . . . . . . . . . . 297
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 297
Case Problems . . . . . . . . . . . . . . . . . . . . . 299

CHAPT ER 6 Looping . . . . . . . . . . . . . . . . . 301

Learning About the Loop Structure . . . . . . . . . . . . . . 302
Creating while Loops . . . . . . . . . . . . . . . . . . 303
Writing a Definite while Loop . . . . . . . . . . . . . . 303
Pitfall: Failing to Alter the Loop Control Variable
Within the Loop Body . . . . . . . . . . . . . . . . . 305
Pitfall: Unintentionally Creating a Loop with
an Empty Body . . . . . . . . . . . . . . . . . . . . 306

Copyright 2016 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
Altering a Definite Loop’s Control Variable . . . . . . . . . . 307
Writing an Indefinite while Loop . . . . . . . . . . . . . 308
Validating Data . . . . . . . . . . . . . . . . . . . . . 310
Using Shortcut Arithmetic Operators . . . . . . . . . . . . . 314
Creating a for Loop . . . . . . . . . . . . . . . . . . . 319 xi
Unconventional for Loops . . . . . . . . . . . . . . . . 320
Learning How and When to Use a do…while Loop . . . . . . 325
Learning About Nested Loops . . . . . . . . . . . . . . . . 328
Improving Loop Performance . . . . . . . . . . . . . . . . 333
Avoiding Unnecessary Operations . . . . . . . . . . . . . 333
Considering the Order of Evaluation of Short-Circuit
Operators . . . . . . . . . . . . . . . . . . . . . . 334
Comparing to Zero . . . . . . . . . . . . . . . . . . . 334
Employing Loop Fusion . . . . . . . . . . . . . . . . . . 336
Using Prefix Incrementing Rather than Postfix
Incrementing . . . . . . . . . . . . . . . . . . . . . 337
A Final Note on Improving Loop Performance . . . . . . . . 338
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 342
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 342
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 344
Review Questions . . . . . . . . . . . . . . . . . . . . . 344
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 347
Programming Exercises . . . . . . . . . . . . . . . . . 347
Debugging Exercises . . . . . . . . . . . . . . . . . . 350
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 350
Case Problems . . . . . . . . . . . . . . . . . . . . . 352

CHAPT ER 7 Characters, Strings, and

the StringBuilder . . . . . . . . . . . . 353
Understanding String Data Problems . . . . . . . . . . . . . 354
Using Character Class Methods . . . . . . . . . . . . . . 355
Declaring and Comparing String Objects . . . . . . . . . . 359
Comparing String Values . . . . . . . . . . . . . . . . 359
Empty and null Strings . . . . . . . . . . . . . . . . . 363
Using Other String Methods . . . . . . . . . . . . . . . 365
Converting String Objects to Numbers . . . . . . . . . . 369

Learning About the StringBuilder

and StringBuffer Classes . . . . . . . . . . . . . . 374
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 381
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 382
xii Chapter Summary . . . . . . . . . . . . . . . . . . . . . 382
Review Questions . . . . . . . . . . . . . . . . . . . . . 383
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 385
Programming Exercises . . . . . . . . . . . . . . . . . 385
Debugging Exercises . . . . . . . . . . . . . . . . . . 388
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 388
Case Problems . . . . . . . . . . . . . . . . . . . . . 391

CHAPT ER 8 Arrays . . . . . . . . . . . . . . . . . . 393

Declaring Arrays . . . . . . . . . . . . . . . . . . . . . 394
Initializing an Array . . . . . . . . . . . . . . . . . . . . 399
Using Variable Subscripts with an Array . . . . . . . . . . . . 402
Using the Enhanced for Loop . . . . . . . . . . . . . . 403
Using Part of an Array . . . . . . . . . . . . . . . . . . 404
Declaring and Using Arrays of Objects . . . . . . . . . . . . 406
Using the Enhanced for Loop with Objects . . . . . . . . . 408
Manipulating Arrays of Strings . . . . . . . . . . . . . 408
Searching an Array and Using Parallel Arrays . . . . . . . . . 414
Using Parallel Arrays . . . . . . . . . . . . . . . . . . . 415
Searching an Array for a Range Match . . . . . . . . . . . 418
Passing Arrays to and Returning Arrays from Methods . . . . . 422
Returning an Array from a Method . . . . . . . . . . . . . 426
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 428
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 428
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 429
Review Questions . . . . . . . . . . . . . . . . . . . . . 430
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 433
Programming Exercises . . . . . . . . . . . . . . . . . 433
Debugging Exercises . . . . . . . . . . . . . . . . . . 435
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 435
Case Problems . . . . . . . . . . . . . . . . . . . . . 438

Sorting Array Elements Using the Insertion Sort Algorithm . . . . 448

Using Two-Dimensional and Other Multidimensional Arrays . . . . 452
Passing a Two-Dimensional Array to a Method . . . . . . . . 454
Using the length Field with a Two-Dimensional Array . . . . 455
Understanding Ragged Arrays . . . . . . . . . . . . . . . 456
Using Other Multidimensional Arrays . . . . . . . . . . . . 456
Using the Arrays Class . . . . . . . . . . . . . . . . . . 459
Using the ArrayList Class . . . . . . . . . . . . . . . . 467
Creating Enumerations . . . . . . . . . . . . . . . . . . . 472
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 479
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 479
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 480
Review Questions . . . . . . . . . . . . . . . . . . . . . 481
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 484
Programming Exercises . . . . . . . . . . . . . . . . . 484
Debugging Exercises . . . . . . . . . . . . . . . . . . 486
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 487
Case Problems . . . . . . . . . . . . . . . . . . . . . 490

CHAPT ER 10 Introduction to Inheritance . . . . . . . . . 491

Learning About the Concept of Inheritance . . . . . . . . . . 492
Diagramming Inheritance Using the UML . . . . . . . . . . 492
Inheritance Terminology . . . . . . . . . . . . . . . . . 495
Extending Classes . . . . . . . . . . . . . . . . . . . . . 496
Overriding Superclass Methods . . . . . . . . . . . . . . . 502
Using the @Override Tag . . . . . . . . . . . . . . . . 504
Calling Constructors During Inheritance . . . . . . . . . . . . 507
Using Superclass Constructors that
Require Arguments . . . . . . . . . . . . . . . . . . 508
Accessing Superclass Methods . . . . . . . . . . . . . . . 513
Comparing this and super . . . . . . . . . . . . . . . 515
Employing Information Hiding . . . . . . . . . . . . . . . . 516

Methods You Cannot Override . . . . . . . . . . . . . . . . 518

A Subclass Cannot Override static Methods in
Its Superclass . . . . . . . . . . . . . . . . . . . . 518
A Subclass Cannot Override final Methods in
Its Superclass . . . . . . . . . . . . . . . . . . . . 522
xiv
A Subclass Cannot Override Methods
in a final Superclass . . . . . . . . . . . . . . . . 523
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 525
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 525
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 526
Review Questions . . . . . . . . . . . . . . . . . . . . . 527
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 530
Programming Exercises . . . . . . . . . . . . . . . . . 530
Debugging Exercises . . . . . . . . . . . . . . . . . . 533
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 534
Case Problems . . . . . . . . . . . . . . . . . . . . . 535

CHAPT ER 11 Advanced Inheritance Concepts . . . . . . . 537

Creating and Using Abstract Classes . . . . . . . . . . . . . 538
Using Dynamic Method Binding . . . . . . . . . . . . . . . 547
Using a Superclass as a Method Parameter Type . . . . . . 549
Creating Arrays of Subclass Objects . . . . . . . . . . . . . 551
Using the Object Class and Its Methods . . . . . . . . . . . 554
Using the toString() Method . . . . . . . . . . . . . 556
Using the equals() Method . . . . . . . . . . . . . . . 559
Using Inheritance to Achieve Good Software Design . . . . . . 564
Creating and Using Interfaces . . . . . . . . . . . . . . . . 565
Creating Interfaces to Store Related Constants . . . . . . . 570
Creating and Using Packages . . . . . . . . . . . . . . . . 574
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 580
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 580
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 581
Review Questions . . . . . . . . . . . . . . . . . . . . . 582
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 585
Programming Exercises . . . . . . . . . . . . . . . . . 585
Debugging Exercises . . . . . . . . . . . . . . . . . . 589
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 590
Case Problems . . . . . . . . . . . . . . . . . . . . . 590
Copyright 2016 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
CHAPT ER 12 Exception Handling . . . . . . . . . . . . 593
Learning About Exceptions . . . . . . . . . . . . . . . . . 594
Trying Code and Catching Exceptions . . . . . . . . . . . . 599
Using a try Block to Make Programs “Foolproof” . . . . . . 604
Declaring and Initializing Variables in try…catch Blocks . . . 606 xv

Throwing and Catching Multiple Exceptions . . . . . . . . . . 609

Using the finally Block . . . . . . . . . . . . . . . . . 615
Understanding the Advantages of Exception Handling . . . . . . 618
Specifying the Exceptions that a Method Can Throw . . . . . . 621
Tracing Exceptions Through the Call Stack . . . . . . . . . . 626
Creating Your Own Exception Classes . . . . . . . . . . . 630
Using Assertions . . . . . . . . . . . . . . . . . . . . . 634
Displaying the Virtual Keyboard . . . . . . . . . . . . . . . 650
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 653
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 654
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 655
Review Questions . . . . . . . . . . . . . . . . . . . . . 656
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 659
Programming Exercises . . . . . . . . . . . . . . . . . 659
Debugging Exercises . . . . . . . . . . . . . . . . . . 662
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 662
Case Problems . . . . . . . . . . . . . . . . . . . . . 663

CHAPT ER 13 File Input and Output . . . . . . . . . . . . 665

Understanding Computer Files . . . . . . . . . . . . . . . 666
Using the Path and Files Classes . . . . . . . . . . . . . 667
Creating a Path . . . . . . . . . . . . . . . . . . . . . 668
Retrieving Information About a Path . . . . . . . . . . . . 669
Converting a Relative Path to an Absolute One . . . . . . . . 670
Checking File Accessibility . . . . . . . . . . . . . . . . 671
Deleting a Path . . . . . . . . . . . . . . . . . . . . . 673
Determining File Attributes . . . . . . . . . . . . . . . . 674
File Organization, Streams, and Buffers . . . . . . . . . . . . 678
Using Java’s IO Classes . . . . . . . . . . . . . . . . . . 680
Writing to a File . . . . . . . . . . . . . . . . . . . . . 683
Reading from a File . . . . . . . . . . . . . . . . . . . 685

Creating and Using Sequential Data Files . . . . . . . . . . . 687

Learning About Random Access Files . . . . . . . . . . . . 693
Writing Records to a Random Access Data File . . . . . . . . 697
Reading Records from a Random Access Data File . . . . . . . 704
xvi Accessing a Random Access File Sequentially . . . . . . . . 704
Accessing a Random Access File Randomly . . . . . . . . . 705
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 719
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 719
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 720
Review Questions . . . . . . . . . . . . . . . . . . . . . 721
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 724
Programming Exercises . . . . . . . . . . . . . . . . . 724
Debugging Exercises . . . . . . . . . . . . . . . . . . 726
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 727
Case Problems . . . . . . . . . . . . . . . . . . . . . 727

CHAPT ER 14 Introduction to Swing Components . . . . . 729

Understanding Swing Components . . . . . . . . . . . . . 730
Using the JFrame Class . . . . . . . . . . . . . . . . . . 731
Customizing a JFrame’s Appearance . . . . . . . . . . . 734
Using the JLabel Class . . . . . . . . . . . . . . . . . . 738
Changing a JLabel’s Font . . . . . . . . . . . . . . . . 740
Using a Layout Manager . . . . . . . . . . . . . . . . . . 743
Extending the JFrame Class . . . . . . . . . . . . . . . . 746
Adding JTextFields, JButtons, and Tool Tips to a
JFrame . . . . . . . . . . . . . . . . . . . . . . . . 748
Adding JTextFields . . . . . . . . . . . . . . . . . . 748
Adding JButtons . . . . . . . . . . . . . . . . . . . 750
Using Tool Tips . . . . . . . . . . . . . . . . . . . . . 752
Learning About Event-Driven Programming . . . . . . . . . . 755
Preparing Your Class to Accept Event Messages . . . . . . . 756
Telling Your Class to Expect Events to Happen . . . . . . . 757
Telling Your Class How to Respond to Events . . . . . . . . 757
An Event-Driven Program . . . . . . . . . . . . . . . . . 757
Using Multiple Event Sources . . . . . . . . . . . . . . . 759
Using the setEnabled() Method . . . . . . . . . . . . 761
Understanding Swing Event Listeners . . . . . . . . . . . . 764

CHAPT ER 15 Advanced GUI Topics . . . . . . . . . . . 791

Understanding the Content Pane . . . . . . . . . . . . . . 792
Using Color . . . . . . . . . . . . . . . . . . . . . . . 795
Learning More About Layout Managers . . . . . . . . . . . . 797
Using BorderLayout . . . . . . . . . . . . . . . . . 798
Using FlowLayout . . . . . . . . . . . . . . . . . . . 800
Using GridLayout . . . . . . . . . . . . . . . . . . . 802
Using CardLayout . . . . . . . . . . . . . . . . . . . 803
Using Advanced Layout Managers . . . . . . . . . . . . . 805
Using the JPanel Class . . . . . . . . . . . . . . . . . . 813
Creating JScrollPanes . . . . . . . . . . . . . . . . . 821
A Closer Look at Events and Event Handling . . . . . . . . . . 824
An Event-Handling Example: KeyListener . . . . . . . . 827
Using AWTEvent Class Methods . . . . . . . . . . . . . . 830
Understanding x- and y-Coordinates . . . . . . . . . . . . 832
Handling Mouse Events . . . . . . . . . . . . . . . . . . 832
Using Menus . . . . . . . . . . . . . . . . . . . . . . . 837
Using Specialized Menu Items . . . . . . . . . . . . . . . 841
Using addSeparator() . . . . . . . . . . . . . . . . 843
Using setMnemonic() . . . . . . . . . . . . . . . . . 843
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 848
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 849

Chapter Summary . . . . . . . . . . . . . . . . . . . . . 850

Review Questions . . . . . . . . . . . . . . . . . . . . . 851
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 853
Programming Exercises . . . . . . . . . . . . . . . . . 853
xviii Debugging Exercises . . . . . . . . . . . . . . . . . . 855
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 855
Case Problems . . . . . . . . . . . . . . . . . . . . . 859

CHAPT ER 16 Graphics . . . . . . . . . . . . . . . . . 861

Learning About Rendering Methods . . . . . . . . . . . . . 862
Drawing Strings . . . . . . . . . . . . . . . . . . . . . . 865
Repainting . . . . . . . . . . . . . . . . . . . . . . . 867
Setting a Font . . . . . . . . . . . . . . . . . . . . . 869
Using Color . . . . . . . . . . . . . . . . . . . . . . 870
Drawing Lines and Shapes . . . . . . . . . . . . . . . . . 874
Drawing Lines . . . . . . . . . . . . . . . . . . . . . 874
Drawing Unfilled and Filled Rectangles . . . . . . . . . . . 875
Drawing Clear Rectangles . . . . . . . . . . . . . . . . 875
Drawing Rounded Rectangles . . . . . . . . . . . . . . . 876
Drawing Shadowed Rectangles . . . . . . . . . . . . . . 878
Drawing Ovals . . . . . . . . . . . . . . . . . . . . . 879
Drawing Arcs . . . . . . . . . . . . . . . . . . . . . . 880
Creating Polygons . . . . . . . . . . . . . . . . . . . . 881
Copying an Area . . . . . . . . . . . . . . . . . . . . 883
Using the paint() Method with JFrames . . . . . . . . . 883
Learning More About Fonts . . . . . . . . . . . . . . . . . 891
Discovering Screen Statistics . . . . . . . . . . . . . . . 893
Discovering Font Statistics . . . . . . . . . . . . . . . . 894
Drawing with Java 2D Graphics . . . . . . . . . . . . . . . 898
Specifying the Rendering Attributes . . . . . . . . . . . . 899
Setting a Drawing Stroke . . . . . . . . . . . . . . . . . 901
Creating Objects to Draw . . . . . . . . . . . . . . . . . 902
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 910
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 911
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 911
Review Questions . . . . . . . . . . . . . . . . . . . . . 912
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 915

APPENDIX B Data Representation . . . . . . . . . . . . 925

Understanding Numbering Systems . . . . . . . . . . . . . 926
Representing Numeric Values . . . . . . . . . . . . . . . . 927
Representing Character Values . . . . . . . . . . . . . . . 929
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 930

APPENDIX C Formatting Output . . . . . . . . . . . . . 931

Rounding Numbers . . . . . . . . . . . . . . . . . . . . 932
Using the printf() Method . . . . . . . . . . . . . . . . 933
Specifying a Number of Decimal Places to
Display with printf() . . . . . . . . . . . . . . . . 936
Specifying a Field Size with printf() . . . . . . . . . . . 937
Using the Optional Argument Index with printf() . . . . . 938
Using the DecimalFormat Class . . . . . . . . . . . . . 939
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 940

APPENDIX D Generating Random Numbers . . . . . . . . 941

Understanding Computer-Generated Random Numbers . . . . . 942
Using the Math.random() Method . . . . . . . . . . . . . 943
Using the Random Class . . . . . . . . . . . . . . . . . . 944
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 947

APPENDIX E Javadoc . . . . . . . . . . . . . . . . . 949

The Javadoc Documentation Generator . . . . . . . . . . . . 950
Javadoc Comment Types . . . . . . . . . . . . . . . . . . 950
Generating Javadoc Documentation . . . . . . . . . . . . . 952
xx Specifying Visibility of Javadoc Documentation . . . . . . . . 955
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 956

Glossary . . . . . . . . . . . . . . . . . 957
Index . . . . . . . . . . . . . . . . . . . 979

Java Programming, Eighth Edition, provides the beginning programmer with a guide to
developing applications using the Java programming language. Java is popular among
professional programmers because it can be used to build visually interesting graphical user
interface (GUI) and Web-based applications. Java also provides an excellent environment for
the beginning programmer—a student can quickly build useful programs while learning the
basics of structured and object-oriented programming techniques.
This textbook assumes that you have little or no programming experience. It provides a solid
background in good object-oriented programming techniques and introduces terminology
using clear, familiar language. The programming examples are business examples; they do not
assume a mathematical background beyond high-school business math. In addition, the
examples illustrate only one or two major points; they do not contain so many features that
you become lost following irrelevant and extraneous details. Complete, working programs
appear frequently in each chapter; these examples help students make the transition from the
theoretical to the practical. The code presented in each chapter can also be downloaded from
the publisher’s Web site, so students can easily run the programs and experiment with
changes to them.
The student using Java Programming, Eighth Edition, builds applications from the bottom up
rather than starting with existing objects. This facilitates a deeper understanding of the
concepts used in object-oriented programming and engenders appreciation for the existing
objects students use as their knowledge of the language advances. When students complete
this book, they will know how to modify and create simple Java programs, and they will have
the tools to create more complex examples. They also will have a fundamental knowledge of
object-oriented programming, which will serve them well in advanced Java courses or in
studying other object-oriented languages such as C++, C#, and Visual Basic.

Organization and Coverage

Java Programming, Eighth Edition, presents Java programming concepts, enforcing good
style, logical thinking, and the object-oriented paradigm. Objects are covered right from the
beginning, earlier than in many other textbooks. You create your first Java program in
Chapter 1. Chapters 2, 3, and 4 increase your understanding of how data, classes, objects,
and methods interact in an object-oriented environment.
Chapters 5 and 6 explore input and repetition structures, which are the backbone of
programming logic and essential to creating useful programs in any language. You learn the
special considerations of string and array manipulation in Chapters 7, 8, and 9.

Chapters 10, 11, and 12 thoroughly cover inheritance and exception handling. Inheritance is
the object-oriented concept that allows you to develop new objects quickly by adapting the
features of existing objects; exception handling is the object-oriented approach to handling
errors. Both are important concepts in object-oriented design. Chapter 13 provides
information on handling files so you can permanently store and retrieve program output.
xxii
Chapters 14, 15, and 16 introduce GUI Swing components (Java’s visually pleasing,
user-friendly widgets), their layout managers, and graphics.

Features
The following features are new for the Eighth Edition:
JAVA 8E: All programs have been tested using Java 8e, the newest edition of Java.
WINDOWS 8.1: All programs have been tested in Windows 8.1, and all screen shots have
been taken in this new environment.
DATE AND TIME CLASSES: This edition provides thorough coverage of the java.time
package, which is new in Java 8e.
ON-SCREEN KEYBOARD: This edition provides instructions for displaying and using an
on-screen keyboard with either a touch screen or a standard screen.
MODERNIZED GRAPHICS OUTPUT: The chapter on graphics (Chapter 16) has been
completely rewritten to focus on Swing component graphics production using the
paintComponent() method.

MODERNIZED OVERRIDING: The @Override tag is introduced.

EXPANDED COVERAGE OF THE EQUALS() METHOD: The book provides a thorough
explanation of the difference between overloading and overriding the equals() method.
PROGRAMMING EXERCISES: Each chapter contains several new programming exercises
not seen in previous editions. All exercises and their solutions from the previous edition
that were replaced in this edition are still available in the Instructor’s Resource Kit.
Additionally, Java Programming, Eighth Edition, includes the following features:
OBJECTIVES: Each chapter begins with a list of objectives so you know the topics that will
be presented in the chapter. In addition to providing a quick reference to topics covered,
this feature provides a useful study aid.
YOU DO IT: In each chapter, step-by-step exercises help students create multiple working
programs that emphasize the logic a programmer uses in choosing statements to include.
These sections provide a means for students to achieve success on their own—even those
in online or distance learning classes.
NOTES: These highlighted tips provide additional information—for example, an
alternative method of performing a procedure, another term for a concept, background
information on a technique, or a common error to avoid.

EMPHASIS ON STUDENT RESEARCH: The student frequently is directed to the Java Web
site to investigate classes and methods. Computer languages evolve, and programming
professionals must understand how to find the latest language improvements. This book
encourages independent research.
FIGURES: Each chapter contains many figures. Code figures are most frequently 25 lines
xxiii
or fewer, illustrating one concept at a time. Frequent screen shots show exactly how
program output appears. Callouts appear where needed to emphasize a point.
COLOR: The code figures in each chapter contain all Java keywords in blue. This helps
students identify keywords more easily, distinguishing them from programmer-selected
names.
FILES: More than 200 student files can be downloaded from the publisher’s Web site. Most
files contain the code presented in the figures in each chapter; students can run the code for
themselves, view the output, and make changes to the code to observe the effects. Other
files include debugging exercises that help students improve their programming skills.
TWO TRUTHS & A LIE: A short quiz reviews each chapter section, with answers provided.
This quiz contains three statements based on the preceding section of text—two
statements are true and one is false. Over the years, students have requested answers to
problems, but we have hesitated to distribute them in case instructors want to use
problems as assignments or test questions. These true–false quizzes provide students with
immediate feedback as they read, without “giving away” answers to the multiple-choice
questions and programming exercises.
DON’T DO IT: This section at the end of each chapter summarizes common mistakes and
pitfalls that plague new programmers while learning the current topic.
KEY TERMS: Each chapter includes a list of newly introduced vocabulary, shown in the
order of appearance in the text. The list of key terms provides a short review of the major
concepts in the chapter.
SUMMARIES: Following each chapter is a summary that recaps the programming
concepts and techniques covered in the chapter. This feature provides a concise means for
students to check their understanding of the main points in each chapter.
REVIEW QUESTIONS: Each chapter includes 20 multiple-choice questions that serve as a
review of chapter topics.
GAME ZONE: Each chapter provides one or more exercises in which students can create
interactive games using the programming techniques learned up to that point; 70 game
programs are suggested in the book. The games are fun to create and play; writing them
motivates students to master the necessary programming techniques. Students might
exchange completed game programs with each other, suggesting improvements and
discovering alternate ways to accomplish tasks.
CASES: Each chapter contains two running case problems. These cases represent projects
that continue to grow throughout a semester using concepts learned in each new chapter.
Two cases allow instructors to assign different cases in alternate semesters or to divide
students in a class into two case teams.
Copyright 2016 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
PREFACE Instructor Resources

GLOSSARY: This edition contains an alphabetized list of all key terms identified in the
book, along with their definitions.
APPENDICES: This edition includes useful appendices on working with the Java platform,
data representation, formatting output, generating random numbers, and creating Javadoc
comments.
xxiv
QUALITY: Every program example, exercise, and game solution was tested by the author
and then tested again by a quality assurance team using Java Standard Edition (SE) 8, the
most recent version available.

CourseMate
The more you study, the better the results. Make the most of your study time by accessing
everything you need to succeed in one place. Read your textbook, take notes, review
flashcards, watch videos, and take practice quizzes online. CourseMate goes beyond the book
to deliver what you need! Learn more at www.cengage.com/coursemate.
The Java Programming CourseMate includes:
Debugging Exercises: Four error-filled programs accompany each chapter. By
debugging these programs, students can gain expertise in program logic in general and
the Java programming language in particular.
Video Lessons: Each chapter is accompanied by at least three video lessons that help to
explain important chapter concepts. These videos were created and narrated by the
author.
Interactive Study Aids: An interactive eBook, quizzes, flashcards, and more!
Instructors may add CourseMate to the textbook package, or students may purchase
CourseMate directly at www.CengageBrain.com.

Instructor Resources
The following teaching tools are available for download at our Instructor Companion Site.
Simply search for this text at sso.cengage.com. An instructor login is required.
Electronic Instructor’s Manual: The Instructor’s Manual that accompanies this
textbook contains additional instructional material to assist in class preparation,
including items such as Overviews, Chapter Objectives, Teaching Tips, Quick
Quizzes, Class Discussion Topics, Additional Projects, Additional Resources, and Key
Terms. A sample syllabus is also available. Additional exercises in the Instructor’s
Manual include:
Tough Questions: Two or more fairly difficult questions that an applicant
might encounter in a technical job interview accompany each chapter. These
questions are often open-ended; some involve coding and others might involve
research.

Up for Discussion: A few thought-provoking questions concerning programming in

general or Java in particular supplement each chapter. The questions can be used to
start classroom or online discussions, or to develop and encourage research, writing,
and language skills.
Programming Exercises and Solutions: Each chapter is accompanied by several
xxv
programming exercises to supplement those offered in the text. Instructors can use
these exercises as additional or alternate assignments, or as the basis for lectures.
Test Bank: Cengage Learning Testing Powered by Cognero is a flexible, online system
that allows you to:
Author, edit, and manage test bank content from multiple Cengage Learning
solutions.
Create multiple test versions in an instant.
Deliver tests from your LMS, your classroom, or anywhere you want.
PowerPoint Presentations: This text provides PowerPoint slides to accompany each
chapter. Slides may be used to guide classroom presentations, to make available to
students for chapter review, or to print as classroom handouts. Files are provided for every
figure in the text. Instructors may use the files to customize PowerPoint slides, illustrate
quizzes, or create handouts.
Solutions: Solutions to “You Do It” exercises and all end-of-chapter exercises are
available. Annotated solutions are provided for some of the multiple-choice Review
Questions. For example, if students are likely to debate answer choices or not understand
the choice deemed to be the correct one, a rationale is provided.

Acknowledgments
I would like to thank all of the people who helped to make this book a reality, including Dan
Seiter, Development Editor; Alyssa Pratt, Senior Content Developer; Carmel Isaac, Content
Project Manager; and Chris Scriver and Danielle Shaw, quality assurance testers. I am lucky to
work with these professionals who are dedicated to producing high-quality instructional
materials.
I am also grateful to the reviewers who provided comments and encouragement during this
book’s development, including Bernice Cunningham, Wayne County Community College
District; Bev Eckel, Iowa Western Community College; John Russo, Wentworth Institute of
Technology; Leslie Spivey, Edison Community College; and Angeline Surber, Mesa
Community College.
Thanks, too, to my husband, Geoff, for his constant support and encouragement. Finally, this
book is dedicated to the newest Farrell, coming March 2015. As this book goes to production,
I don’t know your name or even your gender, but I do know that I love you.
Joyce Farrell

To the User of the Data Files

To complete the steps and projects in this book, you need data files that have been created
specifically for this book. Your instructor will provide the data files to you. You also can
obtain the files electronically from www.CengageBrain.com. Find the ISBN of your title on the
back cover of your book, then enter the ISBN in the search box at the top of the Cengage
Brain home page. You can find the data files on the product page that opens. Note that
you can use a computer in your school lab or your own computer to complete the exercises
in this book.

Using Your Own Computer

To use your own computer to complete the steps and exercises, you need the following:
Software: Java SE 8, available from www.oracle.com/technetwork/java/index.html. Although
almost all of the examples in this book will work with earlier versions of Java, this book was
created using Java 8. The book clearly points out the few cases when an example is based on
Java 7 and will not work with earlier versions of Java. You also need a text editor, such as
Notepad. A few exercises ask you to use a browser for research.
Hardware: If you are using Windows 8, the Java Web site suggests at least 128 MB of
memory and at least 181 MB of disk space. For other operating system requirements, see
http://java.com/en/download/help.

YOU DO IT sections walk

students through program
development step by step.

NOTES provide
additional information—
for example, another
location in the book that
expands on a topic, or a
common error to watch
out for.

The author does an awesome

job: the examples, problems,
VIDEO LESSONS help
and material are very easy to
explain important chapter
understand!
concepts. Videos are part
—Bernice Cunningham, of the text’s enhanced
Wayne County Community
CourseMate site.
College District
Copyright 2016 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
Another random document with
no related content on Scribd:
TABLE XII
Plate Distance 1.6 cm. Distance of Fall .0975 cm. Volts 1,015.
Temperature 230 C. Radius of Drop .000063 cm.
No. of No. of
No. of charges No. of charges
Charges on Charges on
on drop Ion on drop Ion
Caught Caught
19.0 100.0 1P 20.0 10.0* 1N
16.0 2P 1P 20.0* 0 1P
8.0 3P 1P 100.0 1P 1P
20.0* 0 1P
20.0 16.0 2P 1P 100.0 1P 1P
8.0 3P 16.0 2P 1P
100.0 1P
17.0 2P 1P 104.0 1P
8.2 3P 1P 15.0 2P 1P
6.0 4P 1P 9.0 3P 1P
6.0 4P
7.0* 2N
9.8* 1N 1P 6.5* 2N
7.0* 2N 10.0* 1N 1P
20.0* 0 1P
21.0 20.0* 0 100.0 1P 1P
No. of No. of
No. of charges No. of charges
Charges on Charges on
on drop Ion on drop Ion
Caught Caught
95.0 1P 1P 15.5 2P 1P
16.5 2P 1P 8.0 3P 1P
8.0 3.P 1P 8.0 3P 1P
6.0 4P
100.0 1P 16.5 2P
16.0 2P 1P
8.4 3P 20.0* 0
20.0 106.0 1P 16.5 2P
16.0 2P 1P
8.4 3P 5.7 4P
10.0* 1N 100.0 1P
20.0* 0 1P 20.0* 0 1N
100.0 1P 1P 10.0* 1N 1N
16.0 2P 10.0* 1N 1N
100.0 1P 1P
16.0 2P 1P
8.0 3P

44 catches, all singles

It will be seen from Table XII that in 4 cases out of 44 we caught
negatives, although it would appear from the arrangement shown in
Fig. 12 that we could catch only positives. These negatives are
doubtless due to secondary rays which radiate in all directions from
the air molecules when these are subjected to the primary X-ray
radiation.
Toward the end of Table XII is an interesting series of catches. At
the beginning of this series, the drop was charged with 2 negatives
which produced a speed in the direction of gravity of 6.5 seconds. It
caught in succession 6 single positives before the field was thrown
off. The corresponding times were 6.5*, 10*, 20*, 100, 15.5, 8.0, 6.0.
The mean time during which the X-rays had to be on in order to
produce a “catch” was in these experiments about six seconds,
though in some instances it was as much as a minute. The majority
of the times recorded in column were actually measured with a
stop watch as recorded, but since there could be no possibility of
mistaking the 100-second speed, it was observed only four or five
times. It will be seen from Table XII that out of 44 catches of ions
produced by very hard X-rays there is not a single double. As a
result of observing from 500 to 1,000 catches in the manner
illustrated in Table XII, we came to the conclusion that, although we
had entered upon the investigation with the expectation of proving
the existence of valency in gaseous ionization, we had instead
obtained direct, unmistakable evidence that the act of ionization of
air molecules by both primary and secondary X-rays of widely
varying degrees of hardness, as well as by - and -rays, uniformly
consists, under all the conditions which we were able to investigate,
in the detachment from a neutral molecule of one single elementary
electrical charge.

III. RECENT EVIDENCE AS TO NATURE OF IONIZATION

PRODUCED BY ETHER WAVES
Although Townsend and Franck and Westphal dissented from the
foregoing conclusion, all the evidence which has appeared since has
tended to confirm it. Thus Salles,[60] using a new method due to
Langevin of measuring directly the ratio of the mobility to the
diffusion coefficient, concluded that when the ionization is produced
by -rays there are no ions bearing multiple charges. Again, the very
remarkable photographs (see plate opposite p. 190) taken by C. T.
R. Wilson in the Cavendish Laboratory of the tracks made by the
passage of X-rays through gases show no indication of a larger
number of negatively than of positively charged droplets. Such an
excess is to be expected if the act of ionization ever consists in these
experiments in the detachment of two or more negative electrons
from a neutral molecule. Further, if the initial act of ionization by X-
rays ever consists in the ejection of two or more corpuscles from a
single atom, there should appear in these Wilson photographs a
rosette consisting of a group of zigzag lines starting from a common
point. A glance at the plate opposite p. 192 shows that this is not the
case, each zigzag line having its own individual starting-point.
There are two other types of experiments which throw light on
this question.
When in the droplet experiments the X-rays are allowed to fall
directly upon the droplet, we have seen that they detach negative
electrons from it, and if the gas is at so low a pressure that there is
very little chance of the capture of ions by the droplet, practically all
of its changes in charge have this cause. Changes produced under
these conditions appear, so far as I have yet been able to discover,
to be uniformly unit changes. Also, when the changes are produced
by the incidence on the droplet of ultra-violet light, so far as the
experiments which have been carried out by myself or my pupils go,
they usually, though not always, have appeared to correspond to the
loss of one single electron. The same seems to have been true in
the experiments reported by A. Joffé,[61] who has given this subject
careful study.
Meyer and Gerlach,[62] it is true, seem very often to observe
changes corresponding to the simultaneous loss of several
electrons. It is to be noted, however, that their drops are generally
quite heavily charged, carrying from 10 to 30 electrons. Under such
conditions the loss of a single electron makes but a minute change in
speed, and is therefore likely not only to be unnoticed, but to be
almost impossible to detect until the change has become more
pronounced through the loss of several electrons. This question,
then, can be studied reliably only when the field is powerful enough
to hold the droplet balanced with only one or two free electrons upon
it. Experiments made under such conditions with my apparatus by
both Derieux[63] and Kelly[64] show quite conclusively that the act of
photo-emission under the influence of ultra-violet light consists in the
ejection of a single electron at each emission.
Table XIII contains one series of observations of this sort taken
with my apparatus by Mr. P. I. Pierson. The first column gives the
volts applied to the plates of the condenser shown in Fig. 7, p. 111.
These were made variable so that the drop might always be pulled
up with a slow speed even though its positive charge were
continually increasing. The second and third columns give the times
required to move 1 cm. under gravity and under the field
respectively. The fourth column gives the time intervals required for
the drop to experience a change in charge under the influence of a
constant source of ultra-violet light—a quartz mercury lamp. The fifth
column gives the total charge carried by the drop computed from
equation (12), p. 91. The sixth column shows the change in charge
computed from equation (10), p. 70. This is seen to be as nearly a
constant as could be expected in view of Brownian movements and
the inexact measurements of volts and times. The mean value of
is seen to be , which yields with the aid of equation (16),
p. 101, after the value of found for oil drops has been inserted,
, which is in better agreement with the result
obtained with oil drops than we had any right to expect. In these
experiments the light was weak so that the changes come only after
an average interval of 29 seconds and it will be seen that they are all
unit changes.
Table XIII
MERCURY DROPLET OF RADIUS
DISCHARGING
ELECTRONS UNDER THE INFLUENCE OF ULTRA-VIOLET LIGHT

Drop Time
No. 1 Interval No.
Sec. Charge
Volts Sec. between Electrons
per in
Discharges Emitted
per Cm. Cm.
in Seconds
2.260 11.0 - 1200} {49.4}
3.070 11.0 + 32.8} {50.5}
11 4.4 1
1.960 + 194 54.4
12.8
1.960 + 190 60.8 6.4 1
23
1.820 11.2 + 220 65.0 4.2 1
40.0
1.690 + 230 69.8 4.8 1
15.2
1.550 + 332 75.1 5.3 1
Drop
3.040 No. 2 + 98 43.5
10.4
5.6
Drop Time
No. 1 Interval No.
Sec. Charge
Volts Sec. between Electrons
per in
Discharges Emitted
per Cm. Cm.
in Seconds
2.540 + 200 49.4 5.9 1
18.6
2.230 + 300 55.2 5.8 1
35.0
2.230 + 76 60.7 5.5 1
42.0
1.930 + 200 65.0 4.3 1
54
1.810 + 176 69.6 4.6 1
70
1.650 + 250 75.2 5.6 1
45
1.520 + 500 79.4 4.2 1
9.8
1.520 + 119 85.1 5.5 1
Mean 29 Mean 5.1

So long, then, as we are considering the ionization of neutral

atoms through the absorption of an ether wave of any kind, the
evidence at present available indicates that the act always consists
in the detachment from the atom of one single negative electron, the
energy with which this electron is ejected from the atom depending,
as we shall see in chap. X, in a very definite and simple way upon
the frequency of the ether wave which ejects it.
IV. IONIZATION BY -RAYS
When the ionization is due to the passage of -rays through
matter, the evidence of the oil-drop experiments as well as that of C.
T. R. Wilson’s experiments (see chap. IX) on the photographing of
the tracks of the -rays is that here, too, the act consists in the
detachment of one single electron from a single atom. This
experimental result is easy to understand in the case of the -rays,
when it is remembered that Wilson’s photographs prove directly the
fact, long known from other types of evidence, that a -ray, in
general, ionizes but a very minute fraction of the number of atoms
through which it shoots before its energy is expended. If, then, its
chance, in shooting through an atom, of coming near enough to one
of the electronic constituents of that atom to knock it out is only one
in one thousand, or one in one million, then its chance of getting
near enough to two electronic constituents of the same atom to
knock them both out is likely to be negligibly small. The argument
here rests, however, on the assumption that the electrons within the
atom are independent of one another, which is not necessarily the
case, so that the matter must be decided after all solely by
experiment.
The difference between the act of ionization when produced by a
-ray and when produced by an ether wave seems, then, to consist
wholly in the difference in the energy with which the two agencies
hurl the electron from its mother atom. Wilson’s photographs show
that -rays do not eject electrons from atoms with appreciable
speeds, while ether waves may eject them with tremendous energy.
Some of Wilson’s photographs showing the effect of passing X-rays
through air are shown in the most interesting plate opposite p. 190.
The original X-rays have ejected electrons with great speeds from a
certain few of the atoms of the gas, and it is the tracks of these
electrons as they shoot through the atoms of the gas, ionizing here
and there as they go, which constitute the wiggly lines shown in the
photograph. Most of the ionization, then, which is produced by X-
rays is a secondary effect due to the negative electrons, i.e., the -
rays which the X-rays eject. If these -rays could in turn eject
electrons with ionizing speeds, each of the dots in one of these -ray
tracks would be the starting-point of a new wiggly line like the
original one. But such is not the case. We may think, then, of the -
rays as simply shaking loose electronic dust from some of the atoms
through which they pass while we think of the X-rays as taking hold
in some way of the negative electrons within an atom and hurling
them out with enormous energy.

V. IONIZATION BY -RAYS
But what happens to the electronic constituents of an atom when
an -particle, that is, a helium atom, shoots through it? Some of
Bragg’s experiments and Wilson’s photographs show that the -
particles shoot in straight lines through from 3 to 7 cm. of air before
they are brought to rest. We must conclude, then, that an atom has
so loose a structure that another atom, if endowed with enough
speed, can shoot straight through it without doing anything more
than, in some instances, to shake off from that atom an electron or
two. The tracks shown in Figs. 14 and 15, facing p. 190, are Wilson’s
photographs of the tracks of the -particles of radium. They ionize
so many of the atoms through which they pass that the individual
droplets of water which form about the ions produced along the path
of the ray, and which are the objects really photographed, are not
distinguishable as individuals. The sharp changes in the direction of
the ray toward the end of the path are convincing evidence that the
-particle actually goes through the atoms instead of pushing them
aside as does a bullet. For if one solar system, for example,
endowed with a stupendous speed, were to shoot straight through
another similar system, but without an actual impact of their central
bodies, the deflection from its straight path which the first system
experienced might be negligibly small if its speed were high enough,
and that for the simple reason that the two systems would not be in
each other’s vicinity long enough to produce a deflecting effect. In
technical terms the time integral of the force would be negligibly
small. The slower the speed, however, the longer this time, and
hence the greater the deflection. Thus it is only when the -particle
shown in Fig. 15 has lost most of its velocity—i.e., it is only toward
the end of its path—that the nuclei of the atoms through which it
passes are able to deflect it from its straight path. If it pushed the
molecules aside as a bullet does, instead of going through them, the
resistance to its motion would be greatest when the speed is highest.
Now, the facts are just the opposite of this. The -particle ionizes
several times more violently toward the end of its path than toward
the beginning, and it therefore loses energy more rapidly when it is
going slowly than when it is going rapidly. Further, it is deflected
more readily, then, as the photograph shows. All of this is just as it
should be if the -particle shoots straight through the molecules in
its path instead of pushing them aside.
These photographs of Wilson’s are then the most convincing
evidence that we have that the atom is a sort of miniature stellar
system with constituents which are unquestionably just as minute
with respect to the total volume occupied by the atom as are the sun
and planets and other constituents of the solar system with respect
to the whole volume inclosed within the confines of this system.
When two molecules of a gas are going as slowly as they are in the
ordinary motion of thermal agitation, say a mile a second, when their
centers come to within a certain distance—about 0.2 . (millionths
of a millimeter)—they repel one another and so the two systems do
not interpenetrate. This is the case of an ordinary molecular collision.
But endow one of these molecules with a large enough energy and it
will shoot right through the other, sometimes doubtless without so
much as knocking out a single electron. This is the case of an -
particle shooting through air
But the question to which we are here seeking an answer is,
does an individual -particle ever knock more than one electron
from a single atom or molecule through which it passes, so as to
leave that atom doubly or trebly charged? The oil-drop method used
at low pressures[65] has given a very definite answer to this question.
In no gas or vapor except helium, which we have as yet tried, is
them any certain evidence that an individual -ray in shooting
through an atom is able to remove from that atom more than one
single electron at a time.
The foregoing result has been obtained by shooting the -rays
from polonium through a rarefied gas in an oil-drop apparatus of the
type sketched in Fig. 12, catching upon a balanced oil drop the
positively charged residue of one of the atoms thus ionized, and
counting, by the change in speed imparted to the droplet, the
number of electrons which were detached from the captured atom by
the passage of the -ray through or near it.[66]
This mode of experimenting extended to helium, however, has
yielded the most interesting result[67] that every sixth one on the
average of all the passages, or “shots,” which detached any
electrons at all from the helium atom detached both of the two
electrons which the neutral helium atom possesses. Since some of
the ionization produced along the path of an -ray is probably due to
slow-speed secondary -rays produced by the -ray, it is probable
that the fraction of the actual passages through helium atoms of -
rays themselves which detach both electrons is greater than the
foregoing one in six. It has been estimated by Fowler at as high as
three in four.
The foregoing experimental result of one in six was obtained only
at the very end of the range of the -rays where they have their
maximum ionizing power. When these rays were near the beginning
of their range, and therefore were moving much more rapidly, the
fraction of the number of double catches to total catches was only
about half as much, i.e., the chance of getting both electrons at a
single shot is much smaller with a high-speed bullet than with a slow-
speed one. This is to be expected if the two electrons are
independent of each other, i.e., if the removal of one does not carry
the other out with it.
The foregoing is, I think, the only experiment which has yet been
devised in which the act of ionization is isolated and studied as an
individual thing.
Since 1913, however, very definite evidence has come in from
two different sources that multiply-valent. ions are often produced in
discharge tubes. The most unambiguous proof of this result has
been furnished by the spectroscope. Indeed, Mr. Bowen and the
author have recently found with great definiteness that high-voltage
vacuum sparks give rise to spectral lines which are due to singly-,
doubly-, trebly-, quadruply-, and quintuply- charged atoms of the
elements from lithium to nitrogen, and even to sextuply-charged
ones in the case of sulphur.[68] In view of the foregoing studies with
X-rays, -rays, and -rays, it is probable that these
spectroscopically discovered multiply-charged ions are produced by
successive ionizations such as might be expected to take place in a
region carrying a very dense electron current, such as must exist in
our “hot-sparks.”
Again, J. J. Thomson has brought forward evidence[69] that the
positive residues of atoms which shoot through discharge tubes in a
direction opposite to that of the cathode rays have suffered multiple
ionization. Indeed, he thinks he has evidence that the act of
ionization of atoms of mercury consists either in the detachment of
one negative electron or else in the detachment of eight. His
evidence for the existence in the case of mercury of multiple charges
from one up to eight is certainly very convincing, and it is possible,
also, that under his conditions the act of ionization itself may consist
in the detachment either of one or of eight electrons as he suggests.
Further evidence upon this point must be sought.

VI. SUMMARY
The results of the studies reviewed in this chapter may be
summarized thus:
1. The act of ionization by -rays seems to consist in the shaking
off without any appreciable energy of one single electron from an
occasional molecule through which the -ray passes. The faster the
-ray the less frequently does it ionize.
2. The act of ionization by ether waves, i.e., by X-rays or light,
seems to consist in the hurling out with an energy which may be very
large, but which depends upon the frequency of the incident ether
wave, of one single electron from an occasional molecule over which
this wave passes.
3. The act of ionization by rapidly moving -particles consists
generally in the shaking loose of one single electron from the atom
through which it passes, though in the case of helium, two electrons
are certainly sometimes removed at once. It may be, too, that a very
slow-moving positive ray, such as J. J. Thomson used, may detach
several electrons from a single atom.
CHAPTER VII
BROWNIAN MOVEMENTS IN GASES
I. HISTORICAL SUMMARY
In 1827 the English botanist, Robert Brown, first made mention of
the fact that minute particles of dead matter in suspension in liquids
can be seen in a high-power microscope to be endowed with
irregular wiggling motions which strongly suggest “life.”[70] Although
this phenomenon was studied by numerous observers and became
known as the phenomenon of the Brownian movements, it remained
wholly unexplained for just fifty years. The first man to suggest that
these motions were due to the continual bombardment to which
these particles are subjected because of the motion of thermal
agitation of the molecules of the surrounding medium was the
Belgian Carbonelle, whose work was first published by his
collaborator, Thirion, in 1880,[71] although three years earlier
Delsaulx[72] had given expression to views of this sort but had
credited Carbonelle with priority in adopting them. In 1881
Bodoszewski[73] studied the Brownian movements of smoke
particles and other suspensions in air and saw in them “an
approximate image of the movements of the gas molecules as
postulated by the kinetic theory of gases.” Others, notably Gouy,[74]
urged during the next twenty years the same interpretation, but it
was not until 1905 that a way was found to subject the hypothesis to
a quantitative test. Such a test became possible through the brilliant
theoretical work of Einstein[75] of Bern, Switzerland, who, starting
merely with the assumption that the mean kinetic energy of agitation
of a particle suspended in a fluid medium must be the same as the
mean kinetic energy of agitation of a gas molecule at the same
temperature, developed by unimpeachable analysis an expression
for the mean distance through which such a particle should drift in a
given time through a given medium because of this motion of
agitation. This distance could be directly observed and compared
with the theoretical value. Thus, suppose one of the wiggling
particles is observed in a microscope and its position noted on a
scale in the eyepiece at a particular instant, then noted again at the
end of (for example, 10) seconds, and the displacement in that
time along one particular axis recorded. Suppose a large number of
such displacements in intervals all of length are observed,
each one of them squared, and the mean of these squares taken
and denoted by : Einstein showed that the theoretical value of
should be

in which is the universal gas constant per gram molecule, namely,

, the temperature on the absolute scale,
the number of molecules in one gram molecule, and a resistance
factor depending upon the viscosity of the medium and the size of
the drop, and representing the ratio between the force applied to the
particle in any way and the velocity produced by that force. If
Stokes’s Law, namely, , held for the motion of the
particle through the medium, then would have the value
, so that Einstein’s formula would become

This was the form which Einstein originally gave to his equation, a
very simple derivation of which has been given by Langevin.[76] The
essential elements of this derivation will be found in Appendix C.
The first careful test of this equation was made on suspensions in
liquids by Perrin,[77] who used it for finding the number of
molecules in a gram molecule. He obtained the mean value
, which, in view of the uncertainties in the
measurement of both and , may be considered as proving
the correctness of Einstein’s equation within the limits of error of
Perrin’s measurements, which differ among themselves by as much
as 30 per cent.

II. QUANTITATIVE MEASUREMENTS IN GASES

Up to 1909 there had been no quantitative work whatever on
Brownian movements in gases. Bodoszewski had described them
fully and interpreted them correctly in 1881. In 1906
Smoluchowski[78] had computed how large the mean displacements
in air for particles of radius ought to be, and in 1907
Ehrenhaft[79] had recorded displacements of the computed order
with particles the sizes of which he made, however, no attempt to
measure, so that he knew nothing at all about the resistance factor
. There was then nothing essentially quantitative about this work.
In March, 1908, De Broglie, in Paris,[80] made the following
significant advance. He drew the metallic dust arising from the
condensation of the vapors coming from an electric arc or spark
between metal electrodes (a phenomenon discovered by Hemsalech
and De Watteville[81]) into a glass box and looked down into it
through a microscope upon the particles rendered visible by a beam
of light passing horizontally through the box and illuminating thus the
Brownian particles in the focal plane of the objective. His addition
consisted in placing two parallel metal plates in vertical planes, one
on either side of the particles, and in noting that upon applying a
potential difference to these plates some of the particles moved
under the influence of the field toward one plate, some remained at
rest, while others moved toward the other plate, thus showing that a
part of these particles were positively electrically charged and a part
negatively. In this paper he promised a study of the charges on these
particles. In May, 1909, in fulfilling this promise[82] he made the first
quantitative study of Brownian movements in gases. The particles
used were minute droplets of water condensed upon tobacco smoke.
The average rate at which these droplets moved in Broglie’s
horizontal electric field was determined. The equation for this motion
was

The mean was next measured for a great many particles and
introduced into Einstein’s equation:

From these two equations was eliminated and obtained in terms

of . Introducing Perrin’s value of , De Broglie obtained from one
series of measurements ; from another series on
larger particles he got a mean value several times larger—a result
which he interpreted as indicating multiple charges on the larger
particles. Although these results represent merely mean values for
many drops which are not necessarily all alike, either in radius or
charge, yet they may be considered as the first experimental
evidence that Einstein’s equation holds approximately, in gases, and
they are the more significant because nothing has to be assumed
about the size of the particles, if they are all alike in charge and
radius, or about the validity of Stokes’s Law in gases, the -factor
being eliminated.
The development of the oil-drop method made it possible to
subject the Brownian-movement theory to a more accurate and
convincing experimental test than had heretofore been attainable,
and that for the following reasons:
1. It made it possible to hold, with the aid of the vertical electrical
field, one particular particle under observation for hours at a time and
to measure as many displacements as desired on it alone instead of
assuming the identity of a great number of particles, as had been
done in the case of suspensions in liquids and in De Broglie’s
experiments in gases.
2. Liquids are very much less suited than are gases to convincing
tests of any kinetic hypothesis, for the reason that prior to Brownian-
movement work we had no satisfactory kinetic theory of liquids at all.
3. The absolute amounts of the displacements of a given particle
in air are 8 times greater and in hydrogen 15 times greater than in
water.
4. By reducing the pressure to low values the displacements can
easily be made from 50 to 200 times greater in gases than in liquids.
5. The measurements can be made independently of the most
troublesome and uncertain factor involved in Brownian-movement
work in liquids, namely, the factor , which contains the radius of
the particle and the law governing its motion through the liquid.
Accordingly, there was begun in the Ryerson Laboratory, in 1910,
a series of very careful experiments in Brownian movements in
gases. Svedberg,[83] in reviewing this subject in 1913, considers this
“the only exact investigation of quantitative Brownian movements in
gases.” A brief summary of the method and results was published by
the author.[84] A full account was published by Mr. Harvey Fletcher in
May, 1911,[85] and further work on the variation of Brownian
movements with pressure was presented by the author the year
following.[86] The essential contribution of this work as regards
method consisted in the two following particulars:
1. By combining the characteristic and fully tested equation of the
oil-drop method, namely,

with the Einstein Brownian-movement equation, namely,

it was possible to obtain the product without any reference to the
size of the particle or the resistance of the medium to its motion. This
quantity could then be compared with the same product obtained
with great precision from electrolysis. The experimental procedure
consists in balancing a given droplet and measuring, as in any
Brownian-movement work, the quantity , then unbalancing it
and measuring , and ( ; the combination of (24) and
(25) then gives

Since it is awkward to square each displacement before

averaging, it is preferable to modify by substituting from the Maxwell
distribution law, which holds for Brownian displacements as well as
for molecular velocities, the relation

We obtain thus

The possibility of thus eliminating the size of the particle and with
it the resistance of the medium to its motion can be seen at once
from the simple consideration that so long as we are dealing with
one and the same particle the ratio between the force acting and
the velocity produced by it must be the same, whether the acting
force is due to gravity or an electrical held, as in the oil-drop
experiments, or to molecular impacts as in Brownian-movement
work. De Broglie might have made such an elimination and
calculation of in his work, had his Brownian displacements and
mobilities in electric fields been made on one and the same particle,
but when the two sets of measurements are made on different
particles, such elimination would involve the very uncertain
assumption of identity of the particles in both charge and size.
Although De Broglie did actually make this assumption, he did not
treat his data in the manner indicated, and the first publication of this
method of measuring as well as the first actual determination
was made in the papers mentioned above.
Some time later E. Weiss reported similar work to the Vienna
Academy.[87]
2. Although it is possible to make the test of in just the
method described and although it was so made in the case of one or
two drops, Mr. Fletcher worked out a more convenient method,
which involves expressing the displacements in terms of the
fluctuations in the time required by the particle to fall a given
distance and thus dispenses with the necessity of balancing the drop
at all. I shall present another derivation which is very simple and yet
of unquestionable validity.
In equation (28) let be the time required by the particle, if there
were no Brownian movements, to fall between a series of equally
spaced cross-hairs whose distance apart is . In view of such
movements the particle will have moved up or down a distance
in the time . Let us suppose this distance to be up. Then the actual
time of fall will be , in which is now the time it takes the
particle to fall the distance . If now is small in comparison
with , that is, if is small in comparison with (say ⅒ or less),
then we shall introduce a negligible error (of the order ¹⁄₁₀₀ at the
most) if we assume that in which is the mean
velocity under gravity. Replacing then in (28) ( , by in
which is the square of the average difference between an