Product Description

Customer Reviews (18)

Good if you need one of the tricks.
I should preface my review by saying that I generally love the sitepoint books.Simply Javascript (also co-authored by Adams) is hands down the best programming book I've ever read.That said, this book isn't really so much a "book" as it is a "handy reference."If you skim this book and find something you need, then you may be able to justify the cost.As a cover-to-cover read, it's definitely lacking and will leave you wanting.Taken as individual chapters, the writing is excellent and the solutions offer solid coding practices.My recommendation would be to find this book in a bookstore, skim the table of contents and chapters, and see if you will actually use any of the included solutions before you buy.

Just What I Needed
I purchased this book out of desperation after using a 1000 page Javascript Wrox book published in 2000 that was worse than useless. The author's blog posting here is very accurate: it is a modern javascript book that gives usable solutions and concepts that work well. I recommend this book to anyone who has at least some programming background and is sick of cut and pasting garbage code from other mickey mouse tutorial sites that break at the slightest change. It is also a great start for working with AJAX, which is what I needed it for.

That said, the book is surprisingly a great read. I am reading this book cover to cover and also use it as an every day reference with dozens of tips. It is obvious the authors have worked extensively with web sites and write from experience. Thanks for a job well done!

Javascript 4 U
This is an excellent next-step up from an introduction to Javascript and looks at its use in real world situations. You will need to be reasonably fluent in the language to get the best out of it.

The book presents a topic as a question and then presents code to action that query as a solution, then goes through that code in a discussion section. This is where I have a relatively minor criticism of this book; the necessities of discussing the code do not always mesh well with the question and answer format of the layout.

The authors have gone to great effort to ensure that the book is as up-to-date as possible, though this is a rapidly moving target of course, and detail how to ensure that the code will run on as many platforms as possible, rarely giving up and saying 'forget it..', though this proved necessary in a number of the more esoteric options and older browsers.

A highly recommended read if you are looking for a quick solution, or a detailed understanding of what's going on.

The most useful JavaScript book on my shelf
I didn't really think I needed this book -- I have sever other JavaScript books, including the O'Reilly JavaScript Cookbook, and it seemed like this would just be a duplication. But I kept reading really positive reviews of this and other SitePoint books on sites that I trusted, so I decided to take a flier on it.

I'm really glad I did. Unlike some of the O'Reilly books, which are dated at this point, this has really up-to-date, professional code that incorporates best practices. Depending on what kind of JavaScript code base you need to integrate with, you may be able to use this code as-is in many instances. Even if you need to modify it for your own uses, you will never find poorly-organized hackwork here.

Also nice is the up-to-date topic selection. Classics like DOM, form validation, drop-down menus, and cookies are supplemented with topics about accessibility, XMLHttpRequest, in-page dialogs, and using class prototypes. When the authors tell you how to launch popups, they also tell you about all the pitfalls and problems.

No cookbook is going to cover ever possible topic (personally, I would have liked to see JSON examples), but this one is about as complete as you could reasonably ask for. Really, the only downside about this book that I can see is that you need to have at least an intermediate understanding of JavaScript to understand what's going on. There isn't a lot of handholding, and you will likely want to own both a good tutorial and a solid reference on JavaScript and spend some time with them before you're ready for this book. But if you have a good working knowledge of JavaScript and are looking for practical, well-written examples of how to incorporate new techniques into your code, you won't find a better book than this one.

Good and elegant book
It is a good book with useful tips and tricks.
the authors use an elegant way to catch the target.

... Read more

Product Description
If you thought that Java Script is dirty down-to-business language, read this to change your mind. It will not change the way you workIf you know JavaScript and work with it, pick up this terse little gem. It distills the good bits of JavaScript and crystalizes the reasoning behind its redemption in image over the last few years. ... Read more

Product Description

The highly anticipated JavaFX™ technology and platform, including the latest version 1.2 update, is essentially Sun’s approach to Adobe Flash and Microsoft’s emerging Silverlight. JavaFX lets developers play with the open source scripting, desktop, and mobile APIs offered to create dynamic, seamless visual user interfaces (UIs) that are “Flash–like” and beyond…

Learn from bestselling JavaFX author Jim Weaver and expert JavaFX developers Weiqi Gao, Stephen Chin, and Dean Iverson to discover the highly anticipated JavaFX technology and platform that enables developers and designers to create RIAs that can run across diverse devices. Covering the JavaFX Script language, JavaFX Mobile, and development tools, Pro JavaFX™ Platform: Script, Desktop and Mobile RIA with Java™ Technology is the first book tha fully provides JavaFX version 1.2 code examples that cover virtually every language and API feature.

This book contains the following:

• Tutorials that teach JavaFX 1.2 to an application developer or graphics designer who has had no exposure to JavaFX. These tutorials will be exhaustive, covering virtually every facet of JavaFX Script and are fully updated for the JavaFX 1.2 release.
• Reference materials on JavaFX 1.2 that augment what is available from the JavaFX 1.2 Language Reference and API documentation.
• How to take JavaFX 1.2 to other platforms besides the desktop, such as mobile.

Visit projavafx.com for more resources and information from the authors.

What you’ll learn

• Get started with JavaFX Script, including downloading the JavaFX SDK 1.2 and available tools.
• Express user interfaces with declarative scripting.
• Define classes, functions, and attributes.
• Use JavaFX 1.2 and associated tools so that an application developer and a graphics designer can effectively collaborate on an application.
• Uncover the JavaFX 1.2 language and APIs to whatever degree you choose. The tutorials, reference materials, and pointers to resources will be exhaustive.
• Have fun learning JavaFX 1.2 because of the engaging and friendly style in which it is presented in this book.A lot of people have been waiting for a real 1.2 book to buy and this is it!

Customer Reviews (5)

JavaFX Instructional Designer - Sun Microsystems
I learned many details about JavaFX from reading this book. I do work closely with the JavaFX development team, but there are facets to using the JavaFX platform that can only come from end users who are pounding on the code every day. The authors of this book bring their real world examples to their instruction, and they give developers practical information to help them develop with JavaFX. Their expertise spills from the covers of the book--They are all very approachable and willing to answers questions via email and blogs.

They have done a nice job of chunking the material into logical units that progress nicely as you work through each Chapter. The material is ordered from beginning topics to more advanced topics. You can read this book from cover to cover, or you can use it as a quick reference. I'm keeping my copy in my laptop bag so I always have it with me!

Most thorough book on JavaFX
Pro JavaFX Platform is the most thorough book on JavaFX 1.2 to date. I have to admit that the first Chapter was a little daunting like when you are getting ready to get into a cool pool on a hot day.But you know, once you get into the pool, you are glad you did. And I am glad I got past the first chapter.This book is very well written and edited putting the together chapters of four diverse JavaFX experts.

Jim Weaver author and speaker from [...]and author of the first JavaFX book, JavaFX Script: Dynamic Java Scripting for Rich Internet/Client-side Applications is back.

Weigo Gao software engineer with Object Computing Inc, and [...].

Stephen Chin of [...] and founder of the likes of WidgetFx and JavaFXtras, and senior manager of Inovis.

Dean Iverson RIA expert and co founder of Pleasing Software Solutions and now blogging at [...].

This book covers everything from the basics, to using the documentation, to using other libraries, and even mobile device development.My coworkers and I who have been working on a major JavaFX project have used it for reference quite often as it is the most up to date.I particularly like the fact it covers creating and using custom UI components and layout. If you want to go from zero to JavaFX expert or anything in between I recommend you get a hard copy of this book.

Great Comprehensive Reference
The authors of this book have been tracking the bleeding edge of the JavaFX technology from its very inception and along the way have worked closely with us (the JavaFX engineering team) both to understand the technology and give us practical feedback on making it easier to learn and use.This book is everything we'd like our documentation to be: organized, thorough, practical, and easy to read. In fact, I'll be using it as a general reference myself for the areas of JavaFX for which I don't personally work on.

The Definitive Reference for JavaFX
"Pro JavaFX" is a very well-written, detail-oriented, yet approachable read. While learning JavaFX over the past year, mostly from blogs, hearsay, and copious amounts of trial and error, I had a functional, yet "swiss-cheese" understanding of the language. I was effectively a Java programmer writing JavaFX code -- but I wasn't writing idiomatic JavaFX. I wasn't a JavaFX programmer.

PJP answered nearly all of my questions by not only explaining language features and corner cases, but also usually the rationale and implications behind them as well. It made it easy to get excited about the language itself all over again.

For example, take this small code fragment taken from Chapter 7 which will return the number of cells for a given player in a Reversi game (but I don't need to tell you that, because I think the code does a better job):

public bound function getScore(owner:Owner):Integer {
def cells = for (row in board, cell in row.cells where cell == owner) {
cell
}

return cells.size();
}

There's a lot going on here that I like (but not necessarily news): the bound function makes for easy updating of state, and constructing a sequence from a "for" loop almost feels like cheating it's so concise (I think that "return" is optional though).

What's really great though, is JavaFX's "nested" for loops. I find "for (row in board, coll in row.cells where cell == owner)" not only concise, but about as clear as if it were written out in English. PJP is littered with these "idiomatic pearls of wisdom" that helped me realize how Java-centric my JavaFX code was.

The book is a good survey of JavaFX as it exists today (version 1.2). In addition to the language proper, it covers many of the third party libraries (JFXTras, et al.), has a chapter on building a professional RIA book store front type app, and finishes with a solid chapter on JavaFX Mobile.

While readable cover-to-cover, I've found it more valuable as a reference to pick and choose from as needed. For example, today I finally read up on mixins and the different forms of triggers.

I highly recommend this book to anyone interested in JavaFX. It will likely stay on my desk for some time to come.

Everything you need to know about JavaFX 1.2 in one place
Whether you are new to JavaFX or a seasoned Java desktop developer, if you want to get to know JavaFX, then I happily and wholeheartedly recommend the Pro JavaFX Platform book. It is a good book, and it will get you up to speed very quickly. It is based on the latest JavaFX 1.2 release, so you need not worry that you're learning old language and API's.

This book feels like it is primarily targeted towards desktop and rich internet application developers. It contains technical information for developers and designers, and builds a compelling case for choosing JavaFX for web applications and Rich Internet Applications.

Chapter 1, Getting a Jump Start in JavaFX, gives a good introduction to developing applications in the JavaFX language. It brings you up to date on the brief history of JavaFX, and shows you how to get the JavaFX software development kit. It then walks you through the process of compiling and running JavaFX applications, and teaches you a lot about the JavaFX language and API while walking through example application code.

Chapter 2, Taking a Closer Look at the JavaFX Script Language, covers the fundamentals of the JavaFX Script language, including concepts such as variables, primitive types, literal values, and basic operations.JavaFX sequences are introduced in this chapter, along with how to access their members and perform sequence comprehension. By the end of this chapter you have had a comprehensive introduction to the JavaFX Script language.

Chapter 3, Creating a User Interface in JavaFX, associates the metaphor of creating a theatre play with JavaFX development, and discusses creating a stage, a scene, nodes, a model, event handlers, and animating some of the nodes.It then delves into each of these concepts using JavaFX examples, finishing up with a Pong-like game that demonstrates how to detect when nodes in the scene have collided.

Chapter 4, Using Functions, Classes, and Other Advanced Features, discusses how to define functions and classes of your own. It then covers function signatures and function types, and how to write anonymous functions.From there, this chapter introduces how to define class hierarchies, and the covers the details about class types. It also discusses what happens when an object is instantiated and how you can exert control over the process. This is one of the more comprehensive and in-depth chapters within the book, and it will certainly require you to be on your A-game to understand it all. Alternatively, be prepared to re-read this chapter as the need arises.

Chapter 5, Creating Custom UI Components and Charts in JavaFX, explains how to define custom UI components of two fundamentally different types -- custom nodes, and UI controls.After showing you how to create custom nodes in the context of creating a couple of color selection components, it covers how to create UI controls in the context of a stoplight control that has multiple skins.The chapter finishes by teaching you how to use the charting controls to simply and easily create charts in JavaFX.

Chapter 6, Using the Media Classes, explores the capabilities of the JavaFX media classes that make it easy for developers to incorporate playback support for most of the popular formats. This chapter demonstrates how simple it is to include basic media playback support in your JavaFX applications and then shows you how to build more sophisticated playback applications.

Chapter 7, Dynamically Laying Out Nodes in the User Interface, shows how you can leverage the dynamic layout mechanisms of JavaFX to build complicated user interfaces with zero static positioning.These mechanisms include the bind statement, powerful custom layouts built on top of the Panel and Container classes, and the built-in layouts including HBox, VBox, Flow, Tile, and Stack.

Chapter 8, Extending JavaFX with Third-Party Libraries, introduces several of the JavaFX third-party extensions that simplify the development of applications. All of the third-party extensions introduced in this chapter are available as free or open source libraries. This ensures that anyone can make use of these libraries, and also guarantees that you will not be locked into a specific vendor.

Chapter 9, Building a Professional JavaFX Application, shows you some of the professional techniques we use to write real-world JavaFX applications. You will need them when working with a graphic designer, and you will find them useful when you are confronted with the memory usage and performance trade-offs that developers need to consider for real applications. This chapter also provides tips and techniques for enhancing the user's experience.

Chapter 10, Developing JavaFX Mobile Applications, teaches you the basics of JavaFX Mobile development, which will enable you to write portable applications that work on both desktop and mobile devices.During this chapter you'll gain an understanding of the Common Profile, learn how to take advantage of the Java ME capabilities beneath JavaFX Mobile, and adopt JavaFX Mobile best practices that will enable you to write high-performance applications.

The Appendix presents the keywords and the operators of JavaFX Script.Precedence and associativity rules are supplied for the operators.

This book is, I would argue, most relevant for people with previous programming experience. It does not require you to have any previous understanding of JavaFX Script, as it does a very good job of introducing JavaFX Script early in the book. Despite this, if you do come to this book with some knowledge of JavaFX already, the content within this book is very useful to quickly grow your understanding. ... Read more

Product Description

Customer Reviews (14)

Really great book
I've had this book for a few weeks now, and I've really liked it. I was put onto a team using Prototype and Scriptaculous, and needed to get up to speed quickly. The author's style makes it easy to read, and I've really learned a lot. I would consider it sort of a beginner/intermediate level book. But since I hadn't been using either library before, that was perfect for me.

Concise introduction to both frameworks
I'm a Java developer who rarely gets to touch client side code. Recently I was assigned to a project that uses Prototype and I got this book to get me up to speed. It certainly did that and I feel like it's taken me from a beginner Javascript coder to novice. I wish the section on creating my own classes was covered further and there were more examples, but other than that I would recommend this to any of my coworkers.

Christophe Hits a Home Run
If you have some Javascript experience, have hit the cross browser issues, and now are looking for the Prototype and Scriptaculous libraries to take away some of the pain then this is a great book for you.Christophe takes you through the entirety of the API with a very readable book.When a new method is introduced short examples are given that show not only how to use the call but also provide the context of how the functionality might be used in a real world web application.Christophe often explains why a particular technique is needed and explains the cross browser issue that it works around.This book also amazingly teaches some tricky Javascript concepts extremely well.For example, this book has a section explaining binding loss in Javascript that is better than anything I have read anywhere else.Also, Christophe apparently teaches at a University and it shows in the writing style - the end of each chapter has a really nice "what we learned" summary that really wraps things up nicely - if you need quick insight into what a particular piece of the API offers I would recommend heading to these "what we learned" summaries for a quick review.

In summary I recommend this book highly for the Javascripter with a Javascript foundation looking to take things to the next level with Prototype and Scriptaculous.

Excellent Pragmatic Introduction
I set out to read this book from start to finish to understand what the Prototype and Script.aculo.us libraries were about, but before I could I found myself needing to use them, and the book was an extremely useful resource. The book compliments the online resources nicely, explaining not just what to do, but why, and how to do things best. This book does an excellent job of straddling the line between reference and introduction. The writing style is readable enough that you can read a few chapters just to get a sense of what to do, while at the same time, terse enough that you can find what you need quickly. If you are using JavaScript, get this book to help yourself from re-inventing things.

Good reference but not a learning book
I learn best by example, and this book has a but a precious few.Most of the book is a glorified API documentation.I was really looking for a book with a lot of ajax examples ( or even non ajax ones ) but it seems this book does not fit the bill. ... Read more

Product Description
An updated version of Java for C/C++++ Programmers provides enhanced coverage of JavaScript, analyses of all major new APIs, a section on interfacing C and Java applications, expanded coverage of the Java Developers Kit, and new sample applications.Original. (Intermediate)." ... Read more

Customer Reviews (5)

Badly written book - avoid it!
The book was published in January 1998 so it only reflects pre-beta changes. Unfortunately, this can be spotted in both the quality of the text and its reflecting advanced Java 2 things (no mention of Collections etc).It wouldn't alone make a book bad - after all, you should buy for exampleThinking in Java that has a wonderful chapter on Collections -, but the 1.0/ 1.1-specific stuff is also badly explained. Very important C/C++-relatedsubjects are not mentioned: the inherent differences between C/C++'s andJava's static is not even mentioned. Comparing the C++ and Java exceptionlibraries is also painfully missing from the book. And there are a lot ofC++ listings in the book without much help - the authors seem to forgetsometimes that they're working on a book on Java and not on C++.

CoreJava has no C++ in its title, but I still found it at least as useful asthis book when it comes to emphasizing the differences and similaritiesbetween the two languages. Having lost its greatest advantage over CoreJava, the book has nothing to offer for the seasoned programmer. It's weakas a reference, it's even weaker at actually teaching Java in acomprehensible way. C programmers should not try to learn the Java fromthis book - especially not OOP. The book's sections targeted at Cprogrammers don't actually teach how an OOP structure can be translatedinto plain C. C++ programmers may find the book relatively easy tounderstand. Books like Thinking in Java or Core Java are still far morecomprehensible - I don't really think you should present your beginnerreaders complete applications that utilize streams right at the beginning.Let's agree to differ - some readers may find it cool to get complete,non-toy (?) applications - I didn't. Some chapters only have one or two bigexamples (there are - later - chapters that don't have any!) - a lot ofsmall code snippets teach the language far more efficiently than a big one,no matter how complicated and advanced it is.

The comparisons to C andC++ in the first five chapters are overwhelming (still, as was alreadymentioned, some key differences haven't been mentioned); later chaptersdon't compare Java to C(++) any more - they may have been written bydifferent authors.

The book doesn't explain name conventions. Doesn't usethem either. Most classnames begin with lowercase letters - very annoying!Another common mistake is importing the classes used in the same package -especially in the first chapter. As with most Wiley titles, there is nocode highlighting in the book, and the editing is, in general, quite sloppy(quite a few typos, duplicated words etc).

Chapter 1: Introduction toJava: compares almost everything to C/C++. The rest of the chapterdescribes how JDK should be installed and used.

p. 16: "...which iswhy the main function of Source 1.7 only contains the constructor for thebookWindow()"; "once we have added all the components, we can...size the window using either width or height or the pack() methods".The book being written in late 1997, it still refers to classes.zip andCLASSPATH.

Chapter 2: Comparing Java to ANSI C: explains packages,import (also emphasizes the difference between import and #include).Compares keywords, literals, expressions, identifiers etc. between the twolanguages (allowed characters, length etc, but no name conventions).Compares arrays (also mentions reference arrays and their dangerousbehavior) and strings. Even uses PixelGrabber in the examples - very hardto follow for a beginner. Quite interesting examples (Base16 coders etc). Asection about the features removed from C: keywords, global variables,pointers, preprocessor directives, variable arguments (recommends usingVectors instead). The chapter is packed with C examples - sometimes you canfeel it's a C tutorial. Lists the header files of the entire C standardlibrary and shows their Java equivalents: assert -> nothing, ctype ->Character's methods, errno -> Exceptions, float, limits, locale ->i18n, math -> Math's methods; setjmp -> Exception, (p. 92:"since Java provides both exceptions and threads, there is need forsetjmp and longjmp in Java" (that is, no need); signal ->Exception, stdarg -> Vector, stddef, stdio, stdlib, string, time.

Thechapter doesn't try to teach any OOP-related subject.

Chapter 3:Comparing Java to C++: teaches some OOP (why not in the previous chapter,for the C programmers, who really need this introductory stuff?!) - theexplanation is quite abstract and almost useless for a newbie to OOP (lacksalmost everything that makes a good OOP text great). The book uses 'classmethods' when referring to instance methods and static class methods whenreferring to static methods - very annoying for people that are used to theright terminology. Mentioned the difference between C++ and Java when itcomes to initializing static class members.

The explicit super()explanation is OK, but the book never mentions the difference between Javaand C++ in the usage of this() in the constructor (shows it in Java butdoesn't mention it doesn't exist in C++).

Compares Java's clone() toC++'s copy constructor - just so as a decent Java book should introduce thesubject. I find Core Java's or Thinking in Java's discussion much better,though. And most beginner C++ books do much better work at explaining whyexplicit copy constructors are needed.

Shows the syntactic differencebetween C++ and Java inheritance (while making a mistake in the table: asuperfluous colon). Also shows abstract (pure virtual) methods: source3.13, which comes right after this, has the main class drawShapes (yes,wrong capitalization) using AWT and the drawing methods of Graphics. As alot of C++ books are showing examples of just this Shape <- Square /Triangle / Hexagon relationship with an abstract calculatePoints() in thesuperclass to make readers understand how overriding and dynamic methoddispatch works, I expected this book the same: an example that has an arrayof type Shape containing elements of the above-mentioned subclasses,getting these elements out the array and calling calculatePoints() on themto see whether dynamic dispatch really works. Unfortunately, the authorshave missed this chance to really show the readers how runtime bindingworks - you have to choose from the menu which shape to draw and voila - itgets drawn. No reference arrays of type superclass, nothing. The very nextexample does just this with a much less interesting example (actually, it'sjust another toy example).

Touches on exceptions, shows the differencebetween C++'s catchall- that is, catch (...) - and Java's catch(Exception). The C++ example here is again a very bulky one, it is onlyincluded here to show that in C++ you don't have to declare what kind ofexceptions will be thrown out of any methods. Doesn't draw a line betweenunchecked and checked exceptions - it only happens later. Some severeerrors are made:

"classes derived from the Exception class fall intothe category of errors that can be recovered from, whereas classes derivedfrom the RuntimeException generally cannot be recovered from" - thisis not the only point where the readers show they confuse the subclasses ofError for the children of RuntimeException. It is a very severeerror.

The chapter also discusses inner classes - quite brightly. I stillmiss the explanation of static member classes - the authors only devotedone sentence to them.

Also presents the C++ Standard Library (thecomparison takes some 3 pages).

Chapter 4: Language features not in C orC++: discusses packages, interfaces (doesn't show how they can be used astypes / for callback), dynamic type inquiries (Class.forName() etc. - thissub-chapter should have been put in Chapter 6 entirely) and threads.

This sub-chapter is quite weak: there is no wait/notify (not in theentire book, actually); doesn't try to explain what the difference betweenimplementing Runnable and extending Thread is; doesn't try to explain whysome methods got deprecated and has errors like the following: p.195:"the Runnable interface is simply implementing the run method".

Chapter 5: JNI; 17 pages;

Chapter 6: The Java Language Classes andReflection: there is a severe error in the title, as it refers to java.langand definitely not all classes of the language. Discusses wrapper classes(doesn't mention they're immutable; doesn't show which of them wereintroduced only in 1.1; and suggests only Integer and Long haveparse methods), standard input/output/error (no info onactually redirecting them - another 1.1 issue), the Thread class(absolutely useless, as it doesn't have any new information - the toyexample only creates a thread and doesn't do any sophisticated work); itlists the most important Error, Exception (and RuntimeException) classes -I found this quite useless. Again, it confuses the subclasses of Error forthe children of RuntimeException: p. 258: " RuntimeException: ...these exceptions can be common (like running out of memory)...

Useful Java material, but...
I found the Java material quite useful and informative, however, I bought this book in March of 1998, when JDK 1.2 was not even released!!! So this mystery vexes me a lot!It seems the authors are trying to jump on thepublication frenzy and bandwagon.The Java stuff in there is good, I justquestion the accuracy of it all.

Pretty good for cross-platform languages
This book is pretty good in the way it tries to relate Java with C and C++. Though, I really don't think this book is for beginners of the C/C++ language. As an afterthought, I think this book has good info for anyonewho is cross-platforming between C++ and Java.

Good for Java, not so good for JavaScript
I originally bought this book for JavaScript.I found that its main focus, however, is Java.It has lots of useful information about Java and in that respect I found it useful.I have found it a good companion bookto the "Java Master Reference".If you are looking for detailedinformation on JavaScript, don't buy this book, instead get the JavaScriptBible.

Not bad, but certainly not stellar
The book does a noble attempt at covering all there is about Java 1.2 along with C/C++. The problem is that this selection will definitely not serve as a reference book. There are no API details; only descriptions covering general usage. Along with clear (but useless) examples, you can pick up the details of the functions and their usage. I assume the authors believe you're not too lazy to go through the java docs. Unfortunately, I am lazy. Fortunately, I already know java, and I read this book to collect tidbits on things I may not know about. It DOES cover just about everything from AWT to beans to JFC to security, etc. I recommend this book only if you have additional sources with detailed API usage, and it would definitely help if you know java already (even 1.0). ... Read more

Product Description
"A must read!"-Information Week, from a review of Java for C/C++ Programmers

The quickest, easiest way for C and C++ programmers to learn how to build full-scale applications using Java(TM) and JavaScript(TM)

Java 2 and JavaScript for C and C++ Programmers

Featuring the rapid skill-building format that made its predecessor such a huge critical success, this powerful book/CD package gets you up to speed on all of Java 2's and JavaScript's features, in no time. Using a series of increasingly sophisticated working applications, it explains basic and advanced Java techniques in terms that C and C++ programmers can relate to.

This revised edition includes updated coverage of:
* JavaBean(TM)
* JFCs p9e RMI
* Security
* JDBC(TM)

It also covers all new features found in Java 2, including:
* Protected domains
* Reference objects
* Collections
* Package versions
* Drag and drop

On the CD-ROM you'll find:
* All the source code from the examples in the book
* Loads of useful scripts and utilities-ready-to-run Java documentation
* Java Multimedia demo
* Three additional "bonus" chapters ... Read more

Customer Reviews (8)

Not effective at leveraging my knowledge of C++
As a very experienced programmer I was hoping this book could leverage my knowledge of C++ to quickly teach me what is new or different in Java.Instead this huge book takes a very long time to teach the simplest concepts.It did explain most Java concepts in terms of their C and C++ counterparts, but it also took the time to explain how things work in C/C++ in way too much detail before comparing it to Java.I wanted to say to the author, "I already know C++. That's why I bought this book. Skip this C/C++ lesson and get to the Java".The even bigger frustration I had was this book assumed you knew some C but didn't assume you know C++ at all.It took the time to introduce concepts like Objects and polymorphism and explained the C programmers what a class is in case they never used C++.

If you already know C++ this book won't really help you any more than any standard Java book.Skip this one and find a highly reviewer Java book or just sticks to Sun's online reference.

Please ignore my review below
In the meantime, I've scrutinized the book more thoroughly. I've written the 1st review after comparing moslty the I/O and AWT chapters, the two being the worst of most Java books (and these two chapters are still asworse as they were in the 1998, Java 1.2 edition). As these chapters weresimilar to the previous edition, I thought the entire book is just a rehashtoo. However, other chapters are really updated, which I will also writeabout in the next review to be posted soon.

Werner Zsolt.

Mediocre Introduction to Language
I wanted a book that for an experienced C++ programmer that would not waste time teaching me what a class is, etc.It did that, but unfortunately covers waaaay to much ground to be really practical to learnhow to actually write code without additional reference material.

Thereare long coding examples presented with little explanation, which thereader is expected to spend hours deciphering and then say "voila,that's how it works."

Major concepts lacking.For e.g, nowherecould I find an explanation of when you have to use "throws" in adeclaration.

The index is a joke.Try to look up Vector, implements,throws, Set...not there!

Overall, very dissapointing and flawed.
Although slightly thought provoking in its tactics, the main theses were misconstrued.There were many instances of erroneous teaching methods which led to unfavorable results.This book does have its bright sides,mainly pertaining to general layout of the book.The relation ofJavascriptto C++ makes the book very difficult to comprehend.Overall,as a Javascript programmer, I would not recommend this book toanyone.

Almost the same as the 1.2 ed - useless for a beginner
Read what I wrote about the previous, 1.2 edition here on Amazon. The book has not been changed much - it just has a new cover.

What is missing from my review (the 1000-word limit has cut out the last 3000 words) is that thebook is definitely NOT suited for a beginner. Just an example> check outthe I/O and the AWT chapters. No beginner will understand them - even bookslike Lemay's Teach Yourself Java 2 in 21 Days are much morecomprehensible.

You can buy this book if you already know the languageand are eager to discover the differences between C++ and Java (too badonly the first 4 chapters emphasize them, the other chapters spend NO wordson C++ at all), you can give it a try. Or just get the previous (and,therefore, cheaper) edition, as it's alsmost the same as this one... ... Read more