100% found this document useful (5 votes)

297 views

Immediate download Java Programming 7th Edition Joyce Farrell ebooks 2024

Joyce

Uploaded by

kotaraxian35

Available Formats

Download as PDF, TXT or read online on Scribd

100% found this document useful (5 votes)

297 views

Immediate download Java Programming 7th Edition Joyce Farrell ebooks 2024

Joyce

Uploaded by

kotaraxian35

Available Formats

Download as PDF, TXT or read online on Scribd

You are on page 1/ 81

Download the full version of the ebook at

https://ebookultra.com

Java Programming 7th Edition Joyce Farrell

https://ebookultra.com/download/java-
programming-7th-edition-joyce-farrell/

Explore and download more ebook at https://ebookultra.com

Recommended digital products (PDF, EPUB, MOBI) that
you can download immediately if you are interested.

Java Programming 8th Edition Joyce Farrell

https://ebookultra.com/download/java-programming-8th-edition-joyce-
farrell/

ebookultra.com

Programming Logic and Design Comprehensive 6th Edition

Joyce Farrell

https://ebookultra.com/download/programming-logic-and-design-
comprehensive-6th-edition-joyce-farrell/

ebookultra.com

Java Programs to Accompany Programming Logic and Design

7th Edition Jo Ann Smith

https://ebookultra.com/download/java-programs-to-accompany-
programming-logic-and-design-7th-edition-jo-ann-smith/

ebookultra.com

Computer programming for teens 1st Edition Mary E. Farrell

https://ebookultra.com/download/computer-programming-for-teens-1st-
edition-mary-e-farrell/

ebookultra.com
Advanced Java Game Programming Wallace Croft

https://ebookultra.com/download/advanced-java-game-programming-
wallace-croft/

ebookultra.com

Java Programming 10 Minute Solutions 1st Edition Mark

Watson

https://ebookultra.com/download/java-programming-10-minute-
solutions-1st-edition-mark-watson/

ebookultra.com

Killer Game Programming in Java 1st Edition Andrew Davison

https://ebookultra.com/download/killer-game-programming-in-java-1st-
edition-andrew-davison/

ebookultra.com

Introduction to Programming with Java 3rd Edition John

Dean

https://ebookultra.com/download/introduction-to-programming-with-
java-3rd-edition-john-dean/

ebookultra.com

The Java TM Programming Language 4th Edition Ken Arnold

https://ebookultra.com/download/the-java-tm-programming-language-4th-
edition-ken-arnold/

ebookultra.com
Java Programming 7th Edition Joyce Farrell Digital
Instant Download
Author(s): Joyce Farrell
ISBN(s): 9781285081953, 1285081951
Edition: 7
File Details: PDF, 32.45 MB
Year: 2014
Language: english
Buy. Rent. Access.

Access student data files and other study

tools on cengagebrain.com.

For detailed instructions visit

www.cengage.com/ct/studentdownload.

Store your Data Files on a USB drive for maximum efficiency in

organizing and working with the files.

Macintosh users should use a program to expand WinZip or PKZip archives.

Ask your instructor or lab coordinator for assistance.

TM
JAVA PROGRAMMING

JOYCE FARRELL

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

Course Technology
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 international.cengage.com/region

Cengage Learning products are represented in Canada by Nelson

Education, Ltd.

For your course and 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.
Instructors: Please visit login.cengage.com and log in to access
instructor-specific resources.

Printed in the United States of America

1 2 3 4 5 6 18 17 16 15 14 13

Preface . . . . . . . . . . . . . . . . . . . . . . xxi
CHAPTER 1 Creating Java Programs . . . . . . . . . . . . . . . . 1
CHAPTER 2 Using Data . . . . . . . . . . . . . . . . . . . . . 51
CHAPTER 3 Using Methods, Classes, and Objects . . . . . . . 117
CHAPTER 4 More Object Concepts . . . . . . . . . . . . . . . 179
CHAPTER 5 Making Decisions . . . . . . . . . . . . . . . . . 241
CHAPTER 6 Looping . . . . . . . . . . . . . . . . . . . . . 299
CHAPTER 7 Characters, Strings, and the StringBuilder . . . . . 349
CHAPTER 8 Arrays . . . . . . . . . . . . . . . . . . . . . . 397
CHAPTER 9 Advanced Array Concepts . . . . . . . . . . . . . 443
CHAPTER 10 Introduction to Inheritance . . . . . . . . . . . . . 499
CHAPTER 11 Advanced Inheri tance Concepts . . . . . . . . . . 547
CHAPTER 12 Exception Handling . . . . . . . . . . . . . . . . 603
CHAPTER 13 File Input and Output . . . . . . . . . . . . . . . 675
CHAPTER 14 Introduction to Swing Components . . . . . . . . 739
CHAPTER 15 Advanced GUI Topics . . . . . . . . . . . . . . . 801
CHAPTER 16 Graphics . . . . . . . . . . . . . . . . . . . . . 879
CHAPTER 17 Applets, Images, and Sound . . . . . . . . . . . . 945
APPENDIX A Working with the Java Platform . . . . . . . . . . . 993
APPENDIX B Learning About Data Representation . . . . . . . 1001
APPENDIX C Formatting Output . . . . . . . . . . . . . . . 1009
APPENDIX D Generating Random Numbers . . . . . . . . . . 1021
APPENDIX E Javadoc . . . . . . . . . . . . . . . . . . . . 1029
Glossary . . . . . . . . . . . . . . . . . . . . 1037
Index . . . . . . . . . . . . . . . . . . . . . . 1063

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

C H AP T E R 1 Creating Java Programs . . . . . . . . . . . 1

Learning Programming Terminology . . . . . . . . . . . . . . 2
Comparing Procedural and Object-Oriented Programming
Concepts . . . . . . . . . . . . . . . . . . . . . . . . 5
Procedural Programming . . . . . . . . . . . . . . . . . . 5
Object-Oriented Programming . . . . . . . . . . . . . . . . 5
Understanding Classes, Objects, and Encapsulation . . . . . . 6
Understanding Inheritance and Polymorphism . . . . . . . . . 8
Features of the Java Programming Language . . . . . . . . . . 10
Java Program Types . . . . . . . . . . . . . . . . . . . . 11
Analyzing a Java Application that Produces Console Output . . . . 12
Understanding the Statement that Produces the Output . . . . . 13
Understanding the First Class . . . . . . . . . . . . . . . 14
Indent Style . . . . . . . . . . . . . . . . . . . . . . . 17
Understanding the main() Method . . . . . . . . . . . . . 18
Saving a Java Class . . . . . . . . . . . . . . . . . . . . 20
Compiling a Java Class and Correcting Syntax Errors . . . . . . . 22
Compiling a Java Class . . . . . . . . . . . . . . . . . . . 22
Correcting Syntax Errors . . . . . . . . . . . . . . . . . . 23
Running a Java Application and Correcting Logical Errors . . . . . 28
Running a Java Application . . . . . . . . . . . . . . . . . 28
Modifying a Compiled Java Class . . . . . . . . . . . . . . 29
Correcting Logical Errors . . . . . . . . . . . . . . . . . . 30
Adding Comments to a Java Class . . . . . . . . . . . . . . . 31
Creating a Java Application that Produces GUI Output . . . . . . 34
Finding Help . . . . . . . . . . . . . . . . . . . . . . . . 37
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . . 38
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . . 40

C H AP T E R 2 Using Data . . . . . . . . . . . . . . . . . 51
Declaring and Using Constants and Variables . . . . . . . . . . 52
Declaring Variables . . . . . . . . . . . . . . . . . . . . 53
Declaring Named Constants . . . . . . . . . . . . . . . . 54
The Scope of Variables and Constants . . . . . . . . . . . . 56
Concatenating Strings to Variables and Constants . . . . . . . 56
Pitfall: Forgetting That a Variable Holds One Value at a Time . . . 58
Learning About Integer Data Types . . . . . . . . . . . . . . 62
Using the boolean Data Type . . . . . . . . . . . . . . . . 67
Learning About Floating-Point Data Types . . . . . . . . . . . . 69
Using the char Data Type . . . . . . . . . . . . . . . . . . 70
Using the Scanner Class to Accept Keyboard Input . . . . . . . 76
Pitfall: Using nextLine() Following One of the
Other Scanner Input Methods . . . . . . . . . . . . . . 79
Using the JOptionPane Class to Accept GUI Input . . . . . . . 85
Using Input Dialog Boxes . . . . . . . . . . . . . . . . . . 85
Using Confirm Dialog Boxes . . . . . . . . . . . . . . . . 89
Performing Arithmetic . . . . . . . . . . . . . . . . . . . . 91
Associativity and Precedence . . . . . . . . . . . . . . . . 93
Writing Arithmetic Statements Efficiently . . . . . . . . . . . 94
Pitfall: Not Understanding Imprecision in
Floating-Point Numbers . . . . . . . . . . . . . . . . . 94
Understanding Type Conversion . . . . . . . . . . . . . . . . 99
Automatic Type Conversion . . . . . . . . . . . . . . . . . 99
Explicit Type Conversions . . . . . . . . . . . . . . . . 100
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 104
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 105
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 109
Review Questions . . . . . . . . . . . . . . . . . . . . . 109

Exercises . . . . . . . . . . . . . . . . . . . . . . . . 112
Programming Exercises . . . . . . . . . . . . . . . . . 112
Debugging Exercises . . . . . . . . . . . . . . . . . . 115
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 115
viii Case Problems . . . . . . . . . . . . . . . . . . . . . 116

C H AP T E R 3 Using Methods, Classes, and Objects . . . . 117

Understanding Method Calls and Placement . . . . . . . . . . 118
Understanding Method Construction . . . . . . . . . . . . . 121
Access Specifiers . . . . . . . . . . . . . . . . . . . . 121
Return Type . . . . . . . . . . . . . . . . . . . . . . 122
Method Name . . . . . . . . . . . . . . . . . . . . . 123
Parentheses . . . . . . . . . . . . . . . . . . . . . . 123
Adding Parameters to Methods . . . . . . . . . . . . . . . 127
Creating a Method That Receives a Single Parameter . . . . . 128
Creating a Method That Requires Multiple Parameters . . . . 130
Creating Methods That Return Values . . . . . . . . . . . . 133
Chaining Method Calls . . . . . . . . . . . . . . . . . . 135
Learning About Classes and Objects . . . . . . . . . . . . . 139
Creating a Class . . . . . . . . . . . . . . . . . . . . . 142
Creating Instance Methods in a Class . . . . . . . . . . . . 143
Organizing Classes . . . . . . . . . . . . . . . . . . . 147
Declaring Objects and Using Their Methods . . . . . . . . . . 151
Understanding Data Hiding . . . . . . . . . . . . . . . . 153
An Introduction to Using Constructors . . . . . . . . . . . . 156
Understanding That Classes Are Data Types . . . . . . . . . 160
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 165
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 165
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 167
Review Questions . . . . . . . . . . . . . . . . . . . . . 168
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 171
Programming Exercises . . . . . . . . . . . . . . . . . 171
Debugging Exercises . . . . . . . . . . . . . . . . . . 175
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 175
Case Problems . . . . . . . . . . . . . . . . . . . . . 176

Creating and Calling Constructors with Parameters . . . . . . . 196

Overloading Constructors . . . . . . . . . . . . . . . . 197
Learning About the this Reference . . . . . . . . . . . . . 201
Using the this Reference to Make Overloaded Constructors More
Efficient . . . . . . . . . . . . . . . . . . . . . . . 205
Using static Fields . . . . . . . . . . . . . . . . . . . 208
Using Constant Fields . . . . . . . . . . . . . . . . . . 210
Using Automatically Imported, Prewritten Constants and Methods 215
Importing Classes That Are Not Imported Automatically . . . . 217
Using the GregorianCalendar Class . . . . . . . . . . 219
Understanding Composition and Nested Classes . . . . . . . . 225
Composition . . . . . . . . . . . . . . . . . . . . . . 225
Nested Classes . . . . . . . . . . . . . . . . . . . . . 227
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 229
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 229
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 231
Review Questions . . . . . . . . . . . . . . . . . . . . . 232
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 234
Programming Exercises . . . . . . . . . . . . . . . . . 234
Debugging Exercises . . . . . . . . . . . . . . . . . . 237
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 238
Case Problems . . . . . . . . . . . . . . . . . . . . . 239

C H AP T E R 5 Making Decisions . . . . . . . . . . . . . 241

Planning Decision-Making Logic . . . . . . . . . . . . . . . 242
The if and if…else Structures . . . . . . . . . . . . . . 244
Pitfall: Misplacing a Semicolon in an if Statement . . . . . . 245
Pitfall: Using the Assignment Operator Instead of the
Equivalency Operator . . . . . . . . . . . . . . . . . 246
Pitfall: Attempting to Compare Objects Using
the Relational Operators . . . . . . . . . . . . . . . . 246
The if…else Structure . . . . . . . . . . . . . . . . . 247

Using Multiple Statements in if and if…else Clauses . . . . 250

Nesting if and if…else Statements . . . . . . . . . . . . 256
Using Logical AND and OR Operators . . . . . . . . . . . . 259
The AND Operator . . . . . . . . . . . . . . . . . . . . 259
x The OR Operator . . . . . . . . . . . . . . . . . . . . 261
Short-Circuit Evaluation . . . . . . . . . . . . . . . . . . 262
Making Accurate and Efficient Decisions . . . . . . . . . . . 265
Making Accurate Range Checks . . . . . . . . . . . . . . 265
Making Efficient Range Checks . . . . . . . . . . . . . . 268
Using && and || Appropriately . . . . . . . . . . . . . . 269
Using the switch Statement . . . . . . . . . . . . . . . . 270
Using the Conditional and NOT Operators . . . . . . . . . . . 276
Using the NOT Operator . . . . . . . . . . . . . . . . . 277
Understanding Operator Precedence . . . . . . . . . . . . . 278
Adding Decisions and Constructors to Instance Methods . . . . 281
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 285
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 285
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 287
Review Questions . . . . . . . . . . . . . . . . . . . . . 287
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 291
Programming Exercises . . . . . . . . . . . . . . . . . 291
Debugging Exercises . . . . . . . . . . . . . . . . . . 295
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 295
Case Problems . . . . . . . . . . . . . . . . . . . . . 297

C H AP T E R 6 Looping . . . . . . . . . . . . . . . . . 299
Learning About the Loop Structure . . . . . . . . . . . . . . 300
Creating while Loops . . . . . . . . . . . . . . . . . . 301
Writing a Definite while Loop . . . . . . . . . . . . . . 301
Pitfall: Failing to Alter the Loop Control Variable Within
the Loop Body . . . . . . . . . . . . . . . . . . . . 303
Pitfall: Creating a Loop with an Empty Body . . . . . . . . . 304
Altering a Definite Loop’s Control Variable . . . . . . . . . . 305
Writing an Indefinite while Loop . . . . . . . . . . . . . 306
Validating Data . . . . . . . . . . . . . . . . . . . . . 308
Using Shortcut Arithmetic Operators . . . . . . . . . . . . . 312
Creating a for Loop . . . . . . . . . . . . . . . . . . . 317

C H AP T E R 7 Characters, Strings, and the StringBuilder . . . . 349

Understanding String Data Problems . . . . . . . . . . . . . 350
Manipulating Characters . . . . . . . . . . . . . . . . . . 351
Declaring and Comparing String Objects . . . . . . . . . . 357
Comparing String Values . . . . . . . . . . . . . . . . 357
Empty and null Strings . . . . . . . . . . . . . . . . . 361
Using Other String Methods . . . . . . . . . . . . . . . 363
Converting String Objects to Numbers . . . . . . . . . . . 370
Learning About the StringBuilder and
StringBuffer Classes . . . . . . . . . . . . . . . . 374
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 382
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 382
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 384
Review Questions . . . . . . . . . . . . . . . . . . . . . 385
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 387
Programming Exercises . . . . . . . . . . . . . . . . . 387
Debugging Exercises . . . . . . . . . . . . . . . . . . 391
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 391
Case Problems . . . . . . . . . . . . . . . . . . . . . 394

C H AP T E R 8 Arrays . . . . . . . . . . . . . . . . . . 397
Declaring Arrays . . . . . . . . . . . . . . . . . . . . . 398
Initializing an Array . . . . . . . . . . . . . . . . . . . . 403
Using Variable Subscripts with an Array . . . . . . . . . . . . 406
xii Using Part of an Array . . . . . . . . . . . . . . . . . . 408
Declaring and Using Arrays of Objects . . . . . . . . . . . . 410
Using the Enhanced for Loop with Objects . . . . . . . . . 412
Manipulating Arrays of Strings . . . . . . . . . . . . . 412
Searching an Array and Using Parallel Arrays . . . . . . . . . 418
Using Parallel Arrays . . . . . . . . . . . . . . . . . . . 418
Searching an Array for a Range Match . . . . . . . . . . . 421
Passing Arrays to and Returning Arrays from Methods . . . . . 425
Returning an Array from a Method . . . . . . . . . . . . . 429
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 431
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 431
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 432
Review Questions . . . . . . . . . . . . . . . . . . . . . 433
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 436
Programming Exercises . . . . . . . . . . . . . . . . . 436
Debugging Exercises . . . . . . . . . . . . . . . . . . 439
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 439
Case Problems . . . . . . . . . . . . . . . . . . . . . 441

C H AP T E R 9 Advanced Array Concepts . . . . . . . . . 443

Sorting Array Elements Using the Bubble Sort Algorithm . . . . 444
Using the Bubble Sort Algorithm . . . . . . . . . . . . . . 445
Sorting Arrays of Objects . . . . . . . . . . . . . . . . . 447
Sorting Array Elements Using the Insertion Sort Algorithm . . . . 453
Using Two-Dimensional and Other Multidimensional Arrays . . . . 457
Passing a Two-Dimensional Array to a Method . . . . . . . . 460
Using the length Field with a Two-Dimensional Array . . . . 460
Understanding Ragged Arrays . . . . . . . . . . . . . . . 462
Using Other Multidimensional Arrays . . . . . . . . . . . . 462
Using the Arrays Class . . . . . . . . . . . . . . . . . . 465
Using the ArrayList Class . . . . . . . . . . . . . . . . 473
Understanding the Limitations of the ArrayList Class . . . 478
Creating Enumerations . . . . . . . . . . . . . . . . . . . 479
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 486
Copyright 2013 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.
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 486
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 487
Review Questions . . . . . . . . . . . . . . . . . . . . . 488
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 492
Programming Exercises . . . . . . . . . . . . . . . . . 492 xiii
Debugging Exercises . . . . . . . . . . . . . . . . . . 495
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 495
Case Problems . . . . . . . . . . . . . . . . . . . . . 498

C H AP T E R 1 0 Introduction to Inheritance . . . . . . . . . 499

Learning About the Concept of Inheritance . . . . . . . . . . 500
Diagramming Inheritance Using the UML . . . . . . . . . . 500
Inheritance Terminology . . . . . . . . . . . . . . . . . 503
Extending Classes . . . . . . . . . . . . . . . . . . . . . 504
Overriding Superclass Methods . . . . . . . . . . . . . . . 511
Calling Constructors During Inheritance . . . . . . . . . . . . 514
Using Superclass Constructors That Require Arguments . . . 516
Accessing Superclass Methods . . . . . . . . . . . . . . . 521
Comparing this and super . . . . . . . . . . . . . . . 523
Employing Information Hiding . . . . . . . . . . . . . . . . 524
Methods You Cannot Override . . . . . . . . . . . . . . . . 526
A Subclass Cannot Override static
Methods in Its Superclass . . . . . . . . . . . . . . . 526
A Subclass Cannot Override final
Methods in Its Superclass . . . . . . . . . . . . . . . 530
A Subclass Cannot Override Methods
in a final Superclass . . . . . . . . . . . . . . . . 532
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 533
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 533
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 535
Review Questions . . . . . . . . . . . . . . . . . . . . . 536
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 539
Programming Exercises . . . . . . . . . . . . . . . . . 539
Debugging Exercises . . . . . . . . . . . . . . . . . . 543
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 543
Case Problems . . . . . . . . . . . . . . . . . . . . . 544

C H AP T E R 1 1 Advanced Inheritance Concepts . . . . . . . 547

Creating and Using Abstract Classes . . . . . . . . . . . . . 548
Using Dynamic Method Binding . . . . . . . . . . . . . . . 557
Using a Superclass as a Method Parameter Type . . . . . . 559
xiv Creating Arrays of Subclass Objects . . . . . . . . . . . . . 561
Using the Object Class and Its Methods . . . . . . . . . . . 565
Using the toString() Method . . . . . . . . . . . . . 566
Using the equals() Method . . . . . . . . . . . . . . . 569
Using Inheritance to Achieve Good Software Design . . . . . . 572
Creating and Using Interfaces . . . . . . . . . . . . . . . . 574
Creating Interfaces to Store Related Constants . . . . . . . 579
Creating and Using Packages . . . . . . . . . . . . . . . . 583
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 589
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 589
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 590
Review Questions . . . . . . . . . . . . . . . . . . . . . 591
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 594
Programming Exercises . . . . . . . . . . . . . . . . . 594
Debugging Exercises . . . . . . . . . . . . . . . . . . 599
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 599
Case Problems . . . . . . . . . . . . . . . . . . . . . 600

C H AP T E R 1 2 Exception Handling . . . . . . . . . . . . 603

Learning About Exceptions . . . . . . . . . . . . . . . . . 604
Trying Code and Catching Exceptions . . . . . . . . . . . . 609
Using a try Block to Make Programs “Foolproof” . . . . . . 614
Declaring and Initializing Variables in try…catch Blocks . . . 616
Throwing and Catching Multiple Exceptions . . . . . . . . . . 619
Using the finally Block . . . . . . . . . . . . . . . . . 625
Understanding the Advantages of Exception Handling . . . . . . 628
Specifying the Exceptions That a Method Can Throw . . . . . . 631
Tracing Exceptions Through the Call Stack . . . . . . . . . . 636
Creating Your Own Exception Classes . . . . . . . . . . . 641
Using Assertions . . . . . . . . . . . . . . . . . . . . . 645
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 661
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 661
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 663
Copyright 2013 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.
Review Questions . . . . . . . . . . . . . . . . . . . . . 664
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 667
Programming Exercises . . . . . . . . . . . . . . . . . 667
Debugging Exercises . . . . . . . . . . . . . . . . . . 672
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 672 xv
Case Problems . . . . . . . . . . . . . . . . . . . . . 672

C H AP T E R 1 3 File Input and Output . . . . . . . . . . . . 675

Understanding Computer Files . . . . . . . . . . . . . . . 676
Using the Path and Files Classes . . . . . . . . . . . . . 677
Creating a Path . . . . . . . . . . . . . . . . . . . . . 678
Retrieving Information About a Path . . . . . . . . . . . . 679
Converting a Relative Path to an Absolute One . . . . . . . . 680
Checking File Accessibility . . . . . . . . . . . . . . . . 681
Deleting a Path . . . . . . . . . . . . . . . . . . . . . 683
Determining File Attributes . . . . . . . . . . . . . . . . 684
File Organization, Streams, and Buffers . . . . . . . . . . . . 688
Using Java’s IO Classes . . . . . . . . . . . . . . . . . . 690
Writing to a File . . . . . . . . . . . . . . . . . . . . . 693
Reading from a File . . . . . . . . . . . . . . . . . . . 695
Creating and Using Sequential Data Files . . . . . . . . . . . 697
Learning About Random Access Files . . . . . . . . . . . . 703
Writing Records to a Random Access Data File . . . . . . . . 707
Reading Records from a Random Access Data File . . . . . . . 714
Accessing a Random Access File Sequentially . . . . . . . . 714
Accessing a Random Access File Randomly . . . . . . . . . 715
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 729
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 730
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 731
Review Questions . . . . . . . . . . . . . . . . . . . . . 732
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 735
Programming Exercises . . . . . . . . . . . . . . . . . 735
Debugging Exercises . . . . . . . . . . . . . . . . . . 737
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 738
Case Problems . . . . . . . . . . . . . . . . . . . . . 738

C H AP T E R 1 4 Introduction to Swing Components . . . . . 739

Understanding Swing Components . . . . . . . . . . . . . 740
Using the JFrame Class . . . . . . . . . . . . . . . . . . 741
Customizing a JFrame’s Appearance . . . . . . . . . . . 744
xvi Using the JLabel Class . . . . . . . . . . . . . . . . . . 748
Changing a JLabel’s Font . . . . . . . . . . . . . . . . 750
Using a Layout Manager . . . . . . . . . . . . . . . . . . 753
Extending the JFrame Class . . . . . . . . . . . . . . . . 756
Adding JTextFields, JButtons, and Tool Tips to a JFrame . . 758
Adding JTextFields . . . . . . . . . . . . . . . . . . 758
Adding JButtons . . . . . . . . . . . . . . . . . . . 760
Using Tool Tips . . . . . . . . . . . . . . . . . . . . . 762
Learning About Event-Driven Programming . . . . . . . . . . 765
Preparing Your Class to Accept Event Messages . . . . . . . 766
Telling Your Class to Expect Events to Happen . . . . . . . 767
Telling Your Class How to Respond to Events . . . . . . . . 767
Using the setEnabled() Method . . . . . . . . . . . . 770
Understanding Swing Event Listeners . . . . . . . . . . . . 774
Using the JCheckBox, ButtonGroup, and
JComboBox Classes . . . . . . . . . . . . . . . . . . 778
The JCheckBox Class . . . . . . . . . . . . . . . . . 778
The ButtonGroup Class . . . . . . . . . . . . . . . . 781
The JComboBox Class . . . . . . . . . . . . . . . . . 782
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 790
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 790
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 792
Review Questions . . . . . . . . . . . . . . . . . . . . . 793
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 796
Programming Exercises . . . . . . . . . . . . . . . . . 796
Debugging Exercises . . . . . . . . . . . . . . . . . . 798
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 798
Case Problems . . . . . . . . . . . . . . . . . . . . . 799

C H AP T E R 1 5 Advanced GUI Topics . . . . . . . . . . . . 801

Understanding the Content Pane . . . . . . . . . . . . . . 802
Using Color . . . . . . . . . . . . . . . . . . . . . . . 805
Learning More About Layout Managers . . . . . . . . . . . . 808
Using BorderLayout . . . . . . . . . . . . . . . . . 809
Copyright 2013 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.
Using FlowLayout . . . . . . . . . . . . . . . . . . . 811
Using GridLayout . . . . . . . . . . . . . . . . . . . 813
Using CardLayout . . . . . . . . . . . . . . . . . . . 815
Using Advanced Layout Managers . . . . . . . . . . . . . 817
Using the JPanel Class . . . . . . . . . . . . . . . . . . 826 xvii
Creating JScrollPanes . . . . . . . . . . . . . . . . . 834
A Closer Look at Events and Event Handling . . . . . . . . . . 837
An Event-Handling Example: KeyListener . . . . . . . . 840
Using AWTEvent Class Methods . . . . . . . . . . . . . . 843
Understanding x- and y-Coordinates . . . . . . . . . . . . 845
Handling Mouse Events . . . . . . . . . . . . . . . . . . 846
Using Menus . . . . . . . . . . . . . . . . . . . . . . . 851
Using JCheckBoxMenuItem and JRadioButtonMenuItem
Objects . . . . . . . . . . . . . . . . . . . . . . . 855
Using addSeparator() . . . . . . . . . . . . . . . . 857
Using setMnemonic() . . . . . . . . . . . . . . . . . 857
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 864
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 864
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 866
Review Questions . . . . . . . . . . . . . . . . . . . . . 867
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 870
Programming Exercises . . . . . . . . . . . . . . . . . 870
Debugging Exercises . . . . . . . . . . . . . . . . . . 871
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 872
Case Problems . . . . . . . . . . . . . . . . . . . . . 877

C H AP T E R 1 6 Graphics . . . . . . . . . . . . . . . . . 879
Learning About the paint() and repaint() Methods . . . . 880
Using the setLocation() Method . . . . . . . . . . . . 882
Creating Graphics Objects . . . . . . . . . . . . . . . 884
Using the drawString() Method . . . . . . . . . . . . . 885
Using the setFont() and setColor() Methods . . . . . 886
Using Color . . . . . . . . . . . . . . . . . . . . . . 887
Drawing Lines and Shapes . . . . . . . . . . . . . . . . . 893
Drawing Lines . . . . . . . . . . . . . . . . . . . . . 893
Drawing Rectangles . . . . . . . . . . . . . . . . . . . 894
Creating Shadowed Rectangles . . . . . . . . . . . . . . 897

Drawing Ovals . . . . . . . . . . . . . . . . . . . . . 898

Drawing Arcs . . . . . . . . . . . . . . . . . . . . . . 899
Creating Polygons . . . . . . . . . . . . . . . . . . . . 901
Copying an Area . . . . . . . . . . . . . . . . . . . . 903
xviii Using the paintComponent() Method with JPanels . . . 903
Learning More About Fonts . . . . . . . . . . . . . . . . . 909
Discovering Screen Statistics Using the Toolkit Class . . . 912
Discovering Font Statistics . . . . . . . . . . . . . . . . 912
Drawing with Java 2D Graphics . . . . . . . . . . . . . . . 920
Specifying the Rendering Attributes . . . . . . . . . . . . 920
Setting a Drawing Stroke . . . . . . . . . . . . . . . . . 922
Creating Objects to Draw . . . . . . . . . . . . . . . . . 923
Don’t Do It . . . . . . . . . . . . . . . . . . . . . . . . 930
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 931
Chapter Summary . . . . . . . . . . . . . . . . . . . . . 933
Review Questions . . . . . . . . . . . . . . . . . . . . . 933
Exercises . . . . . . . . . . . . . . . . . . . . . . . . 936
Programming Exercises . . . . . . . . . . . . . . . . . 936
Debugging Exercises . . . . . . . . . . . . . . . . . . 940
Game Zone . . . . . . . . . . . . . . . . . . . . . . . 940
Case Problems . . . . . . . . . . . . . . . . . . . . . 943

C H AP T E R 1 7 Applets, Images, and Sound . . . . . . . . 945

Introducing Applets . . . . . . . . . . . . . . . . . . . . 946
Understanding the JApplet Class . . . . . . . . . . . . 946
Running an Applet . . . . . . . . . . . . . . . . . . . . 947
Writing an HTML Document to Host an Applet . . . . . . . . . 948
Using the init() Method . . . . . . . . . . . . . . . . . 950
Working with JApplet Components . . . . . . . . . . . . . 955
Understanding the JApplet Life Cycle . . . . . . . . . . . 961
The init() Method . . . . . . . . . . . . . . . . . . 961
The start() Method . . . . . . . . . . . . . . . . . . 962
The stop() Method . . . . . . . . . . . . . . . . . . 962
The destroy() Method . . . . . . . . . . . . . . . . . 962
Understanding Multimedia and Using Images . . . . . . . . . 968
Adding Images to JApplets . . . . . . . . . . . . . . . 969
Using ImageIcons . . . . . . . . . . . . . . . . . . . 971

A PP E N D I X A Working with the Java Platform . . . . . . . 993

Configuring Windows to Work with the Java SE Development Kit . 994
Finding the Command Prompt . . . . . . . . . . . . . . . 995
Command Prompt Anatomy . . . . . . . . . . . . . . . . 995
Changing Directories . . . . . . . . . . . . . . . . . . 995
Setting the class and classpath Variables . . . . . . . 996
Changing a File’s Name . . . . . . . . . . . . . . . . . 997
Compiling and Executing a Java Program . . . . . . . . . . 997
Using Notepad to Save and Edit Source Code . . . . . . . . . 998
Using TextPad to Work with Java . . . . . . . . . . . . . . 998
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 999

A PP E N D I X B Learning About Data Representation . . . 1001

Understanding Numbering Systems . . . . . . . . . . . . . 1002
Representing Numeric Values . . . . . . . . . . . . . . . . 1004
Representing Character Values . . . . . . . . . . . . . . . 1006
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 1007

A PP E N D I X C Formatting Output . . . . . . . . . . . . 1009

Rounding Numbers . . . . . . . . . . . . . . . . . . . . 1010
Using the printf() Method . . . . . . . . . . . . . . . . 1011
Specifying a Number of Decimal Places to Display
with printf() . . . . . . . . . . . . . . . . . . . . 1015
Specifying a Field Size with printf() . . . . . . . . . . . 1015
Using the Optional Argument Index with printf() . . . . . 1016

Using the DecimalFormat Class . . . . . . . . . . . . . 1017

Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 1018

A PP E N D I X D Generating Random Numbers . . . . . . . 1021

xx Understanding Random Numbers Generated by Computers . . . 1022
Using the Math.random() Method . . . . . . . . . . . . . 1023
Using the Random Class . . . . . . . . . . . . . . . . . . 1024
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 1027

A PP E N D I X E Javadoc . . . . . . . . . . . . . . . . 1029
The Javadoc Documentation Generator . . . . . . . . . . . . 1030
Javadoc Comment Types . . . . . . . . . . . . . . . . . . 1030
Generating Javadoc Documentation . . . . . . . . . . . . . 1032
Specifying Visibility of Javadoc Documentation . . . . . . . . 1035
Key Terms . . . . . . . . . . . . . . . . . . . . . . . . 1036

Glossary . . . . . . . . . . . . . . . . 1037
Index . . . . . . . . . . . . . . . . . . 1063

Java Programming, Seventh 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. This book
provides a solid background in good object-oriented programming techniques and introduces
terminology using clear, familiar language. The writing is nontechnical and emphasizes good
programming practices. 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. The explanations in this
textbook are written clearly in straightforward sentences, making it easier for native and
non-native English speakers alike to master the programming concepts. 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, Seventh 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, Seventh 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
xxii
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.
Chapters 14 and 15 introduce GUI Swing components—Java’s visually pleasing, user-friendly
widgets—and their layout managers. Chapters 16 and 17 show you ways to provide
interactive excitement using graphics, applets, images, and sound.

Features
The following features are new for the Seventh Edition:
l 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. Previous editions of the book contained a long,
multipart “You Do It” section at the end of each chapter, but in this edition, more and
shorter sections follow important chapter topics so the student can focus on one new
concept at a time.
l 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.
l PROGRAMMING EXERCISES: Each chapter concludes with meaningful programming
exercises that provide additional practice of the skills and concepts learned in the chapter.
These exercises vary in difficulty and are designed to allow exploration of logical
programming concepts. Each chapter contains several new programming exercises not
seen in previous editions.
l INCREASED EMPHASIS ON STUDENT RESEARCH: In this edition, 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.
Additionally, Java Programming, Seventh Edition, includes the following features:
l 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.

l 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.
l FIGURES: Each chapter contains many figures. Code figures are most frequently 25 lines
or fewer, illustrating one concept at a time. Frequent screen shots show exactly how
xxiii
program output appears. Callouts appear where needed to emphasize a point.
l 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.
l 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.
l TWO TRUTHS AND 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.
l 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.
l 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.
l 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.
l REVIEW QUESTIONS: Each chapter includes 20 multiple-choice questions that serve as a
review of chapter topics.
l GAME ZONE: Each chapter provides one or more exercises in which students 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.
l GLOSSARY: A glossary contains definitions for all key terms in the book, presented in
alphabetical order.

l APPENDICES: This edition includes useful appendices on working with the Java platform,
data representation, formatting output, generating random numbers, and creating Javadoc
comments.
l 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) 7, the
xxiv
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:
l 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.
l 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.
l 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 login.cengage.com. An instructor login is required.
l Electronic Instructor’s Manual: The Instructor’s Manual that accompanies this
textbook includes 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

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.
l ExamView: This textbook is accompanied by ExamView, a powerful testing software
package that allows instructors to create and administer printed, computer (LAN-based),
xxv
and Internet-based exams. ExamView includes hundreds of questions that correspond to
the topics covered in this text, enabling students to generate detailed study guides that
include page references for further review. The computer-based and Internet testing
components allow students to take exams at their computers, and they save the instructor
time by grading each exam automatically. These test banks are also available in
Blackboard-compatible formats.
l 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.
l 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.

Acknowledgements
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 Product Manager; Sreejith Govindan,
Content Project Manager; and Chris Scriver and Serge Palladino, 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 Lee Cottrell, Bradford School, Pittsburgh; Irene Edge, Kent
State University; Susan Peterson, Henry Ford Community College; and Jackie Turner, Central
Georgia Technical College.
Thanks, too, to my husband, Geoff, for his constant support and encouragement. Finally, this
book is dedicated to Ruth LaFreniere, who brought us Stella, and Bob LaFreniere, who let her.
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:
l Software: Java SE 7, 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 7. 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, such as Internet Explorer.
l Hardware: If you are using Windows 7, the Java Web site suggests at least 128 MB
of memory and at least 98 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 excellent

job clarifying what my VIDEO LESSONS help
students have historically had explain important chapter
trouble with. concepts. Videos are part
—Lee Cottrell, Bradford of the text’s enhanced
School, Pittsburgh CourseMate site.

TWO TRUTHS & A LIE quizzes appear

after each chapter section, with
answers provided. The quiz contains
three statements based on the preceding
xxviii section of text—two statements are
true and one is false. Answers give
immediate feedback without “giving away”
answers to the multiple-choice questions
and programming problems later in
the chapter. Students also have the option
to take these quizzes electronically
through the enhanced CourseMate site.

DON'T DO IT sections at the end

of each chapter list advice for
avoiding common programming errors.

THE DON’T DO IT ICON illustrates

how NOT to do something—for
example, having a dead code
path in a program. This icon
provides a visual jolt to the student,

are NOT to be emulated and making

students more careful to recognize
problems in existing code.

REVIEW QUESTIONS test

student comprehension of the
major ideas and techniques
presented. Twenty questions
follow each chapter.

DEBUGGING EXERCISES are

xxx included with each chapter because
examining programs critically and
closely is a crucial programming skill.
Students can download these exercises
at www.CengageBrain.com and through
the CourseMate available for this text.
These files are also available to
instructors through login.cengage.com.

CASE PROBLEMS provide opportunities

to build more detailed programs that
continue to incorporate increasing
functionality throughout the book.

GAME ZONE EXERCISES are included

at the end of each chapter. Students can
create games as an additional entertaining
way to understand key programming
concepts.

In this chapter, you will:

Define basic programming terminology

Compare procedural and object-oriented programming
Describe the features of the Java programming language
Analyze a Java application that produces console output
Compile a Java class and correct syntax errors
Run a Java application and correct logical errors
Add comments to a Java class
Create a Java application that produces GUI output
Find help

Unless noted otherwise, all images are © 2014 Cengage Learning

Learning Programming Terminology

A computer program is a set of instructions that you write to tell a computer what to do.
Computer equipment, such as a monitor or keyboard, is hardware, and programs are
software. A program that performs a task for a user (such as calculating and producing
2 paychecks, word processing, or playing a game) is application software; a program that
manages the computer itself (such as Windows or Linux) is system software. The logic
behind any computer program, whether it is an application or system program, determines
the exact order of instructions needed to produce desired results. Much of this book describes
how to develop the logic to create application software.
All computer programs ultimately are converted to machine language. Machine language, or
machine code, is the most basic set of instructions that a computer can execute. Each type of
processor has its own set of machine language instructions. Programmers often describe
machine language using 1s and 0s to represent the on-and-off circuitry of computer systems.
Machine language is a low-level programming language, or one that corresponds closely to a
computer processor’s circuitry. Low-level languages require you to use memory addresses for
specific machines when you create commands. This means that low-level languages are
difficult to use and must be customized for every type of machine on which a program runs.
Fortunately, programming has evolved into an easier task because of the development of
high-level programming languages. A high-level programming language allows you to use a
vocabulary of reasonable terms, such as read, write, or add, instead of the sequences of 1s and
0s that perform these tasks. High-level languages also allow you to assign single-word,
intuitive names to areas of computer memory, such as hoursWorked or rateOfPay, rather
than having to remember the memory locations. Java is a high-level programming language.
Each high-level language has its own syntax, or rules of the language. For example, depending on
the specific high-level language, you might use the verb print or write to produce output. All
languages have a specific, limited vocabulary (the language’s keywords) and a specific set of rules
for using that vocabulary. When you are learning a computer programming language, such as Java,
C++, or Visual Basic, you really are learning the vocabulary and syntax rules for that language.
Using a programming language, programmers write a series of program statements, similar
to English sentences, to carry out the tasks they want the program to perform. Program
statements are also known as commands because they are orders to the computer, such as
“output this word” or “add these two numbers.”
After the program statements are written, high-level language programmers use a computer
program called a compiler or interpreter to translate their language statements into machine
language. A compiler translates an entire program before carrying out the statement, or
executing it, whereas an interpreter translates one program statement at a time, executing a
statement as soon as it is translated.

Whether you use a compiler or interpreter often depends on the programming language you use. For
example, C++ is a compiled language, and Visual Basic is an interpreted language. Each type of translator
has its supporters; programs written in compiled languages execute more quickly, whereas programs
written in interpreted languages are easier to develop and debug. Java uses the best of both technologies: a
compiler to translate your programming statements and an interpreter to read the compiled code line by line
when the program executes (also called at run time).
Copyright 2013 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.
Learning Programming Terminology

Compilers and interpreters issue one or more error messages each time they encounter an
invalid program statement—that is, a statement containing a syntax error, or misuse of the
language. Subsequently, the programmer can correct the error and attempt another
translation by compiling or interpreting the program again. Locating and repairing all syntax
errors is the first part of the process of debugging a program—freeing the program of all
errors. Figure 1-1 illustrates the steps a programmer takes while developing an executable 3
program. You will learn more about debugging Java programs later in this chapter.

Plan program logic

Write program language statements

that correspond to the logic

Debugging process
Use translating software (a compiler or
interpreter) that translates programming
language statements to machine language

Debugging process
Can all statements No Examine list of
be successfully
syntax errors
translated?

Yes

Execute the program

Examine
program output

Are there runtime Yes

errors or errors
in the output?

Figure 1-1 The program development process

As Figure 1-1 shows, you might be able to use a computer language’s syntax correctly but still
have errors to correct. In addition to learning the correct syntax for a particular language,
a programmer must also understand computer programming logic. When you develop
a program of any significant size, you should plan its logic before you write any program
statements. Correct logic requires that all the right commands be issued in the appropriate
4 order. Examples of logical errors include multiplying two values when you meant to divide
them or producing output prior to obtaining the appropriate input.
Correcting logical errors is the second part of the debugging process and is much more
difficult than correcting syntax errors. Syntax errors are discovered when you compile a
program, but often you can identify logical errors only when you examine a program’s first
output. For example, if you know an employee’s paycheck should contain the value $5,000,
but you see that it holds $50 or $50,000 after you execute a payroll program, a logical error
has occurred. Tools that help you visualize and understand logic are presented in the chapter
Making Decisions.

Programmers call some logical errors semantic errors. For example, if you misspell a programming-
language word, you commit a syntax error, but if you use a correct word in the wrong context, you commit
a semantic error.

TWO TRUTHS & A LIE

Learning Programming Terminology

In each “Two Truths & a Lie” section, two of the numbered statements are true, and one
is false. Identify the false statement and explain why it is false.

1. Unlike a low-level programming language, a high-level programming language

allows you to use a vocabulary of reasonable terms instead of the sequences of on
and off switches that perform the corresponding tasks.
2. A compiler executes each program statement as soon as it is translated, whereas
an interpreter translates all of a program’s statements before executing any.
3. A syntax error occurs when you misuse a language; locating and repairing all
syntax errors is part of the process of debugging a program.

at a time, executing a statement as soon as it is translated.

out any statements, whereas an interpreter translates one program statement
The false statement is #2. A compiler translates an entire program before carrying

Comparing Procedural and Object-Oriented

Programming Concepts
Two popular approaches to writing computer programs are procedural programming and
object-oriented programming.
5

Procedural Programming
Procedural programming is a style of programming in which operations are executed one
after another in sequence. In procedural applications, you create names for computer
memory locations that can hold values—for example, numbers and text—in electronic form.
The named computer memory locations are called variables because they hold values that
might vary. For example, a payroll program written for a company might contain a variable
named rateOfPay. The memory location referenced by the name rateOfPay might contain
different values (a different value for every employee of the company) at different times.
During the execution of the payroll program, each value stored under the name rateOfPay
might have many operations performed on it—the value might be read from an input device,
the value might be multiplied by another variable representing hours worked, and the
value might be printed on paper. For convenience, the individual operations used in
a computer program are often grouped into logical units called procedures. For
example, a series of four or five comparisons and calculations that together determine
a person’s federal withholding tax value might be grouped as a procedure named
calculateFederalWithholding. A procedural program defines the variable memory
locations and then calls a series of procedures to input, manipulate, and output the values
stored in those locations. When a program calls a procedure, the current logic is temporarily
abandoned so that the procedure’s commands can execute. A single procedural program
often contains hundreds of variables and procedure calls. Procedures are also called modules,
methods, functions, and subroutines. Users of different programming languages tend to use
different terms. As you will learn later in this chapter, Java programmers most frequently
use the term method.

Object-Oriented Programming
Object-oriented programming is an extension of procedural programming in which you take
a slightly different approach to writing computer programs. Writing object-oriented
programs involves creating classes, which are blueprints for objects; creating objects from
those classes; and creating applications that use those objects. After creation, classes can be
reused repeatedly to develop new programs. Thinking in an object-oriented manner involves
envisioning program components as objects that belong to classes and that are similar to
concrete objects in the real world; then, you can manipulate the objects and have them
interrelate with each other to achieve a desired result.

Programmers use OO as an abbreviation for object-oriented; it is pronounced “oh oh.” Object-oriented

programming is abbreviated OOP, and pronounced to rhyme with soup.

Originally, object-oriented programming was used most frequently for two major types of
applications:
l Computer simulations, which attempt to mimic real-world activities so that their
processes can be improved or so that users can better understand how the real-world
processes operate
6
l Graphical user interfaces, or GUIs (pronounced “gooeys”), which allow users to interact
with a program in a graphical environment
Thinking about objects in these two types of applications makes sense. For example, a city
might want to develop a program that simulates traffic patterns to help prevent traffic tie-ups.
By creating a model with objects such as cars and pedestrians that contain their own data and
rules for behavior, the simulation can be set in motion. For example, each car object has a
specific current speed and a procedure for changing that speed. By creating a model of city
traffic using objects, a computer can create a simulation of a real city at rush hour.
Creating a GUI environment for users also is a natural use for object orientation. It is easy to
think of the components a user manipulates on a computer screen, such as buttons and scroll
bars, as similar to real-world objects. Each GUI object contains data—for example, a button
on a screen has a specific size and color. Each object also contains behaviors—for example,
each button can be clicked and reacts in a specific way when clicked. Some people consider
the term object-oriented programming to be synonymous with GUI programming, but object-
oriented programming means more. Although many GUI programs are object oriented, do
not assume that all object-oriented programs use GUI objects. Modern businesses use object-
oriented design techniques when developing all sorts of business applications, whether they
are GUI applications or not.
Understanding object-oriented programming requires grasping three basic concepts:
l Encapsulation as it applies to classes as objects
l Inheritance
l Polymorphism

Understanding Classes, Objects, and Encapsulation

In object-oriented terminology, a class is a term that describes a group or collection of
objects with common properties. In the same way that a blueprint exists before any houses
are built from it, and a recipe exists before any cookies are baked from it, so does a class
definition exist before any objects are created from it. A class definition describes what
attributes its objects will have and what those objects will be able to do. Attributes are the
characteristics that define an object; they are properties of the object. When you learn a
programming language such as Java, you learn to work with two types of classes: those that have
already been developed by the language’s creators and your own new, customized classes.
An object is a specific, concrete instance of a class. When you create an object, you
instantiate it. You can create objects from classes that you write and from classes written by
other programmers, including Java’s creators. The values contained in an object’s properties
Copyright 2013 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.
Comparing Procedural and Object-Oriented Programming Concepts

often differentiate instances of the same class from one another. For example, the class
Automobile describes what Automobile objects are like. Some properties of the Automobile
class are make, model, year, and color. Each Automobile object possesses the same attributes
but not, of course, the same values for those attributes. One Automobile might be a 2009
white Ford Taurus and another might be a 2014 red Chevrolet Camaro. Similarly, your dog
has the properties of all Dogs, including a breed, name, age, and whether his shots are current. 7
The values of the properties of an object are also referred to as the object’s state. In other
words, you can think of objects as roughly equivalent to nouns, and of their attributes as
similar to adjectives that describe the nouns.
When you understand an object’s class, you understand the characteristics of the object.
If your friend purchases an Automobile, you know it has a model name, and if your friend gets
a Dog, you know the dog has a breed. Knowing what attributes exist for classes allows you
to ask appropriate questions about the states or values of those attributes. For example,
you might ask how many miles the car gets per gallon, but you would not ask whether the
car has had shots. Similarly, in a GUI operating environment, you expect each component
to have specific, consistent attributes and methods, such as a window having a title bar and
a close button, because each component gains these properties as a member of the general
class of GUI components. Figure 1-2 shows the relationship of some Dog objects to the
Dog class.

By convention, programmers using Java begin their class names with an uppercase letter. Thus, the class
that defines the attributes and methods of an automobile would probably be named Automobile, and
the class for dogs would probably be named Dog. However, following this convention is not required to
produce a workable program.

Dog class definition Dog class instances (objects)

Every Dog that is

created will have
a:

Name

Age
Ginger Bowser Roxy
Breed 6 2 1
Akita Retriever Beagle
Shot status Up to date Up to date Up to date

Figure 1-2 A class definition and some objects created from it

Besides defining properties, classes define methods their objects can use. A method is a self-
contained block of program code that carries out some action, similar to a procedure in a
procedural program. An Automobile, for example, might have methods for moving forward,
moving backward, being filled with gasoline, and being washed. Some methods can ascertain
certain attributes, such as the current speed of an Automobile and the status of its gas tank.
8 Similarly, a Dog can walk or run, eat food, and get a bath, and there are methods to determine
how hungry the Dog is or what its name is. GUI operating system components can be
maximized, minimized, and dragged. In other words, if objects are similar to nouns, then
methods are similar to verbs.
In object-oriented classes, attributes and methods are encapsulated into objects that are then
used much like real-world objects. Encapsulation refers to two closely related object-oriented
notions:
l Encapsulation is the enclosure of data and methods within an object. Encapsulation allows
you to treat all of an object’s methods and data as a single entity. Just as an actual dog
contains all of its attributes and abilities, so would a program’s Dog object.
l Encapsulation also refers to the concealment of an object’s data and methods from outside
sources. Concealing data is sometimes called information hiding, and concealing how
methods work is implementation hiding; you will learn more about both terms in the
chapter Using Methods, Classes, and Objects. Encapsulation lets you hide specific object
attributes and methods from outside sources and provides the security that keeps data and
methods safe from inadvertent changes.
If an object’s methods are well written, the user is unaware of the low-level details of how the
methods are executed, and the user must simply understand the interface or interaction
between the method and the object. For example, if you can fill your Automobile with
gasoline, it is because you understand the interface between the gas pump nozzle and the
vehicle’s gas tank opening. You don’t need to understand how the pump works mechanically
or where the gas tank is located inside your vehicle. If you can read your speedometer, it does
not matter how the displayed figure is calculated. As a matter of fact, if someone produces a
superior, more accurate speed-determining device and inserts it in your Automobile, you
don’t have to know or care how it operates, as long as your interface remains the same. The
same principles apply to well-constructed classes used in object-oriented programs—
programs that use classes only need to work with interfaces.

Understanding Inheritance and Polymorphism

An important feature of object-oriented program design is inheritance—the ability to create
classes that share the attributes and methods of existing classes but with more specific
features. For example, Automobile is a class, and all Automobile objects share many traits and
abilities. Convertible is a class that inherits from the Automobile class; a Convertible is a
type of Automobile that has and can do everything a “plain” Automobile does—but with an
added mechanism for and an added ability to lower its top. (In turn, Automobile inherits from
the Vehicle class.) Convertible is not an object—it is a class. A specific Convertible is an
object—for example, my1967BlueMustangConvertible.
Copyright 2013 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.
Comparing Procedural and Object-Oriented Programming Concepts

Inheritance helps you understand real-world objects. For example, the first time you
encounter a Convertible, you already understand how the ignition, brakes, door locks, and
other Automobile systems work. You need to be concerned only with the attributes and
methods that are “new” with a Convertible. The advantages in programming are the same—
you can build new classes based on existing classes and concentrate on the specialized
features you are adding. 9

A final important concept in object-oriented terminology is polymorphism. Literally,

polymorphism means “many forms”—it describes the feature of languages that allows the
same word or symbol to be interpreted correctly in different situations based on the
context. For example, although the classes Automobile, Sailboat, and Airplane all inherit
from Vehicle, turn and stop methods work differently for instances of those classes.
The advantages of polymorphism will become more apparent when you begin to create
GUI applications containing features such as windows, buttons, and menu bars. In a GUI
application, it is convenient to remember one method name, such as setColor or setHeight
and have it work correctly no matter what type of object you are modifying.
When you see a plus sign ( + ) between two numbers, you understand they are being
added. When you see it carved in a tree between two names, you understand that the
names are linked romantically. Because the symbol has diverse meanings based on context,
it is polymorphic. Chapters 10 and 11 provide more information about inheritance and
polymorphism and how they are implemented in Java.

Watch the video Object-Oriented Programming.

TWO TRUTHS & A LIE

Comparing Procedural and Object-Oriented
Programming Concepts

1. An instance of a class is a created object that possesses the attributes and

methods described in the class definition.
2. Encapsulation protects data by hiding it within an object.
3. Polymorphism is the ability to create classes that share the attributes and methods
of existing classes, but with more specific features.

polymorphism describes the ability to use one term to cause multiple actions.
attributes and methods of existing classes but with more specific features;
The false statement is #3. Inheritance is the ability to create classes that share the

Features of the Java Programming Language

Java was developed by Sun Microsystems as an object-oriented language for general-purpose
business applications and for interactive, World Wide Web–based Internet applications.
Some of the advantages that have made Java so popular in recent years are its security features
10 and the fact that it is architecturally neutral: Unlike other languages, you can use Java to write
a program that runs on any operating system (such as Windows, Mac OS, or Linux) or device
(such as PCs, phones, and tablet computers).
Java can be run on a wide variety of computers and devices because it does not execute
instructions on a computer directly. Instead, Java runs on a hypothetical computer known as
the Java Virtual Machine (JVM). When programmers call the JVM hypothetical, they don’t
mean it doesn’t exist. Instead, they mean it is not a physical entity created from hardware but
is composed only of software.
Figure 1-3 shows the Java environment. Programming statements written in a high-level
programming language are source code. When you write a Java program, you first
construct the source code using a text editor such as Notepad or a development
environment and source code editor such as jGRASP, which you can download from the
Web for free. A development environment is a set of tools that help you write programs
by providing such features as displaying a language’s keywords in color. The statements are
saved in a file; then, the Java compiler converts the source code into a binary program
of bytecode. A program called the Java interpreter then checks the bytecode and
communicates with the operating system, executing the bytecode instructions line by line
within the Java Virtual Machine. Because the Java program is isolated from the operating
system, the Java program also is insulated from the particular hardware on which it is run.
Because of this insulation, the JVM provides security against intruders accessing your
computer’s hardware through the operating system. Therefore, Java is more secure
than other languages. Another advantage provided by the JVM means less work for
programmers—when using other programming languages, software vendors usually have
to produce multiple versions of the same product (a Windows version, Macintosh version,
UNIX version, Linux version, and so on) so all users can run the program. With Java, one
program version runs on all these platforms. “Write once, run anywhere” (WORA) is a slogan
developed by Sun Microsystems to describe the ability of one Java program version to work
correctly on multiple platforms.

Java Source Code

Source code is
stored on a disk in
a file with a name 11
ending in .java

Java Compiler

Compiler creates
bytecode that
is stored on a
disk in a file with
a name ending in
Java Virtual Machine .class

Java Interpreter

JVM (named java.exe)

performs security checks
and translates bytecode to
machine language, which
Computer Operating
executes
System

Figure 1-3 The Java environment

Java also is simpler to use than many other object-oriented languages. Java is modeled after
C++. Although neither language is easy to read or understand on first exposure, Java does
eliminate some of the most difficult-to-understand features in C++, such as pointers and
multiple inheritance.

Java Program Types

You can write two kinds of programs using Java:
l Applets are programs that are embedded in a Web page. You will create applets in the
chapter Applets, Images, and Sound.
l Java applications are stand-alone programs. Java applications can be further
subdivided into console applications, which support character output to a computer
screen in a DOS window, for example, and windowed applications, which create a GUI

Copyright 2013 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.
Exploring the Variety of Random
Documents with Different Content
deux volumes de contes chrétiens d'Égypte. Les histoires populaires
qui servaient à Aristophane se retrouvent encore partiellement dans
les vies des saints russes.
Si on examine à ce point de vue la légende de Julien, on y reconnaît
aussitôt les caractères déterminants d'un conte populaire. Le thème
général est l'histoire d'un homme qui accomplit par destinée un
meurtre involontaire, et dans ce thème général sont compris trois
thèmes épisodiques: un oracle est prononcé par un animal; le héros
est condamné, en expiation de son crime, à devenir passeur sur une
rivière; un ange vient éprouver sa charité sous la forme d'un pauvre
ou d'un lépreux.
On sait que l'idée générale d'un conte populaire est exprimée par
différents thèmes épisodiques qui varient et se combinent
diversement suivant les temps, les nations ou les provinces.
Or, parmi les contes populaires que nous connaissons, aucun ne
reproduit la combinaison de thèmes qui se trouve dans l'histoire de
Julien. Mais il arrive souvent qu'un conte emprunte des thèmes à un
conte qui appartient à un autre cycle. M. Cosquin en a donné des
exemples dans sa belle étude du folklore de Lorraine.
Il suffira donc de comparer les épisodes de l'histoire de Julien à
d'autres épisodes recueillis parmi les cycles du folklore pour s'assurer
de l'origine populaire de cette admirable légende. Peut-être trouvera-
t-on plus tard dans la littérature orale une construction où les
épisodes du conte seront disposés dans le même ordre. Et comme
l'histoire de Julien devait être fort ancienne déjà, puisque son origine
était oubliée lorsqu'elle entra, au XIIIe siècle, dans le Speculum
historiale, on peut imaginer qu'elle représente pour nous un type
archaïque dont les éléments ont été plus tard démembrés. Elle
faisait sans doute partie d'un cycle d'autres contes analogues.
Enclavée dans la littérature religieuse, c'est l'unique variante qui
nous reste.
Le thème général du conte est absolument identique aux thèmes de
l'histoire d'Œdipe, du prince Agib, du troisième calandar des Mille et
une Nuits, et de la Belle au Bois dormant. Œdipe est contraint par
un oracle à tuer son père Laïos; on l'expose; on l'écarte du pays;
malgré toutes les précautions, il accomplit la prédiction à son insu.
Les astrologues ont annoncé au père d'un jeune homme que son fils
serait assassiné à l'âge de quinze ans par le prince Agib. Le vieillard
fait enfermer son enfant dans un souterrain, au milieu d'une île. Agib
aborde dans l'île, découvre la cachette, devient l'ami du jeune
homme; et, à l'heure assignée, le cinquantième jour, au moment où
il va prendre un couteau pour découper un melon au sucre, son pied
glisse, et il frappe l'enfant au cœur. Enfin, dans le conte de Perrault,
une fée prédit que la petite princesse se percera la main d'un
fuseau, et qu'il y aura de cruelles conséquences. Le roi interdit de
filer dans son royaume. Pourtant, la belle trouve une vieille femme
au rouet, dans un donjon, joue avec le fuseau, se blesse, et l'oracle
s'accomplit fatalement. C'est la forme affaiblie du même thème de
folklore: et on se souvient que la première fée annonce que la belle
mourra de sa blessure.
Dans l'histoire de Julien, l'oracle est prononcé par un animal et c'est
la caractéristique du premier épisode. Ici les rapprochements
seraient innombrables et oiseux. C'est l'inverse du thème que les
folkloristes ont coutume d'appeler le «thème des animaux
reconnaissants». Nous sentons bien que l'histoire de Julien est
mutilée à cet endroit, sous sa forme primitive. On ne nous dit point
que Julien commit une mauvaise action en allant à la chasse. Au
contraire, le texte sacré explique: cum Julianus quâdam die venationi
insisteret, ut juvenis et nobilis. Le cerf ne se plaint pas. Il se
retourne simplement, et dit: Tu me sequeris, qui patris et matris
tuae occisor eris?
Il faut donc supposer—puisque la cruauté de Julien ne saurait être
mise en cause—que dans le type archaïque du conte le cerf était un
homme métamorphosé. Car telle est l'apparence de tous les
animaux qui font de semblables prédictions dans les contes
populaires. Et on trouve là probablement l'influence d'une tradition
indoue et de nombreux apologues religieux qui illustrent la doctrine
de la métempsychose.
Après l'oracle, Julien se cache et s'enfuit, pour échapper au destin.
C'est l'épisode des précautions, qu'on retrouve avec des variantes
dans les contes grec, arabe et français.
L'oracle s'accomplit et Julien devient, par pénitence, passeur sur une
rivière. Nous reconnaissons là un épisode que nous retrouvons non
seulement dans la légende de saint Christophe, mais encore dans un
conte recueilli par les frères Grimm, le Diable aux trois cheveux d'or.
Le héros du conte trouve sur son chemin une grosse rivière qu'il lui
faut traverser. Le passeur lui explique qu'il est contraint de mener
incessamment sa barque de l'un à l'autre bord et le supplie de
vouloir bien le délivrer. Le héros fait interroger à ce sujet le diable.
La réponse, c'est qu'il suffira au passeur de placer sa gaffe dans la
main de son premier passager: alors il sera libre, et l'autre sera
damné à son tour. Grâce aux péripéties du conte, le premier
passager se trouve être un méchant roi. Le passeur fait ainsi qu'on
lui a dit; et «désormais, dit le conte, le roi est passeur sur la rivière
en punition de ses péchés».
Quant à la légende de saint Christophe, elle est formée d'éléments si
semblables à ceux dont fut composée celle de Julien qu'il faut citer
toute la partie commune. Voici l'admirable traduction de frère Jehan
du Vignay, publiée en 1554.

«L'hermite dit à Christofle:

—Sçais-tu tel fleuve?
Et Christofle lui dist:
—Moult de gens y passent qui y périssent.
Et l'hermite lui dist:
—Tu es de noble stature et fort vertueux; se tu demouroys delez ce
fleuve et passoys tous les gens, ce seroit moult aggreable chose à
Dieu. Et i'ay esperance à celluy que tu convoites servir qu'il
s'apparoistra à toy.
Et Christofle luy dit:
—Certes ce service puis-ie bien faire, et si te promets que ie le feray.
Adonc s'en alla Christofle à ce fleuve et feit là un habitacle pour luy;
et portoit une grande perche en lieu de baston et s'apuyoit en l'eaue
d'icelle, et portoit oultre toutes gens sans cesser et là fut plusieurs
iours.
Et si comme il se dormoit en sa maisonnette, il ouït la voix d'un
enfant qui l'appelloit et disoit:
—Christofle, viens hors, et me porte oultre.
Et lors s'esveilla, et il yssit hors, mais ne trouva âme. Et quant il fut
en la maison, il ouyt arriere une mesme voix et courut hors et ne
trouva nul. Tiercement il fut appelé et vint là; si trouva un enfant
delez la rive du fleuve qui luy pria doulcement qu'il le portast outre
l'eaue. Et lors Christofle leva l'enfant sur ses espaules et print son
baston et entra au fleuve pour le passer oultre; et l'eaue s'enfla petit
à petit, et l'enfant pesoit griefvement comme plomb. Et tant comme
il alloit plus avant, de tant croissoit plus l'eaue et l'enfant pesoit de
plus en plus sur ses espaules, si que Christofle avoit moult grans
angoisses, et se doubtoit fort de noyer. Et quant il fut eschappé à
grand'peine et il fut passé oultre, il mit l'enfant sur la rive et lui dist:
—Enfant, tu m'as mis en grant péril et pesois tant que si i'eusse eu
tout le monde sur moy, ie ne sentisse à peine greigneur faix.
Et l'enfant respondit:
—Christofle, ne te esmerveille pas: car tu n'as pas seulement eu tout
le monde sur toy—mais celluy qui créa tout le monde tu as porté sur
tes espaules. Je suis Christ ton roy à qui tu sers en ceste œuvre. Et
affin que tu saches que ie dis vray, quand tu seras passé, fische ton
baston en terre delez la maisonnette, et tu verras demain qu'il
portera fleur et fruictz.
Et tantost il se esvanouit de ses yeulx.
Lors Christofle alla et fischa son baston en terre, et quand il se leva
au matin, il le trouva ainsi comme un palmier, portant fueilles et
fruict.»

C'est là essentiellement la même combinaison thématique que dans

la seconde partie de l'histoire de Julien. Mais l'épisode du passeur y
est joint à l'épisode de l'inconnu qui se trouve être un ange ou le
Seigneur. Dans les Contes populaires de la Gascogne, l'épisode du
pauvre ressemble vivement à la variante de l'histoire de Julien[8].
[8] J.-F. Bladé, Contes pop. de la Gascogne, I, 6.
C'est un fils de roi qui cherche l'épée de saint Pierre.
«A minuit il s'arrête tout proche d'une rivière. Au bord de l'eau
grelottait un vieux pauvre à barbe grise.
—Bonsoir, pauvre. Mauvais temps pour voyager. Tu grelottes. Tiens:
bois un coup à ma gourde, cela te réchauffera.
Le vieux pauvre but un coup à la gourde, et ne grelotta plus.
—Merci, mon ami. Maintenant porte-moi de l'autre côté de l'eau.
—Avec plaisir, pauvre. Monte sur mon dos et tiens-toi ferme. Jésus!
tu ne pèses pas plus qu'une plume.
—Patience, je pèserai davantage au milieu de l'eau.
—C'est vrai. Jésus! tu m'écrases!
—Patience, sur l'autre bord je ne pèserai pas plus qu'une plume.
—C'est vrai. Tiens, pauvre, te voilà passé. Bois encore un coup à ma
gourde et que le bon Dieu te conduise!
—Jeune homme, je ne suis pas un pauvre, je suis saint Pierre. Jeune
homme, tu m'as fait un grand service. Je te paierai selon mon
pouvoir...»
Dans un autre conte de la même collection[9], la belle Madeleine
rencontre trois vieux pauvres au bord d'une rivière, elle les passe sur
son dos. Puis les trois vieux pauvres se trouvent être saint Jean,
saint Pierre et le bon Dieu. Ils promettent à la belle Madeleine de
récompenser sa charité.
[9] J.-F. Bladé, Contes pop. de la Gascogne, II, III, 3.
Malheureusement, pour ces deux derniers exemples, nous nous
trouvons dans une grande incertitude. Il est impossible d'assurer que
les deux contes de Gascogne n'ont pas été influencés par
l'hagiographie. C'est peut-être là tout simplement une variante de la
légende de saint Christophe redevenue populaire. Il ne faut pas
omettre de remarquer pourtant que saint Christophe lui-même n'a
d'existence qu'en vertu de cet épisode de sa légende, puisque son
nom est Χριστόφορος—celui qui porte le Christ. C'est là une forte
présomption pour croire que ce personnage a été véritablement créé
dans le domaine du folklore.
Et l'histoire de Julien n'a sans doute point d'autre origine. Gustave
Flaubert, qui en fit un conte si riche, la recueillit à peine
entr'ouverte, comme une timide fleur du peuple. C'est une églantine
sauvage près de la somptueuse chair de velours d'une rose cultivée.
Il faut se pencher très bas pour ne pas perdre son parfum. Elle
naquit parmi d'autres contes qui ne sont pas chrétiens, où les bêtes
et les prêtres prononcent des oracles, où les fils de rois sont
enfermés dans des tours solitaires pour échapper aux prédictions, où
les héros criminels sont condamnés à passer éternellement les
voyageurs sur des rivières tumultueuses, où les pauvres et les
lépreux sont reconnaissants et divins. Elle est si lointaine et si
humble que tout y est incertain.

III
«Et voilà l'histoire de saint Julien l'Hospitalier, dit Gustave Flaubert,
telle à peu près qu'on la trouve sur un vitrail d'église dans mon
pays.»
C'est un vitrail de la cathédrale de Rouen, et M. Langlois en a publié
un dessin dans ses collections. Lorsque Flaubert donna la Légende
de saint Julien à son éditeur, il lui écrivit pour lui demander de
reproduire à la fin du livre la pieuse composition normande. Mais il
avait peu d'estime pour le vitrail de Rouen. Il voulait faire admirer au
lecteur l'extraordinaire différence qu'on trouve entre le conte orné
splendidement et la naïve image provinciale. L'éditeur ne put réaliser
le désir de Flaubert. Aujourd'hui encore nous avons peine à imaginer
la miraculeuse transformation d'art et de style qui habilla de pourpre
et d'or ces simples figures, qui suspendit à des parois de palais les
sanglantes tapisseries de chasses et de batailles, qui fit d'un lépreux
aux lèvres bleuâtres un saint aux yeux d'étoiles dont les narines
soufflaient l'odeur de la rose.

Il faut lire le conte de Julien dans la Légende dorée pour apprécier le

génie de transformation de Gustave Flaubert.
Julien, dans le récit du folklore, n'a aucun caractère personnel. C'est
un homme soumis au destin, et qui n'est point coupable. Il
n'éprouve pas l'impérieux besoin de solitude de ceux qui ont l'âme
criminelle. Voilà pourquoi il accepte de partager la pénitence avec sa
femme «sa très douce sœur» qui ne l'abandonne pas et qui meurt
saintement avec lui. Julien, dans le conte de Flaubert, se présente
devant sa femme après le meurtre: «Et d'une voix différente de la
sienne il lui commanda premièrement de ne pas lui répondre, de ne
pas l'approcher, de ne plus même le regarder.» Seul il subit un
châtiment qui n'est pas immérité.
Car Julien, ainsi que l'a conçu Flaubert, a la passion voluptueuse du
sang. Elle le saisit tout jeune. Il commence par le meurtre d'une
souris pendant la messe. «Chaque dimanche il l'attendait, en était
importuné, fut pris de haine contre elle, et résolut de s'en défaire.»
Il l'épie une baguette à la main. «Il frappa un coup léger et demeura
stupéfait devant ce petit corps qui ne bougeait plus.»
Un peu plus tard, Julien tue un pigeon à coups de pierres. «Le
pigeon, les ailes cassées, palpitait, suspendu aux branches d'un
troène. La persistance de la vie irrita l'enfant. Il se mit à l'étrangler,
et les convulsions de l'oiseau faisaient battre son cœur,
l'emplissaient d'une joie tumultueuse et sauvage. Au dernier
raidissement, il se sentit défaillir.»
Dès lors l'amour de tuer s'élève en lui. Il a une sorte de foi
destructrice. Il touche véritablement au mystère sacré qui fera de lui
un saint; car la destruction et la création ne sont-elles point sœurs?
Hanté par les spectres de ses victimes, il ira jusqu'au meurtre le plus
affreux. C'est un assassinat involontaire. Et cependant il y a une
seconde où il se dit: «Si je le voulais pourtant!—Et il avait peur que
le diable ne lui en inspirât l'envie.»
L'oracle du cerf devient ici une punition prononcée avec une autorité
terrible:
«Le prodigieux animal s'arrêta; et les yeux flamboyants, solennel
comme un patriarche et comme un justicier, pendant qu'une cloche
au loin tintait, il répéta trois fois:
«Maudit! maudit! maudit! Un jour, cœur féroce, tu assassineras ton
père et ta mère!»
Le conte de Flaubert est plein d'apparitions. Les pauvres victimes
muettes viennent reprocher à Julien sa voluptueuse cruauté. On
croirait que Flaubert est allé puiser aux sources mêmes de la
légende l'horreur sacrée du meurtre des animaux.

De même que l'âme de Julien a été faite humaine, le décor du conte

s'est précisé. Julien vit en fils de seigneur dans un château à quatre
tours avec des toits pointus recouverts d'écailles de plomb. Son père
est «toujours enveloppé d'une pelisse de renard»; quant à sa mère,
«les cornes de son hennin frôlaient le linteau des portes». Nous
sommes à une époque imprécise, mais entre le Xe et le XVe siècle.
Le Prince de la légende devient «empereur d'Occitanie». La
Châtelaine a de grands yeux noirs qui «brillaient comme deux
lampes très douces. Un sourire charmant écartait ses lèvres. Les
anneaux de sa chevelure s'accrochaient aux pierreries de sa robe
entr'ouverte, et sous la transparence de sa tunique on devinait la
jeunesse du corps». Le Château qu'elle apporte en dot à Julien
«était un palais de marbre blanc, bâti à la moresque, sur un
promontoire, dans un bois d'orangers... Les chambres, pleines de
crépuscule, se trouvaient éclairées par les incrustations des
murailles. De hautes colonnettes minces comme des roseaux
supportaient la voûte des coupoles, décorées de reliefs imitant les
stalactites des grottes. Il y avait des jets d'eau dans les salles, des
mosaïques dans les cours, des cloisons festonnées, mille délicatesses
d'architecture, et partout un tel silence que l'on entendait le
frôlement d'une écharpe ou l'écho d'un soupir». Flaubert nous décrit
tous les chiens de la meute de Julien, les bêtes qu'il chassait, la
manière dont il «volait le héron, le milan, la corneille et le vautour».
Au lieu que saint Antonin nous dit qu'il «se conduit avec vaillance à
la guerre», nous apprenons ici qu'il combat «les templiers de
Jérusalem, le suréna des Parthes, le négud d'Abyssinie et l'empereur
de Calicut, les Scandinaves, des Nègres, des Indiens, des
Troglodytes», et que «c'est lui, et pas un autre, qui assomma la
guivre de Milan et le dragon d'Oberbirbach».
A l'aide de ces moyens, Flaubert nous transporte parmi le luxe
fabuleux du monde de la chevalerie. Cependant il n'oublie jamais
que l'histoire de Julien est un conte populaire. Il y a introduit des
épisodes empruntés à des contes semblables.
L'aventure qui arrive à Julien avec une épée sarrasine est toute
pareille à celle du prince Agib, qui fait tomber un couteau pointu
d'une haute étagère.
«Son père, le voulant réjouir, lui fit cadeau d'une grande épée
sarrasine.
«Elle était au haut d'un pilier, dans une panoplie. Pour l'atteindre, il
fallut une échelle. Julien y monta. L'épée trop lourde lui échappa des
doigts, et en tombant frôla le bon seigneur de si près que sa
houppelande en fut coupée. Julien crut avoir tué son père, et
s'évanouit.»
De même que les pauvres des Contes de Gascogne, le Lépreux a
une extraordinaire lourdeur:
«Dès qu'il entra dans la barque, elle enfonça prodigieusement,
écrasée par son poids; une secousse la remonta, et Julien se mit à
ramer.»
La gradation des demandes du misérable est triple, ainsi que dans le
folklore: J'ai faim, j'ai soif, j'ai froid! Et il y a comme un vague
souvenir de la cruauté du Loup dans le Petit Chaperon rouge, sous
l'insistance du Lépreux: «Viens près de moi... Déshabille-toi...
Réchauffe-moi; pas avec tes mains—non—toute ta personne.»

Ainsi Gustave Flaubert a réussi à fondre et à unir dans un miraculeux

émail littéraire tout l'appareil de la chevalerie avec le plus simple des
contes pieux du peuple. Et parmi cette éblouissante fusion, nous
voyons se dessiner les attitudes d'un Julien cruellement passionné,
dont l'âme est tout près de la nôtre. C'est ainsi que les nobles poètes
de l'âge d'Élisabeth créaient avec les ballades des pauvres gens de la
campagne les héros que nous admirons dans leurs drames. Une des
gloires de Flaubert sera d'avoir senti si vivement que la grande force
de création vient de l'imagination obscure des peuples et que les
chefs-d'œuvre naissent de la collaboration d'un génie avec une
descendance d'anonymes.
LA TERREUR ET LA PITIÉ
LA TERREUR ET LA PITIÉ
I
La vie humaine est d'abord intéressante pour elle-même; mais, si
l'artiste ne veut pas représenter une abstraction, il faut qu'il la place
dans son milieu. L'organisme conscient a des racines personnelles
profondes; mais la société a développé en lui tant de fonctions
hétérogènes qu'on ne saurait trancher ces milliers de suçoirs par où
il se nourrit sans le faire mourir. Il y a un instinct égoïste de la
conservation de l'individu; il y a aussi le besoin des autres êtres,
parmi lesquels l'individu se meut.
Le cœur de l'homme est double; l'égoïsme y balance la charité; la
personne y est le contre-poids des masses; la conservation de l'être
compte avec le sacrifice aux autres; les pôles du cœur sont au fond
du moi et au fond de l'humanité.
Ainsi l'âme va d'un extrême à l'autre, de l'expansion de sa propre vie
à l'expansion de la vie de tous. Mais il y a une route à faire pour
arriver à la pitié, et voici comment on pourrait en marquer les
étapes.
L'égoïsme vital éprouve des craintes personnelles: c'est le sentiment
que nous appelons TERREUR. Le jour où la personne se représente,
chez les autres êtres, les craintes dont elle souffre, elle est parvenue
à concevoir exactement ses relations sociales.
Or, la marche de l'âme est lente et difficile, pour aller de la terreur à
la pitié.
Cette terreur est d'abord extérieure à l'homme. Elle naît de causes
surnaturelles, de la croyance aux puissances magiques, de la foi au
destin que les anciens ont si magnifiquement représentée; mais une
rencontre fortuite d'accidents réels peut exciter une terreur intense
causée par des circonstances indépendantes de l'homme.
La terreur est intérieure à l'homme, bien que déterminée encore par
des causes qui ne dépendent pas de nous, dans la folie, la double
personnalité, la suggestion; mais elle peut être provoquée par
l'homme lui-même, et par sa recherche de sensations—que ce soit la
quintessence de l'amour, de la littérature, ou de l'étrangeté qui le
conduise à l'au-delà.
Quand la vie intérieure l'a mené jusqu'au néant de ces excitations, il
considère les choses terribles avec une certaine ironie, mais où
l'énervement se traduit encore par une excessive acuité de
sensations. La placidité béate de l'existence s'oppose vivement dans
son esprit à l'influence des terreurs provoquées, extérieures, ou
surnaturelles,—mais cette existence matérielle ne semble pas le
dernier but de l'activité humaine et on peut encore y être troublé par
la superstition.
A cet extrême, l'homme entrevoit le terme inférieur de la terreur,
pénètre dans l'autre moitié de son cœur, essaye de se représenter
dans les autres êtres la misère, la souffrance et la crainte, chasse de
lui toutes terreurs humaines ou surhumaines pour ne plus connaître
que la pitié.
Or, toutes les terreurs que l'homme a pu éprouver, la longue série
des criminels les a reproduites d'âge en âge jusqu'à nos jours. Les
actions des simples et des gueux sont des effets de la terreur et
répandent la terreur. La superstition et la magie, la soif de l'or, la
recherche de la sensation, la vie brutale et inconsciente, autant de
causes des crimes qui mènent à la vision de l'échafaud futur, ou à
l'échafaud lui-même, avec son horrible réalité.
L'homme devient pitoyable, après avoir ressenti toutes les terreurs,
après les avoir rendues concrètes en les incarnant dans ces pauvres
êtres qui en souffrent.
On a pitié de cette misère, et on tente de recréer la société, d'en
bannir toutes les terreurs par la Terreur, de faire un monde neuf où il
n'y ait plus ni pauvres, ni gueux. L'incendie devient mathématique,
l'explosion raisonnée, la guillotine volante. On tue pour le principe;
sorte d'homœopathie du meurtre. Le ciel est plein d'étoiles rouges.
La fin de la nuit sera une aurore sanglante.
Tout cela serait bon, serait juste, si l'extrême terreur n'entraînait
autre chose; si la pitié présente de ce qu'on supprime n'était plus
forte que la pitié future de ce qu'on veut créer; si le regard d'un
enfant ne faisait chanceler les meurtriers des générations d'hommes;
si le cœur n'était double, enfin, même dans les poitrines des ouvriers
de la terreur future.
Ainsi est atteint le but et nous sommes venus par le chemin du cœur
et par le chemin de l'histoire de la terreur à la pitié; nous avons
compris que les événements du monde extérieur peuvent être
parallèles aux émotions du monde intérieur; nous avons pressenti
que dans une seconde de vie intense nous revivons virtuellement et
actuellement l'univers.

II
Les anciens ont saisi le double rôle de la terreur et de la pitié dans la
vie humaine. L'intérêt des autres passions semblait inférieur, tandis
que ces deux émotions extrêmes emplissaient l'âme entière. L'âme
devait être en quelque manière une harmonie, une chose symétrique
et équilibrée. Il ne fallait pas la laisser en état de trouble; on
cherchait à balancer la terreur par la pitié. L'une de ces passions
chassait l'autre, et l'âme redevenait calme; le spectateur sortait
satisfait. Il n'y avait pas de moralité dans l'art; il y avait à faire
l'équilibre dans l'âme. Le cœur, sous l'empire d'une seule émotion,
eût été trop peu artistique à leurs yeux.
La purgation des passions, ainsi que l'entendait Aristote, cette
purification de l'âme, n'était peut-être que le calme ramené dans un
cœur palpitant. Car il n'y avait dans le drame que deux passions, la
terreur et la pitié, qui devaient se faire contre-poids, et leur
développement intéressait l'artiste à un point de vue bien différent
du nôtre. Le spectacle que cherchait le poète n'était pas sur la
scène. mais dans la salle. Il se préoccupait moins de l'émotion
éprouvée par l'acteur que de ce que sa représentation soulevait dans
le spectateur. Les personnages étaient vraiment de gigantesques
marionnettes terrifiantes ou pitoyables. On ne raisonnait pas sur la
description des causes, mais on percevait l'intensité des effets.
Or, les spectateurs n'éprouvaient que les deux sentiments extrêmes
qui emplissent le cœur. L'égoïsme menacé leur donnait la terreur; la
souffrance partagée leur donnait la pitié. Ce n'était pas la fatalité
dans l'histoire d'Œdipe ou des Atrides qui occupait le poète, mais
l'impression de cette fatalité sur la foule.
Le jour où Euripide analysa l'amour sur la scène, on put l'accuser
d'immoralité; car on ne lui reprochait pas le développement de la
passion chez ses personnages, mais celle qui pourrait se développer
chez ceux qui les voyaient.
On aurait pu concevoir l'amour comme un mélange de ces deux
passions extrêmes qui se partageaient le théâtre. Car il y a en lui de
l'admiration, de l'attendrissement et du sacrifice, un sentiment du
sublime qui participe de la terreur, une commisération délicate, et un
désintéressement suprême qui viennent de la pitié; si bien que peut-
être les deux moitiés de l'amour se joignent avec une force
supérieure là où d'un côté il y a l'admiration la plus effrayée, où de
l'autre il y a la pitié qui se sacrifie le plus sincèrement.
Ainsi, l'amour perd son égoïsme exclusif qui fait des amants deux
centres d'attraction tour à tour: car l'amant doit être tout pour son
amante, comme l'amante doit être tout pour son amant. Il est
devenu l'alliance la plus noble d'un cœur plein de sublime avec un
cœur plein de désintéressement. Les femmes ne sont plus Phèdre ni
Chimène, mais Desdémone, Imogène, Miranda, ou Alceste.
L'amour a sa place entre la terreur et la pitié. Sa représentation est
le plus délicat passage d'une de ces passions à l'autre; et elle les
soulève toutes deux dans le spectateur, dont l'âme prend ainsi plus
d'intérêt que celle du personnage qui joue.
L'analyse des passions dans la description des héros ou dans le rôle
des acteurs est déjà une pénétration de l'art par la critique.
L'examen que la personne représentée fait d'elle-même provoque un
examen imité chez le spectateur. Il perd la sincérité de ses
impressions; il ratiocine, discute, compare; les femmes cherchent
parfois dans ces développements des moyens matériels pour
tromper, et les hommes des moyens moraux pour découvrir; la
déclamation rhétorique est vide; la déclamation psychologique est
pernicieuse.
Les passions représentées non plus pour l'acteur, mais pour le
spectateur, ont une haute portée morale. En entendant les Sept
contre Thèbes, dit Aristophane, on était plein d'Arès. La fureur
guerrière et la terreur des armes ébranlait tous les assistants. Puis
les deux frères se tuant, les deux sœurs les enterrant, malgré des
ordres cruels et une mort imminente, la pitié chassait la terreur; le
cœur se calmait, l'âme reprenait de l'harmonie.
A de semblables effets une composition spéciale est nécessaire. Le
drame implexe diffère systématiquement du drame complexe. La
situation dramatique tout entière est dans l'exposition d'un état
tragique, qui contient en puissance le dénouement. Cet état est
exposé symétriquement, avec une mise en place rigoureuse et
définie du sujet et de la forme. D'un côté ceci; de l'autre cela.
Il suffit de lire Eschyle avec quelque attention pour percevoir cette
permanente symétrie qui est le principe de son art. La fin des pièces
est pour lui une rupture de l'équilibre dramatique. La tragédie est
une crise, et sa solution une accalmie. En même temps, à Égine, un
peu plus tard à Olympie, des sculpteurs de génie, obéissant aux
mêmes principes d'art, ornaient les frontons des temples de figures
humaines et de compositions scéniques symétriquement groupées
des deux côtés d'une rupture d'harmonie centrale. Les crises des
attitudes, réelles mais immobiles, sont placées dans une composition
dont le total explique chacune des parties.
Phidias et Sophocle furent en art des révolutionnaires réalistes. Le
type humain qui nous paraît idéalisé dans leurs œuvres est la nature
même, telle qu'ils la concevaient. Le mouvement de la vie fut suivi
jusque dans ses courbes les plus molles. Au témoignage d'Aristote,
un acteur d'Eschyle reprochait à un acteur de Sophocle de singer la
nature, au lieu de l'imiter. Le drame implexe avait disparu de la
scène artistique. Le mouvement réaliste devait encore s'accentuer
avec Euripide.
La composition d'art cessa d'être la représentation d'une crise. La vie
humaine intéressa par son développement. L'Œdipe de Sophocle est
une sorte de roman. Le drame fut découpé en tranches successives;
la crise devint finale, au lieu d'être initiale; l'exposition, qui était dans
l'art antérieur la pièce elle-même, fut réduite pour permettre le jeu
de la vie.
Ainsi naquit l'art postérieur à Eschyle, à Polygnote, et aux maîtres
d'Égine et d'Olympie. C'est l'art qui est venu jusqu'à nous par le
théâtre et le roman.
Comme toutes les manifestations vitales, l'action, l'association et le
langage, l'art a passé par des périodes analogues qui se
reproduisent d'âge en âge. Les deux points extrêmes entre lesquels
l'art oscille semblent être la Symétrie et le Réalisme. Dans la
Symétrie, la vie est assujettie à des règles artistiques
conventionnelles; dans le Réalisme, la vie est reproduite avec toutes
ses inflexions les plus inharmoniques.
De la période symétrique du XIIe et du XIIIe siècle, l'art a passé à la
période psychologique, réaliste et naturiste des XIVe, XVe et XVIe
siècles. Sous l'influence des règles antiques au XVIIe, il s'est
développé un art conventionnel que le mouvement du XVIIIe et du
XIXe siècle a rompu. Nous touchons aujourd'hui, après le
romantisme et le naturalisme, à une nouvelle période de symétrie.
L'Idée qui est fixe et immobile semble devoir se substituer de
nouveau aux Formes Matérielles, qui sont changeantes et flexibles.
Au moment où se crée un art nouveau, il est utile de ne pas
s'attacher uniquement à la considération de la floraison
indépendante des Primitifs et des Préraphaélites; il ne faut pas
négliger les belles constructions des crises de l'âme et du corps
qu'ont exécutées Eschyle et les maîtres d'Égine et d'Olympie.

III
Avant d'examiner le rôle que peuvent jouer dans l'art ces crises de
l'âme et du corps, il n'est pas inutile de regarder derrière nous et
autour de nous la forme littéraire prépondérante dans les temps
modernes, c'est-à-dire le roman.
Sitôt que la vie humaine parut intéressante par son développement
même, qu'il fût intérieur ou extérieur, le roman était né. Le roman
est l'histoire d'un individu, qu'il soit Encolpe, Lucius, Pantagruel, Don
Quichotte, Gil Blas ou Tom Jones. L'histoire était extérieure plutôt
avant la fin du siècle dernier et Clarisse Harlowe; mais pour être
devenue intérieure, la trame de la composition n'a pas changé.
Historiola animæ, sed historiola.
Les tourments de l'âme avec Gœthe, Stendhal, Benjamin Constant,
Alfred de Vigny, devinrent prédominants. La liberté personnelle avait
été dégagée par la révolution américaine, par la révolution française.
L'homme libre avait toutes les aspirations. On sentait plus qu'on ne
pouvait. Un élève notaire se tua en 1810, et laissa une lettre où il
annonçait sa résolution, parce qu'à la suite de sérieuses réflexions il
avait reconnu qu'il était incapable de devenir aussi grand que
Napoléon. Tous éprouvaient ceci dans tous les rayons de l'activité
humaine. Le bonheur personnel devait être au fond des bissacs que
chacun de nous porte devant et derrière lui.
La maladie du siècle commença. On voulut être aimé pour soi-
même. Le cocuage devint triste. La vie aussi: c'était un tissu
d'aspirations excessives que chaque mouvement déchirait. Les uns
se jetèrent dans des mysticismes singuliers, chrétiens, extravagants,
ou immondes; les autres, poussés du démon de la perversité, se
scarifièrent le cœur, déjà si malade, comme on taquine une dent
gâtée. Les autobiographies vinrent au jour sous toutes les formes.
Alors la science du XIXe siècle, qui devenait géante, se mit à envahir
tout. L'art se fit biologique et psychologique. Il devait prendre ces
deux formes positives, puisque Kant avait tué la métaphysique. Il
devait prendre une apparence d'érudition. Le XIXe siècle est
gouverné par la naissance de la chimie, de la médecine et de la
psychologie, comme le XVIe est mené par la renaissance de Rome et
d'Athènes. Le désir d'entasser des faits singuliers et archéologiques y
est remplacé par l'aspiration vers les méthodes de liaison et de
généralisation.
Mais, par un recul étrange, les généralisations des esprits artistiques
ayant été trop hâtives, les lettres marchèrent vers la déduction,
tandis que la science marchait vers l'induction.
Il est singulier que, dans le temps où on parle synthèse, personne
ne sache en faire. La synthèse ne consiste pas à rassembler les
éléments d'une psychologie individuelle, ni à réunir les détails de
description d'un chemin de fer, d'une mine, de la Bourse ou de
l'Armée.
Ainsi entendue, la synthèse est de l'énumération; et si des
ressemblances que présentent les moments de la série l'auteur
cherche à tirer une idée générale, c'est une banale abstraction, qu'il
s'agisse de l'amour des salons ou du ventre de Paris. La vie n'est pas
dans le général, mais dans le particulier; l'art consiste à donner au
particulier l'illusion du général.
Présenter ainsi la vie des entités partielles de la société, c'est faire
de la science moderne à la façon d'Aristote. La généralité engendrée
par l'énumération complète des parties est une variété du
syllogisme. «L'homme, le cheval, le mulet vivent longtemps, écrit
Aristote.—Or, l'homme, le cheval et le mulet sont tous les animaux
sans fiel.—Donc tous les animaux sans fiel vivent longtemps.»
Ceci n'est pas une désespérante tautologie, mais c'est le syllogisme
énumératif, qui n'a aucune rigueur scientifique. Il repose en effet sur
une énumération complète; et il est impossible, dans la nature, de
parvenir à un tel résultat.
La monotone nomenclature des détails psychologiques ou
physiologiques ne peut pas servir à donner les idées générales de
l'âme et du monde; et cette manière d'entendre et d'appliquer la
synthèse est une forme de la déduction.
Ainsi le roman analyste et le roman naturaliste, en faisant usage de
ce procédé, pèchent contre la science qu'ils invoquent tous deux.
Mais s'ils emploient faussement la synthèse, ils appliquent aussi la
déduction en plein développement de la science expérimentale.
Le roman analyste pose la psychologie du personnage, la commente
finement et déduit de là une vie entière.
Le roman naturaliste pose la physiologie du personnage, décrit ses
instincts, son hérédité, et déduit de là l'ensemble de ses actions.
Cette déduction unie à la synthèse énumérative constitue la
méthode propre des romans analystes et naturalistes.
Car le romancier moderne prétend avoir une méthode scientifique,
réduire les lois naturelles et mathématiques en formules littéraires,
observer comme un naturaliste, expérimenter comme un chimiste,
déduire comme un algébriste.
L'art véritablement entendu semble au contraire se séparer de la
science par son essence même.
Dans la considération d'un phénomène de la nature, le savant
suppose le déterminisme, cherche les causes de ce phénomène et
ses conditions de détermination; il l'étudie au point de vue de
l'origine et des résultats; il se l'asservit à lui-même, pour le
reproduire, et l'asservit à l'ensemble des lois du monde pour l'y lier;
il en fait un déterminable et un déterminé.
L'artiste suppose la liberté, regarde le phénomène comme un tout, le
fait entrer dans sa composition avec ses causes rapprochées, le
traite comme s'il était libre, lui-même libre dans sa manière de le
considérer.
La science cherche le général par le nécessaire; l'art doit chercher le
général par le contingent; pour la science, le monde est lié et
déterminé; pour l'art, le monde est discontinu et libre; la science
découvre la généralité extensive; l'art doit faire sentir la généralité
intensive; si le domaine de la science est le déterminisme, le
domaine de l'art est la liberté.
Les êtres vivants, spontanés, libres, dont la synthèse psychologique
et physiologique, malgré certaines conditions déterminées, dépendra
des séries qu'ils rencontreront, des milieux qu'ils traverseront, tels
seront les objets de l'art. Ils ont des facultés de nutrition,
d'absorption et d'assimilation; mais il faut tenir compte du jeu
compliqué des lois naturelles et sociales, que nous appelons hasard,
que l'artiste n'a pas à analyser, qui est véritablement pour lui le
Hasard, et qui amène à l'organisme physique et conscient les choses
dont il peut se nourrir, qu'il peut absorber et s'assimiler.
Ainsi la synthèse sera celle d'un être vivant.
Si toutes les conditions de la vie humaine pouvaient être
déterminées ou prévues, a écrit Kant, on calculerait les actions des
hommes comme des éclipses.
La science des choses humaines n'a pas encore atteint la science des
choses célestes.
La physiologie et la psychologie ne sont malheureusement pas
beaucoup plus avancées que la météorologie; et les actions que
prédit la psychologie de nos romans sont d'ordinaire aussi faciles à
prévoir que la pluie pendant l'orage.
Mais il faut trouver le moyen de nourrir artistiquement l'être
physique et conscient des événements que le Hasard lui offre. On ne
peut pas donner de règles pour cette synthèse vivante. Ceux qui
n'en ont pas d'idée, et qui clament sans cesse à la synthèse,
retardent en art, comme Platon retardait en science.
«Quand j'ajoute un à un, disait Platon dans sa République, qu'est-ce
qui devient deux, l'unité à laquelle j'ajoute, ou celle qui est
ajoutée?»
Pour un esprit aussi profondément déductif, la série des nombres
devait naître analytiquement; le nouvel être deux devait être
enveloppé dans l'une des unités dont la jonction l'engendrait.
Nous disons que le nombre deux est produit synthétiquement, qu'il
intervient dans l'addition un principe différent de l'analyse; et Kant a
montré que la sériation des nombres était le résultat d'une synthèse
à priori.
Or, dans la vie la synthèse qui s'opère est aussi radicalement
différente de l'énumération générale des détails psychologiques et
physiologiques ou du système déductif.
Il y a peu d'exemples meilleurs de la représentation de la vie qu'un
passage d'Hamlet.
Deux actions dramatiques se partagent la pièce, l'une extérieure à
Hamlet, l'autre intérieure. A la première se rattache le passage des
troupes de Fortinbras (act. IV, sc. V) qui traversent le Danemark
pour attaquer la Pologne. Hamlet les voit passer. Comment l'action
intérieure à Hamlet se nourrira-t-elle de cet événement extérieur?
Voici; Hamlet s'écrie:

Comment, je reste immobile,

Moi qui ai, par mon père tué, ma mère souillée,
Des excitations de la raison et du sang,
Et je laisse tout dormir? Quand, à ma honte, je vois
L'imminente mort de vingt mille hommes
Qui, pour une fantaisie et un jeu de gloire,
Vont vers leurs tombes!

Ainsi la synthèse est accomplie; et Hamlet s'est assimilé pour sa vie

intérieure un fait de la vie extérieure. Claude Bernard distinguait
dans les êtres vivants le milieu intérieur et le milieu extérieur;
l'artiste doit considérer en eux la vie intime et la vie externe, et nous
faire saisir les actions et les réactions, sans décrire ni discuter.
Or, les émotions ne sont pas continues; elles ont un point extrême et
un point mort. Le cœur éprouve, au moral, une systole et une
diastole, une période de contraction, une période de relâchement.
On peut appeler crise ou aventure le point extrême de l'émotion.
Chaque fois que la double oscillation du monde extérieur et du
monde intérieur amène une rencontre, il y a une «aventure» ou une
«crise». Puis les deux vies reprennent leur indépendance, chacune
fécondée par l'autre.
Depuis la grande renaissance romantique, la littérature a parcouru
tous les moments de la période de relâchement du cœur, toutes les
émotions lentes et passives. A cela devaient aboutir les descriptions
de la vie psychologique et de la vie physiologique déterminées. A
cela aboutira le roman des masses, si on y fait disparaître l'individu.
Mais la fin du siècle sera peut-être menée par la devise du poète
Walt Whitman: Soi-Même et en Masse. La littérature célébrera les
émotions violentes et actives. L'homme libre ne sera pas asservi au
déterminisme des phénomènes de l'âme et du corps. L'individu
n'obéira pas au despotisme des masses, ou il les suivra
volontairement. Il se laissera aller à l'imagination et à son goût de
vivre.
Si la forme littéraire du roman persiste, elle s'élargira sans doute
extraordinairement. Les descriptions pseudo-scientifiques, l'étalage
de psychologie de manuel et de biologie mal digérée en seront
bannis. La composition se précisera dans les parties, avec la langue;
la construction sera sévère; l'art nouveau devra être net et clair.
Alors le roman sera peut-être un roman d'aventures dans le sens le
plus large du mot, le roman des crises du monde intérieur et du
monde extérieur, l'histoire des émotions de l'individu et des masses,
soit que les hommes cherchent du nouveau dans leur cœur, dans
l'histoire, dans la conquête de la terre et des choses, ou dans
l'évolution sociale.
LA PERVERSITÉ
LA PERVERSITÉ
I
«Vivre, a écrit Ibsen, c'est combattre avec les êtres fantastiques qui
naissent dans les chambres secrètes de notre cœur et de notre
cerveau; être poète, c'est tenir jugement sur soi-même.»
Ces vers sont terribles. Ils disent toute la perversité qui hante les
têtes de notre temps. Je voudrais esquisser ce que j'y vois, et dire
quelques mots sur cette perversité.
Le premier aspect du monde, centralisateur, égoïste et logique, est la
continuité. L'expérience de Weber pourrait se formuler ainsi: la
notion de continuité croît en raison inverse de la spécialisation
tactile. Nous mettons la continuité dans les choses par la
centralisation nerveuse, qui nous donne le continu dans la quantité
et par la généralisation logique, qui nous donne le continu dans la
qualité. Tel est l'aspect simple et extérieur de l'univers, qui résulte de
la position de notre unité au milieu d'une multiplicité que nous
coordonnons.
La spécialisation tactile, la science qui en est comme le
prolongement instrumental, nous apprennent que le monde est en
réalité discontinu. L'espace interstellaire ne diffère de l'espace
intermoléculaire que parce que nous sommes placés entre les deux
et que nous mesurons leurs rapports. La notion de temps qui est
engendrée par celle de l'espace n'est pas plus exacte sous son
premier aspect continu. Il peut y avoir de l'infini entre les moments
d'un temps divisé à l'infini. On perçoit très bien que le temps
psychologique (et le temps astronomique se mesure par des
différences de position dans l'espace) est essentiellement variable.
Notre notion du temps se transforme du sauvage à l'homme civilisé,
de l'enfant à l'adulte, du rêve à la veille.
Ainsi l'aspect dernier du monde, après le perfectionnement des sens
et de la connaissance, est la discontinuité. (Il serait facile de montrer
que qualitativement c'est aussi la notion de ressemblance qui
précède la notion de l'extrême différenciation, et que là encore
s'affirme la loi du passage de l'homogène à l'hétérogène.)
La vision passionnelle et morale de l'univers s'adapte successivement
aux mêmes points de vue. L'âme est une d'abord, et qu'elle regarde,
raisonne ou désire, elle s'applique tout entière. La notion de la
diversité des objets et de la diversité de ses propres parties ne lui
vient que plus tard. Elle se conçoit alors sous forme de sensation, de
raison, ou de volonté, et accorde une prépondérance à ses espèces.
Si elle réalise des créations esthétiques, elle les sépare et leur donne
à chacune leur domaine; elle ne produit pas l'homme tout entier, fin
et courageux, aventureux et prudent, comme Odysseus; elle jette
sur la scène un ambitieux, un jaloux, un irrésolu, Macbeth. Othello,
Hamlet. De même que les modernes distinguent dans la gamme des
couleurs des nuances que les anciens n'apercevaient pas, l'âme a
fait aussi son éducation des nuances: là où elle était pourpre, elle se
voit violette, et mauve, et cerise, et orange, et plus elle se
différencie, plus elle donne de valeur à ses molécules.
Le point de départ moral de l'homme est l'égoïsme. C'est le reflet
sentimental de la loi de l'existence, par laquelle l'être tend à
persister dans son être. La perversité morale (et j'entends perversité
en me plaçant au point de vue de la nature) naît au moment même
où l'homme conçoit qu'il y a d'autres êtres semblables à lui et leur
sacrifie une part de son moi. La fleur douloureuse de cette perversité
est le plaisir du sacrifice. Et si le sacrifice n'est accompli que pour lui-
même cette perversité est absolue: car l'être s'annule dans le but
positif du plaisir, au lieu que l'hédoniste ne se tuait que pour éviter la
négation douleur. Mais si le sacrifice est accompli en vue des autres
hommes, au profit de la masse, si l'être tend à persister dans
d'autres êtres, de la perversité première est sortie une moralité plus
haute, supérieure à la nature même.
II
«Ces êtres fantastiques qui naissent dans les chambres de notre
cœur et de notre cerveau» sont des créations ou des fantômes. Je
vois que l'effroyable perversité de Shakespeare a engendré dans sa
tête Lear, Richard III, Antoine, Caliban, Falstaff, Miranda, et tant
d'autres si divers, qu'il avait voulus tels, et que l'extrême
différenciation de ses passions lui a permis de projeter tous, après
avoir lutté contre eux. Mais je vois que dans les Revenants le
fantôme du père d'Oswald Alving germe dans le cerveau du fils et
l'opprime et le terrifie, et que le fils succombe à la lutte. Je vois tous
les pauvres êtres romantiques éclos dans la tête de Mme Bovary ou
de Frédéric Moreau les assujettir et les mener à la mort ou au
lamentable ennui de la vie.
Car ceux qui ont pu se différencier et cesser d'être eux-mêmes
savent appliquer leur volonté à la création esthétique, ou l'ignorent,
ont engendré les êtres fantastiques, ou sont leur proie. Le plus
terrible fantôme, sans apparence, sans forme, que rencontre Peer
Gynt, le héros d'Ibsen, qui se conçoit sous un nombre infini de
formes imaginaires aussitôt réalisées, répond quand Peer Gynt lui
demande son nom: «Je m'appelle Moi-même.»
On voit très clairement que dans la période que nous traversons
nous sommes soumis aux fantômes de l'hérédité ou de l'extrême
littérature. Car notre volonté ne sait plus s'appliquer aux choses
extérieures, ni projeter les êtres qui naissent en nous. Les poètes
regardent passer l'action, et la regrettent,—mais ils n'agissent pas.
Le prince Florimond voyait s'enfuir le char où se rouillaient ses
glaives; la Belle au Bois Dormant sommeille sous des berceaux
d'épines neuf fois entrelacés; le plongeur regarde passer le long des
parois de sa cloche de verre, tiédie par la vie ambiante, les pendules
vivants de la mer. Et Florimond reste prisonnier des fleurs
victorieuses; et les haies de ronces empêchent la Belle d'allonger sa
main; et la vitre des serres chaudes et des cloches de verre arrête
en buée l'haleine de ceux qui voudraient galoper par la forêt ou
secouer les vagues. Et M. Maurice Maeterlinck nous dit: «J'aurais
voulu agir—mais à quoi bon—la mort est là, tout de suite, qui
anéantit l'activité. Voyez, elle est parmi les aveugles, dans cette île
de la vie, entourée par la mer inconnue et montante, où ils sont
arrivés d'étranges pays; et quand l'action humaine est partie (—nous
ne reviendrons plus—) sur le vaisseau de guerre, l'intruse est venue
au milieu des sept princesses. Ayez pitié de nous! car la mort est
proche, et nous n'osons étendre la main, de peur de la toucher.»

III
Imaginons donc un être dont le cerveau soit hanté de fantômes qui
ont une tendance à la réalité, comme les images ont une tendance
hallucinatoire, et qui, en même temps, ne soit pas encore doué de la
volonté nécessaire pour agir, ou pour projeter ses fantômes après
avoir lutté contre eux. Je pense que cet être n'est pas rare, et qu'il
représente même un moment de l'évolution intellectuelle de
beaucoup d'artistes de notre temps. L'intelligence et l'esthétique
intérieure se forment bien plus tôt que la volonté. Pour produire une
œuvre d'art, il faut que la volonté ait atteint son développement.
Auparavant les créations ou les fantômes de l'artiste, puisqu'il ne
peut pas encore les réaliser esthétiquement, s'interposeront entre lui
et la société, l'isoleront du monde, ou il les introduira dans l'univers,
à la manière de Don Quichotte, qui n'a point d'autre folie que celle-
là.
Cet être m'apparaît nettement dans l'Écornifleur de Jules Renard.
L'Écornifleur est un jeune homme dont le cerveau est peuplé de
littérature. Rien pour lui ne se présente comme un objet normal. Il
voit le XVIIIe siècle à travers Goncourt, les ouvriers à travers Zola, la
société à travers Daudet, les paysans à travers Balzac et
Maupassant, la mer à travers Michelet et Richepin. Il a beau
regarder la mer, il n'est jamais au niveau de la mer. S'il aime, il se
rappelle les amours littéraires. S'il viole, il s'étonne de ne pas violer
comme en littérature. Sa tête est pleine de fantômes.
Il apporte ces fantômes dans un ménage bourgeois. Jamais il ne
sera au niveau de ce ménage, ni le ménage au sien. Il veut
intéresser des gens qu'il voit déformés, et il les déforme pour les
obliger à l'intéresser. Il se doit à sa littérature de traiter le mari en
Homais, la femme en Mme Bovary, et de violer la nièce par un beau
jour d'été. Entre temps, il vit aux crochets de la famille—car
l'Écornifleur est pauvre de nature.
Mais la volonté manque à ses créations. Il est encore trop lui-même.
Il rencontre le même être que Peer Gynt. Il a pitié et peur du mari.
Le baiser soudain de la femme l'effare, et il se sent dans une action
réelle sans soutien littéraire. La jeune fille forcée pousse des cris,
souffre, se lamente—et les fantômes de son cerveau n'étaient pas
ainsi. L'Écornifleur cède devant lui-même; il ne sait pas réaliser dans
la vie les êtres fantastiques qui ont poussé dans sa tête; il faut qu'il
attende le jour où sa volonté formée les projettera dans l'art.
Un pouce de plus à son vouloir, et c'est Chambige. Un pouce de
moins, et c'est Poil-de-Carotte. Un peu plus d'énergie dans l'action,
et il est criminel. Un peu moins d'extériorisation, et le pauvre enfant
se plaint de ne pas être compris.
Et comme ce roman est bien celui des crises! L'être fantastique
conçu par l'Écornifleur est arrivé à sa pleine croissance, il voit la
femme qu'il se doit d'aimer; il va descendre à sa chambre, au milieu
de la nuit; déjà elle a les jambes levées. Mais l'aventure ne se
produit pas; la femme ne l'attend pas—elle dort—les portes seront
fermées—l'Écornifleur sera pieds nus et ridicule.—Il lit des vers en
élevant son âme jusqu'au fumivore; le miracle va se produire; on
écoutera ses poèmes comme il conçoit qu'on les écoute: le mari fait
vibrer son couteau dans une rainure de la table et dit: «C'est fini?»
Dans un roman fantastique comme Macbeth ou Hamlet, la crise
appelle l'aventure; l'état intérieur du personnage projette le fantôme
ou l'événement extérieur. Le pauvre Écornifleur ne trouve jamais les
aventures qu'il s'imaginait, quand elles étaient des crises.