search for books and compare prices
Tables of Contents for Programming With Visualage for Java
Chapter/Section Title
Page #
Page Count
Foreword
vi
1
Preface
vii
18
What Is Java?
vii
1
Who Should Read This Book?
vii
1
Let's Get Practical
vii
1
How This Book Is Organized
viii
3
CD-ROM Included
xi
1
Special Conventions in This Book
xi
1
ITSO on the Internet
xii
1
VisualAge for Java Support
xiii
1
About the Authors
xiv
1
Acknowledgments
xiv
1
Figures
xxv
4
Tables
xxix
Part 1. VisualAge for Java and Java Basics
3
194
Chapter 1. Introduction to the Environment
3
16
The VisualAge for Java Development Environment
3
2
Building Your First Applet
5
8
Let's Get Started!
5
5
The Workbench Explained
10
2
Creating An Animated Applet
12
1
Building Your First Application
13
3
VisualAge for Java Symbols Explained
16
3
Chapter 2. Java Basics
19
22
How Java Works
19
1
The Java Language
20
15
Statements
21
1
Variables, Keywords, and Operators
21
8
Comments
29
1
Predefined Classes: String and Array
29
2
Control Flow
31
4
The VisualAge for Java Scrapbook
35
6
Using the Scrapbook
35
3
Correcting Errors in the Scrapbook
38
3
Chapter 3. Objects and the Java Language
41
30
Object-Oriented Programming Concepts
42
5
Objects
42
3
Messages
45
1
Classes
46
1
What Makes Java Object-Oriented?
46
1
The Automated Teller Machine (ATM)
47
4
System Requirements
48
1
Analysis
48
2
Design
50
1
Implementation
50
1
The BankAccount Class
51
5
Creating Java Classes
51
1
Fields
52
1
Methods
53
3
Wrapper Classes
56
1
The BankAccount Objects
56
2
Static Fields and Static Methods
57
1
Using Objects within Your Programs
58
2
Object References
58
1
Message Sending
59
1
Object Assignment
59
1
Implementing the BankAccount Class
60
11
Creating a New Class
60
2
Creating the Balance Field
62
1
Creating the AccountId Field
63
1
Creating Getter and Setter Methods for the Balance Field
63
2
Creating the Getter and Setter Methods for the AccountId Field
65
1
Correcting Mistakes
65
1
Creating Debit and Credit Methods
66
3
Testing the Class in the Scrapbook
69
2
Chapter 4. Organizing Your Code
71
14
What Is a Package?
71
2
More about Access Modifiers
72
1
Packages in File-Based Java
73
2
CLASSPATH Environment Variable
73
1
Creating Packages
73
1
Using Packages
74
1
Packages in VisualAge for Java
75
3
Creating Packages
76
1
Using Packages in Your VisualAge for Java Code
77
1
Importing and Exporting Java Code
78
4
Importing Java Code to VisualAge for Java
78
2
Using the Import SmartGuide
80
1
Exporting Java Code from VisualAge for Java
81
1
Projects in VisualAge for Java
82
3
Java Class Libraries
83
2
Chapter 5. Lifecycle of Java Objects
85
18
Instantiating Objects
85
9
Initializing Fields
86
1
Constructors
87
2
Overloading a Constructor
89
1
The this Keyword
90
1
Copy Constructor and References
90
3
Passing Arguments in Methods
93
1
Access Modifiers and Constructors
94
1
When the Work Is Done: Finalizers
94
1
Creating Constructors and Finalizers with VisualAge for Java
95
8
Copying Packages
96
1
Adding the initialAmount Field
96
1
Creating Constructors with VisualAge for Java
97
3
Defining Finalizers with VisualAge for Java
100
3
Chapter 6. Reuse in Java
103
36
Reuse in Object-Oriented Languages
103
1
Is-A and Has-A Relationships
104
1
Inheritance
104
11
Do You Speak Object-Oriented?
104
2
Creating Subclasses with Java
106
1
Incremental Development
106
1
Abstract Classes
107
1
Abstract Methods
108
1
Polymorphism
109
3
Interfaces
112
2
Interfaces and Abstract Classes
114
1
Aggregation
115
4
Banking Transactions
115
2
Delegation
117
1
Association
118
1
Inheritance and Aggregation
118
1
Inner Classes
118
1
Class Implementation Revisited
119
2
Modifiers Revisited
119
1
Constructors Revisited
120
1
Reuse with VisualAge for Java
121
18
Implementing Inheritance
121
7
Implementing Abstract Classes
128
2
Implementing an Interface
130
3
Implementing Aggregation
133
6
Chapter 7. Error Handling and Debugging
139
24
Overview of Exception Handling in Java
139
7
Why a New Error Handling Mechanism?
140
1
What Are Exceptions?
141
1
Exception Handling Keywords and Concepts
141
5
Java Standard Exceptions
146
3
The Throwable Hierarchy
146
2
Using Predefined Exceptions
148
1
Creating and Throwing Your Own Exceptions
149
1
Defining a New Exception Class
149
1
Implementing the InsufficientFunds Exception
150
3
Defining the InsufficientFundsException Class
150
1
Modifying the Debit Method
151
1
Testing the BankAccount Class
152
1
Debugging a VisualAge for Java Program
153
10
Inspectors
153
3
The Debugger
156
7
Chapter 8. File I/O and Persistence
163
18
Persistence
164
1
Java I/O
164
6
Input Streams
165
1
Output Streams
166
1
Utility Classes
167
1
Using Input/Output Streams
168
2
Object Streams
170
1
Object Serialization
170
4
The Serializable Interface
171
1
Object Dependencies
172
1
Behind the Scene of Serialization
173
1
Controlling the Serialization
173
1
BankAccount Serialization
174
7
Serializing the Transaction Class
174
3
Serializing the BankAccount Class
177
4
Chapter 9. Managing Your Code
181
16
Storing Your Code
182
2
The Workspace
183
1
The Repository
183
1
Version Control
184
7
Editions
184
1
Versions
184
1
Versioning Program Elements
185
2
Managing Editions
187
4
Searching for Program Elements
191
1
The Search Dialog
191
1
Customizing the Search
191
1
Versioning the BankAccount
192
5
Part 2. Visual Building with JavaBeans
197
154
Chapter 10. Building User Interfaces with Java
197
32
The Abstract Windowing Toolkit
198
5
The GUI Components
198
3
Applets and Applications Revisited
201
2
Creating User Interfaces
203
2
Container Classes
203
1
Coding Your First User Interface
203
2
Handling Events
205
9
Handling Events with Java AWT 1.0
205
3
Handling Events with Java AWT 1.1
208
6
Controlling Layout
214
10
FlowLayout
215
1
BorderLayout
216
1
CardLayout
217
1
GridLayout
218
3
GridBagLayout
221
3
Combining Layout Managers
224
1
Creating and Using Menus
224
5
Using Menus with Applications
224
2
Using Menus with Applets
226
3
Chapter 11. Visual Programming and JavaBeans
229
48
Software Components
230
2
Software Components and Classes
230
1
Benefits of Software Components
230
1
JavaBeans
231
1
Visual Programming
231
1
The Visual Composition Editor
232
6
First Contact
233
3
Basic Bean Manipulations
236
2
Creating a Simple User Interface
238
8
Visual Programming in Action
238
3
Looking at the Generated Code
241
5
More about JavaBeans
246
5
Bean Features
246
3
Introspection and BeanInfo Class
249
1
Bean Persistence
250
1
Using VisualAge to Create Beans
251
26
Requirements for a Simple Calculator
251
1
Building the Calculator Model
252
4
Building the Calculator View
256
1
Connecting the Model and the View
257
13
Adding Menus to Your Application
270
4
Importing and Beanizing Existing Java Code
274
3
Chapter 12. Visual Programming in Action
277
74
Expanding the Banking Model
278
14
Creating an AtmCard Class
278
3
Modifying the BankAccount Class
281
8
Creating a Bank Bean
289
3
Creating the ATM View
292
37
Reusing Composite Beans
296
1
Organizing the Building of Your Beans
296
2
Using Layout Managers in Visual Composition
298
2
AtmAccountPanel
300
9
AtmKeypad
309
4
AtmKeypadPanel
313
2
AtmWelcomePanel
315
4
AtmPinPanel
319
2
AtmPanel
321
6
AtmHistoryPanel
327
2
Putting Your Applet Together
329
15
Assembling the ATM Panels
329
7
Displaying a Java Exception in a Message Box
336
2
Creating a Custom Event
338
6
Running Your ATM Applet As an Application
344
1
Converting Your Applet
344
1
The Final Touch
345
6
Using Factory Bean
346
1
Running CalculApp from AtmApplet
346
5
Part 3. Applet Publishing and Advanced Features
351
90
Chapter 13. Improving Your ATM Applet
351
42
Multithreading Support
352
9
The StaticTicker Bean
352
2
A Demanding Ticker
354
2
Multithreading to the Rescue
356
3
Modifying the ATM Applet
359
1
Resource Locking
360
1
NLS Support
361
25
Internationalization Framework
361
1
Locales
362
1
Obtaining All Supported Locales
362
2
Resource Bundles
364
3
Formatting Data
367
4
Collation
371
2
Character Properties
373
2
Converting Non-Unicode Text
375
1
Creating Multilingual Applications
375
1
Modifying the ATM Applet
375
11
Run-Time Type Identification
386
7
Using Class Objects
387
1
Identifying the Type of Account
387
2
Accessing Methods by Downcasting
389
4
Chapter 14. Publishing Your Applet
393
20
Exporting Your Applet
393
3
Exporting the ATM Applet As Binary Files
394
1
Exporting the ATM Applet As a JAR File
395
1
Writing an HTML Page
396
4
Applets and the APPLET Tag
396
2
Referring to JAR Files in Your HTML Page
398
1
Sample of HTML Page for the ATM Applet
398
2
Setting Up Your Web Server
400
8
Hardware and Software Requirements
401
1
Installation
401
2
Starting the Server
403
1
Configuring the Server
404
4
Web Browsers and JDK 1.1
408
5
Sun HotJava 1.0
408
1
Netscape Communicator 4.03
409
1
Microsoft Internet Explorer 4.0
410
1
Compatibility Issues
410
3
Chapter 15. VisualAge for Java Enterprise Edition
413
28
Introduction to the Enterprise Access Builder
414
24
Relational Database Access
414
5
CICS Access
419
5
C++ Access
424
6
RMI Access
430
8
The ATM Applet Revisited
438
3
Accessing the Bank Database
438
1
Accessing the Credit Card Authentication Server
439
1
Accessing Distributed Java Objects
439
1
Home Banking
439
2
Appendix A. VisualAge for Java Installation
441
4
Installing VisualAge for Java
441
1
Loading the Samples in the Workspace
442
1
Managing the ATM Applet Resources
443
1
Loading IBM Extra Beans
443
1
Extra Software
444
1
Appendix B. UML Notation
445
6
Class
446
1
Object
446
1
Generalize/Inherits Relationship
447
1
Association Relationship
447
1
Aggregation Relationship
448
1
Sequence Diagram
449
2
Appendix C. Related Publications
451
6
International Technical Support Organization Publications
451
1
Redbooks on CD-ROMs
452
1
Other Publications
453
2
How To Get ITSO Redbooks
455
1
How IBM Employees Can Get ITSO Redbooks
455
1
How Customers Can Get ITSO Redbooks
456
1
Special Notices
457
4
Glossary
461
16
List of Abbreviations
477
2
Index
479