9780131872486

Thinking in Java

by
  • ISBN13:

    9780131872486

  • ISBN10:

    0131872486

  • Edition: 4th
  • Format: Paperback
  • Copyright: 2006-02-10
  • Publisher: Prentice Hall

Note: Supplemental materials are not guaranteed with Rental or Used book purchases.

Purchase Benefits

  • Free Shipping On Orders Over $35!
    Your order must be $35 or more to qualify for free economy shipping. Bulk sales, PO's, Marketplace items, eBooks and apparel do not qualify for this offer.
  • Get Rewarded for Ordering Your Textbooks! Enroll Now
  • We Buy This Book Back!
    In-Store Credit: $10.50
    Check/Direct Deposit: $10.00
List Price: $74.99 Save up to $18.75
  • Rent Book $56.24
    Add to Cart Free Shipping

    TERM
    PRICE
    DUE

Supplemental Materials

What is included with this book?

  • The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.
  • The Rental copy of this book is not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.

Summary

Bruce Eckel's Classic, award-winning Thinking in Java, Fourth Edition - now fully updated and revised for J2SE 5.0!

Author Biography

Bruce Eckel is president of MindView, Inc. (www.MindView.net), which provides public and private training seminars, consulting, mentoring, and design reviews in object-oriented technology and design patterns. He is the author of several books, has written more than fifty articles, and has given lectures and seminars throughout the world for more than twenty years. Bruce has served as a voting member of the C++ Standards Committee. He holds a B.S. in applied physics and an M.S. in computer engineering.



Table of Contents

Preface 1(1)
Java SE5 and SE6 2(1)
Java SE6 3(1)
The 4th edition 3(1)
Changes 4(2)
Note on the cover design 6(1)
Acknowledgements 7(6)
Introduction
13(10)
Prerequisites
14(1)
Learning Java
14(1)
Goals
15(1)
Teaching from this book
16(1)
JDK HTML documentation
17(1)
Exercises
17(1)
Foundations for Java
18(1)
Source code
18(3)
Coding standards
21(1)
Errors
21(2)
Introduction to Objects
23(38)
The progress of abstraction
24(2)
An object has an interface
26(3)
An object provides services
29(1)
The hidden implementation
30(2)
Reusing the implementation
32(1)
Inheritance
33(5)
Is-a vs. is-like-a relationships
37(1)
Interchangeable objects with polymorphism
38(5)
The singly rooted hierarchy
43(1)
Containers
44(2)
Parameterized types (Generics)
45(1)
Object creation & lifetime
46(3)
Exception handling: dealing with errors
49(1)
Concurrent programming
50(1)
Java and the Internet
51(9)
What is the Web?
51(2)
Client-side programming
53(6)
Server-side programming
59(1)
Summary
60(1)
Everything Is an Object
61(32)
You manipulate objects with references
61(2)
You must create all the objects
63(4)
Where storage lives
63(2)
Special case: primitive types
65(1)
Arrays in Java
66(1)
You never need to destroy an object
67(2)
Scoping
67(1)
Scope of objects
68(1)
Creating new data types: class
69(3)
Fields and methods
70(2)
Methods, arguments, and return values
72(2)
The argument list
73(1)
Building a Java program
74(4)
Name visibility
74(1)
Using other components
75(1)
The static keyword
76(2)
Your first Java program
78(3)
Compiling and running
80(1)
Comments and embedded documentation
81(7)
Comment documentation
82(1)
Syntax
83(1)
Embedded HTML
84(1)
Some example tags
85(2)
Documentation example
87(1)
Coding style
88(1)
Summary
89(1)
Exercises
89(4)
Operators
93(42)
Simpler print statements
93(1)
Using Java operators
94(1)
Precedence
95(1)
Assignment
95(3)
Aliasing during method calls
97(1)
Mathematical operators
98(3)
Unary minus and plus operators
101(1)
Auto increment and decrement
101(2)
Relational operators
103(2)
Testing object equivalence
103(2)
Logical operators
105(3)
Short-circuiting
106(2)
Literals
108(3)
Exponential notation
109(2)
Bitwise operators
111(1)
Shift operators
112(4)
Ternary if-else operator
116(2)
String operator + and +=
118(1)
Common pitfalls when using operators
119(1)
Casting operators
120(2)
Truncation and rounding
121(1)
Promotion
122(1)
Java has no ``sizeof''
122(1)
A compendium of operators
123(10)
Summary
133(2)
Controlling Execution
135(20)
true and false
135(1)
if-else
135(2)
Iteration
137(3)
do-while
138(1)
for
138(2)
The comma operator
140(1)
Foreach syntax
140(3)
return
143(1)
break and continue
144(2)
The infamous ``goto''
146(5)
switch
151(3)
Summary
154(1)
Initialization & Cleanup
155(54)
Guaranteed initialization with the constructor
155(3)
Method overloading
158(8)
Distinguishing overloaded methods
160(1)
Overloading with primitives
161(4)
Overloading on return values
165(1)
Default constructors
166(1)
The this keyword
167(6)
Calling constructors from constructors
170(2)
The meaning of static
172(1)
Cleanup: finalization and garbage collection
173(8)
What is finalize() for?
174(1)
You must perform cleanup
175(1)
The termination condition
176(2)
How a garbage collector works
178(3)
Member initialization
181(4)
Specifying initialization
183(2)
Constructor initialization
185(8)
Order of initialization
185(1)
static data initialization
186(4)
Explicit static initialization
190(1)
Non-static instance initialization
191(2)
Array initialization
193(11)
Variable argument lists
198(6)
Enumerated types
204(3)
Summary
207(2)
Access Control
209(28)
package: the library unit
210(11)
Code organization
212(1)
Creating unique package names
213(4)
A custom tool library
217(3)
Using imports to change behavior
220(1)
Package caveat
220(1)
Java access specifiers
221(7)
Package access
221(1)
public: interface access
222(2)
private: you can't touch that!
224(1)
protected: inheritance access
225(3)
Interface and implementation
228(1)
Class access
229(4)
Summary
233(4)
Reusing Classes
237(40)
Composition syntax
237(4)
Inheritance syntax
241(5)
Initializing the base class
244(2)
Delegation
246(3)
Combining composition and inheritance
249(7)
Guaranteeing proper cleanup
251(4)
Name hiding
255(1)
Choosing composition vs. inheritance
256(2)
protected
258(2)
Upcasting
260(2)
Why ``upcasting''?
261(1)
Composition vs. inheritance revisited
261(1)
The final keyword
262(10)
final data
262(5)
final methods
267(3)
final classes
270(1)
final caution
271(1)
Initialization and class loading
272(2)
Initialization with inheritance
272(2)
Summary
274(3)
Polymorphism
277(34)
Upcasting revisited
278(3)
Forgetting the object type
279(2)
The twist
281(12)
Method-call binding
281(1)
Producing the right behavior
282(4)
Extensibility
286(4)
Pitfall: ``overriding'' private methods
290(1)
Pitfall: fields and static methods
290(3)
Constructors and polymorphism
293(10)
Order of constructor calls
293(2)
Inheritance and cleanup
295(6)
Behavior of polymorphic methods inside constructors
301(2)
Covariant return types
303(1)
Designing with inheritance
304(6)
Substitution vs. extension
306(2)
Downcasting and runtime type information
308(2)
Summary
310(1)
Interfaces
311(34)
Abstract classes and methods
311(5)
Interfaces
316(4)
Complete decoupling
320(6)
``Multiple inheritance'' in Java
326(3)
Extending an interface with inheritance
329(2)
Name collisions when combining interfaces
330(1)
Adapting to an interface
331(4)
Fields in interfaces
335(1)
Initializing fields in interfaces
335(1)
Nesting interfaces
336(3)
Interfaces and factories
339(4)
Summary
343(2)
Inner Classes
345(44)
Creating inner classes
345(2)
The link to the outer class
347(3)
Using .this and .new
350(2)
Inner classes and upcasting
352(2)
Inner classes in methods and scopes
354(2)
Anonymous inner classes
356(8)
Factory Method revisited
361(3)
Nested classes
364(5)
Classes inside interfaces
366(2)
Reaching outward from a multiply nested class
368(1)
Why inner classes?
369(13)
Closures & callbacks
372(3)
Inner classes & control frameworks
375(7)
Inheriting from inner classes
382(1)
Can inner classes be overridden?
383(2)
Local inner classes
385(2)
Inner-class identifiers
387(1)
Summary
388(1)
Holding Your Objects
389(54)
Generics and type-safe containers
390(4)
Basic concepts
394(2)
Adding groups of elements
396(2)
Printing containers
398(3)
List
401(5)
Iterator
406(4)
ListIterator
409(1)
LinkedList
410(2)
Stack
412(3)
Set
415(4)
Map
419(4)
Queue
423(4)
PriorityQueue
425(2)
Collection vs. Iterator
427(4)
Foreach and iterators
431(6)
The Adapter Method idiom
434(3)
Summary
437(6)
Error Handling with Exception's
443(60)
Concepts
444(1)
Basic exceptions
445(2)
Exception arguments
446(1)
Catching an exception
447(2)
The try block
447(1)
Exception handlers
448(1)
Creating your own exceptions
449(8)
Exceptions and logging
452(5)
The exception specification
457(1)
Catching any exception
458(10)
The stack trace
460(1)
Rethrowing an exception
461(3)
Exception chaining
464(4)
Standard Java exceptions
468(3)
Special case: RuntimeException
469(2)
Performing cleanup with finally
471(8)
What's finally for?
473(3)
Using finally during return
476(1)
Pitfall: the lost exception
477(2)
Exception restrictions
479(4)
Constructors
483(6)
Exception matching
489(1)
Alternative approaches
490(10)
History
492(2)
Perspectives
494(3)
Passing exceptions to the console
497(1)
Converting checked to unchecked exceptions
497(3)
Exception guidelines
500(1)
Summary
501(2)
Strings
503(50)
Immutable Strings
503(1)
Overloading `+' vs. StringBuilder
504(5)
Unintended recursion
509(2)
Operations on Strings
511(3)
Formatting output
514(9)
printf()
514(1)
System.out.format()
514(1)
The Formatter class
515(1)
Format specifiers
516(2)
Formatter conversions
518(3)
String.format()
521(2)
Regular expressions
523(23)
Basics
524(3)
Creating regular expressions
527(2)
Quantifiers
529(2)
Pattern and Matcher
531(9)
split()
540(1)
Replace operations
541(3)
reset()
544(1)
Regular expressions and Java I/O
544(2)
Scanning input
546(5)
Scanner delimiters
549(1)
Scanning with regular expressions
550(1)
StringTokenizer
551(1)
Summary
552(1)
Type Information
553(64)
The need for RTTI
553(3)
The Class object
556(13)
Class literals
562(3)
Generic class references
565(3)
New cast syntax
568(1)
Checking before a cast
569(13)
Using class literals
576(2)
A dynamic instanceof
578(2)
Counting recursively
580(2)
Registered factories
582(4)
instanceof vs. Class equivalence
586(2)
Reflection: runtime class information
588(5)
A class method extractor
590(3)
Dynamic proxies
593(5)
Null Objects
598(9)
Mock Objects & Stubs
606(1)
Interfaces and type information
607(6)
Summary
613(4)
Generics
617(130)
Comparison with C++
618(1)
Simple generics
619(8)
A tuple library
621(4)
A stack class
625(1)
RandomList
626(1)
Generic interfaces
627(4)
Generic methods
631(14)
Leveraging type argument inference
633(2)
Varargs and generic methods
635(1)
A generic method to use with Generators
636(1)
A general-purpose Generator
637(2)
Simplifying tuple use
639(2)
A Set utility
641(4)
Anonymous inner classes
645(2)
Building complex models
647(3)
The mystery of erasure
650(12)
The C++ approach
652(3)
Migration compatibility
655(1)
The problem with erasure
656(2)
The action at the boundaries
658(4)
Compensating for erasure
662(11)
Creating instances of types
664(3)
Arrays of generics
667(6)
Bounds
673(4)
Wildcards
677(17)
How smart is the compiler?
680(2)
Contravariance
682(4)
Unbounded wildcards
686(6)
Capture conversion
692(2)
Issues
694(7)
No primitives as type parameters
694(2)
Implementing parameterized interfaces
696(1)
Casting and warnings
697(2)
Overloading
699(1)
Base class hijacks an interface
700(1)
Self-bounded types
701(9)
Curiously-recurring generics
701(2)
Self-bounding
703(3)
Argument covariance
706(4)
Dynamic type safety
710(1)
Exceptions
711(2)
Mixins
713(8)
Mixins in C++
714(1)
Mixing with interfaces
715(2)
Using the Decorator pattern
717(2)
Mixins with dynamic proxies
719(2)
Latent typing
721(5)
Compensating for the lack of latent typing
726(11)
Reflection
726(2)
Applying a method to a sequence
728(3)
When you don't happen to have the right interface
731(2)
Simulating latent typing with adapters
733(4)
Using function objects as strategies
737(6)
Summary: Is casting really so bad?
743(4)
Further reading
746(1)
Arrays
747(44)
Why arrays are special
747(2)
Arrays are first-class objects
749(4)
Returning an array
753(1)
Multidimensional arrays
754(5)
Arrays and generics
759(3)
Creating test data
762(13)
Arrays.fill()
762(1)
Data Generators
763(7)
Creating arrays from Generators
770(5)
Arrays utilities
775(11)
Copying an array
775(2)
Comparing arrays
777(1)
Array element comparisons
778(4)
Sorting an array
782(2)
Searching a sorted array
784(2)
Summary
786(5)
Containers in Depth
791(110)
Full container taxonomy
791(2)
Filling containers
793(16)
A Generator solution
794(2)
Map generators
796(4)
Using Abstract classes
800(9)
Collection functionality
809(4)
Optional operations
813(4)
Unsupported operations
815(2)
List functionality
817(4)
Sets and storage order
821(6)
SortedSet
825(2)
Queues
827(4)
Priority queues
828(1)
Deques
829(2)
Understanding Maps
831(8)
Performance
833(4)
SortedMap
837(1)
LinkedHashMap
838(1)
Hashing and hash codes
839(19)
Understanding hashCode()
843(4)
Hashing for speed
847(4)
Overriding hashCode()
851(7)
Choosing an implementation
858(21)
A performance test framework
859(4)
Choosing between Lists
863(8)
Microbenchmarking dangers
871(1)
Choosing between Sets
872(3)
Choosing between Maps
875(4)
Utilities
879(10)
Sorting and searching Lists
884(1)
Making a Collection or Map unmodifiable
885(2)
Synchronizing a Collection or Map
887(2)
Holding references
889(4)
The WeakHashMap
892(1)
Java 1.0/1.1 containers
893(7)
Vector & Enumeration
894(1)
Hashtable
895(1)
Stack
895(2)
BitSet
897(3)
Summary
900(1)
I/O
901(110)
The File class
901(13)
A directory lister
902(4)
Directory utilities
906(6)
Checking for and creating directories
912(2)
Input and output
914(4)
Types of InputStream
915(2)
Types of OutputStream
917(1)
Adding attributes and useful interfaces
918(4)
Reading from an InputStream with FilterInputStream
919(2)
Writing to an OutputStream with FilterOutputStream
921(1)
Readers & Writers
922(4)
Sources and sinks of data
923(1)
Modifying stream behavior
924(1)
Unchanged classes
925(1)
Off by itself: RandomAccessFile
926(1)
Typical uses of I/O streams
927(9)
Buffered input file
927(1)
Input from memory
928(1)
Formatted memory input
929(1)
Basic file output
930(2)
Storing and recovering data
932(2)
Reading and writing random-access files
934(2)
Piped streams
936(1)
File reading & writing utilities
936(5)
Reading binary files
940(1)
Standard I/O
941(3)
Reading from standard input
941(1)
Changing System.out to a PrintWriter
942(1)
Redirecting standard I/O
942(2)
Process control
944(2)
New I/O
946(27)
Converting data
950(3)
Fetching primitives
953(2)
View buffers
955(5)
Data manipulation with buffers
960(2)
Buffer details
962(4)
Memory-mapped files
966(4)
File locking
970(3)
Compression
973(7)
Simple compression with GZIP
974(1)
Multifile storage with Zip
975(3)
Java ARchives (JARs)
978(2)
Object serialization
980(23)
Finding the class
984(2)
Controlling serialization
986(10)
Using persistence
996(7)
XML
1003(3)
Preferences
1006(2)
Summary
1008(3)
Enumerated Types
1011(48)
Basic enum features
1011(3)
Using static imports with enums
1013(1)
Adding methods to an enum
1014(2)
Overriding enum methods
1015(1)
enums in switch statements
1016(1)
The mystery of values()
1017(3)
Implements, not inherits
1020(1)
Random selection
1021(1)
Using interfaces for organization
1022(6)
Using EnumSet instead of flags
1028(2)
Using EnumMap
1030(2)
Constant-specific methods
1032(15)
Chain of Responsibility with enums
1036(5)
State machines with enums
1041(6)
Multiple dispatching
1047(10)
Dispatching with enums
1050(3)
Using constant-specific methods
1053(2)
Dispatching with EnumMaps
1055(1)
Using a 2-D array
1056(1)
Summary
1057(2)
Annotations
1059(50)
Basic syntax
1060(4)
Defining annotations
1061(2)
Meta-annotations
1063(1)
Writing annotation processors
1064(10)
Annotation elements
1065(1)
Default value constraints
1065(1)
Generating external files
1066(4)
Annotations don't support inheritance
1070(1)
Implementing the processor
1071(3)
Using apt to process annotations
1074(5)
Using the Visitor pattern with apt
1079(4)
Annotation-based unit testing
1083(23)
Using @Unit with generics
1094(1)
No ``suites'' necessary
1095(1)
Implementing @Unit
1096(8)
Removing test code
1104(2)
Summary
1106(3)
Concurrency
1109(194)
The many faces of concurrency
1111(5)
Faster execution
1111(3)
Improving code design
1114(2)
Basic threading
1116(34)
Defining tasks
1116(2)
The Thread class
1118(2)
Using Executors
1120(4)
Producing return values from tasks
1124(2)
Sleeping
1126(1)
Priority
1127(2)
Yielding
1129(1)
Daemon threads
1130(5)
Coding variations
1135(7)
Terminology
1142(1)
Joining a thread
1143(2)
Creating responsive user interfaces
1145(1)
Thread groups
1146(1)
Catching exceptions
1147(3)
Sharing resources
1150(29)
Improperly accessing resources
1150(3)
Resolving shared resource contention
1153(7)
Atomicity and volatility
1160(7)
Atomic classes
1167(2)
Critical sections
1169(6)
Synchronizing on other objects
1175(2)
Thread local storage
1177(2)
Terminating tasks
1179(18)
The ornamental garden
1179(4)
Terminating when blocked
1183(2)
Interruption
1185(9)
Checking for an interrupt
1194(3)
Cooperation between tasks
1197(26)
wait() and notifyAll()
1198(6)
notify() vs. notifyAll()
1204(4)
Producers and consumers
1208(7)
Producer-consumers and queues
1215(6)
Using pipes for I/O between tasks
1221(2)
Deadlock
1223(6)
New library components
1229(24)
CountDownLatch
1230(2)
CyclicBarrier
1232(3)
DelayQueue
1235(4)
Priority BlockingQueue
1239(3)
The greenhouse controller with ScheduledExecutor
1242(4)
Semaphore
1246(4)
Exchanger
1250(3)
Simulation
1253(17)
Bank teller simulation
1253(6)
The restaurant simulation
1259(5)
Distributing work
1264(6)
Performance tuning
1270(25)
Comparing mutex technologies
1271(10)
Lock-free containers
1281(9)
Optimistic locking
1290(2)
ReadWriteLocks
1292(3)
Active objects
1295(5)
Summary
1300(3)
Further reading
1302(1)
Graphical User Interfaces
1303(146)
Applets
1306(1)
Swing basics
1307(4)
A display framework
1310(1)
Making a button
1311(1)
Capturing an event
1312(3)
Text areas
1315(2)
Controlling layout
1317(4)
BorderLayout
1317(1)
FlowLayout
1318(1)
GridLayout
1319(1)
GridBagLayout
1320(1)
Absolute positioning
1320(1)
BoxLayout
1320(1)
The best approach?
1321(1)
The Swing event model
1321(11)
Event and listener types
1322(7)
Tracking multiple events
1329(3)
A selection of Swing components
1332(44)
Buttons
1333(2)
Icons
1335(2)
Tool tips
1337(1)
Text fields
1338(2)
Borders
1340(1)
A mini-editor
1341(1)
Check boxes
1342(2)
Radio buttons
1344(1)
Combo boxes (drop-down lists)
1345(2)
List boxes
1347(2)
Tabbed panes
1349(1)
Message boxes
1350(2)
Menus
1352(7)
Pop-up menus
1359(1)
Drawing
1360(4)
Dialog boxes
1364(4)
File dialogs
1368(2)
HTML on Swing components
1370(1)
Sliders and progress bars
1371(2)
Selecting look & feel
1373(3)
Trees, tables & clipboard
1376(1)
JNLP and Java Web Start
1376(6)
Concurrency & Swing
1382(11)
Long-running tasks
1382(9)
Visual threading
1391(2)
Visual programming and JavaBeans
1393(22)
What is a JavaBean?
1395(2)
Extracting BeanInfo with the Introspector
1397(6)
A more sophisticated Bean
1403(4)
JavaBeans and synchronization
1407(5)
Packaging a Bean
1412(2)
More complex Bean support
1414(1)
More to Beans
1415(1)
Alternatives to Swing
1415(1)
Building Flash Web clients with Flex
1416(14)
Hello, Flex
1416(2)
Compiling MXML
1418(1)
MXML and ActionScript
1419(1)
Containers and controls
1420(2)
Effects and styles
1422(1)
Events
1423(1)
Connecting to Java
1424(3)
Data models and data binding
1427(1)
Building and deploying
1428(2)
Creating SWT applications
1430(17)
Installing SWT
1431(1)
Hello, SWT
1431(3)
Eliminating redundant code
1434(2)
Menus
1436(2)
Tabbed panes, buttons, and events
1438(4)
Graphics
1442(2)
Concurrency in SWT
1444(3)
SWT vs. Swing?
1447(1)
Summary
1447(2)
Resources
1448(1)
A: Supplements
1449(6)
Downloadable supplements
1449(1)
Thinking in C: Foundations for Java
1449(1)
Thinking in Java seminar
1450(1)
Hands-On Java seminar-on-CD
1450(1)
Thinking in Objects seminar
1450(1)
Thinking in Enterprise Java
1451(1)
Thinking in Patterns (with Java)
1452(1)
Thinking in Patterns seminar
1452(1)
Design consulting and reviews
1453(2)
B: Resources
1455(8)
Software
1455(1)
Editors & IDEs
1455(1)
Books
1456(7)
Analysis & design
1457(3)
Python
1460(1)
My own list of books
1460(3)
Index 1463

Excerpts

I originally approached Java as "just another programming language," which in many senses it is. But as time passed and I studied it more deeply, I began to see that the fundamental intent of this language was different from other languages I had seen up to that point. Programming is about managing complexity: the complexity of the problem you want to solve, laid upon the complexity of the machine in which it is solved. Because of this complexity, most of our programming projects fail. And yet, of all the programming languages of which I am aware, almost none have gone all out and decided that theirmaindesign goal would be to conquer the complexity of developing and maintaining programs. 1 Of course, many language design decisions were made with complexity in mind, but at some point there were always other issues that were considered essential to be added into the mix. Inevitably, those other issues are what cause programmers to eventually "hit the wall" with that language. For example, C++ had to be backwards-compatible with C (to allow easy migration for C programmers), as well as efficient. Those are both very useful goals and account for much of the success of C++, but they also expose extra complexity that prevents some projects from being finished (certainly, you can blame programmers and management, but if a language can help by catching your mistakes, why shouldn't it?). As another example, Visual BASIC (VB) was tied to BASIC, which wasn't really designed to be an extensible language, so all the extensions piled upon VB have produced some truly unmaintainable syntax. Perl is backwards-compatible with awk, sed, grep, and other Unix tools it was meant to replace, and as a result it is often accused of producing "write-only code" (that is, after a while you can't read it). On the other hand, C++, VB, Perl, and other languages like Smalltalk hadsomeof their design efforts focused on the issue of complexity and as a result are remarkably successful in solving certain types of problems. What has impressed me most as I have come to understand Java is that somewhere in the mix of Sun's design objectives, it seems that there was a goal of reducing complexityfor the programmer.As if to say, "We care about reducing the time and difficulty of producing robust code." In the early days, this goal resulted in code that didn't run very fast (although this has improved over time), but it has indeed produced amazing reductions in development timehalf or less of the time that it takes to create an equivalent C++ program. This result alone can save incredible amounts of time and money, but Java doesn't stop there. It goes on to wrap many of the complex tasks that have become important, such as multithreading and network programming, in language features or libraries that can at times make those tasks easy. And finally, it tackles some really big complexity problems: cross-platform programs, dynamic code changes, and even security, each of which can fit on your complexity spectrum anywhere from "impediment" to "show-stopper." So despite the performance problems that we've seen, the promise of Java is tremendous: It can make us significantly more productive programmers. In all wayscreating the programs, working in teams, building user interfaces to communicate with the user, running the programs on different types of machines, and easily writing programs that communicate across the InternetJava increases the communication bandwidthbetween people. I think that the results of the communication revolution may not be seen from the effects of moving large quantities of bits around. We shall see the true revolution because we will all communica

Rewards Program

Write a Review