- Taschenbuch: 704 Seiten
- Verlag: Brainysoftware.com; Auflage: 3 (1. September 2011)
- Sprache: Englisch
- ISBN-10: 0980839610
- ISBN-13: 978-0980839616
- Größe und/oder Gewicht: 17,8 x 3,8 x 22,9 cm
- Durchschnittliche Kundenbewertung: 1 Kundenrezension
- Amazon Bestseller-Rang: Nr. 2.944.477 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)
Java 7: A Beginner's Tutorial (Englisch) Taschenbuch – 1. September 2011
|Neu ab||Gebraucht ab|
Es wird kein Kindle Gerät benötigt. Laden Sie eine der kostenlosen Kindle Apps herunter und beginnen Sie, Kindle-Bücher auf Ihrem Smartphone, Tablet und Computer zu lesen.
Geben Sie Ihre Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.
Wenn Sie dieses Produkt verkaufen, möchten Sie über Seller Support Updates vorschlagen?
Über den Autor und weitere Mitwirkende
Budi Kurniawan is a senior architect at BrainySoftware.com and the author ofHow Tomcat Works; Java for the Web with Servlets, JSP, and EJB; andStruts 2 Design and Programming. He has published more than 100 articles and written software licensed by major corporations worldwide. He lives in Montreal, Canada.
Derzeit tritt ein Problem beim Filtern der Rezensionen auf. Bitte versuchen Sie es später noch einmal.
Die hilfreichsten Kundenrezensionen auf Amazon.com
I am a qualified expert to review this book because the cover says "A Beginners Tutorial" and I am a beginner. I wanted to learn Java so I wanted to find an up to date Java 7 book. There are only a few choices of Java 7 books and most of them are not for beginners. None the less I reviewed the table of contents of those available and chose Budi Kurniawan's book as the most complete and most up to date. I have carefully read all 691 pages of text and code and underlined material that I may need to read again or come back to for reference.
This book is an excellent teacher and is very complete. It provides more material than is necessary for a beginner; however the more advanced material is so marked and can be skipped initially.
Contrary to many books and on line advisers I have been using Dr Java as my IDE instead of Net Beans or Eclipse because it does not require you to make package files, jar files or Project files. The capabilities of Net Beans and Eclipse are daunting for the beginner to learn and make use of. With Dr Java you can concentrate on writing and adjusting the basic Java language code.
If you are a beginner or perhaps an intermediate level Java programmer, I strongly recommend this book if you want to learn the latest, Java 7.
While I have done significant dynamic web development, unfortunately peers influenced us to step into the wrong contemporary tools; and now I am seriously re-considering Java as the most appropriate architecture for a project which has met too many dead ends in the usual, purportedly easy frameworks, styled ostensibly to depend upon lesser skill or capability. The reason I targeted this particular book for an initial read (among others I have already purchased), is that I wanted to get my feet wet yet one more time -- this time with very serious interests in capable, robust, efficient, and scalable dynamic web development.
I should mention in regard to this assessment then, that I carry the usual prior experiences forward. I was not so impressed with Java in the past. I can appreciate its present architecture(s) in regard to dynamic web applications, but my eyes roll with every "new" language which resorts to needless syntactical disparities. After 10 years and millions of lines of Delphi, I believe we (all) should still appreciate C++ (or C#) as the archetypical model. When I see deviation from such good things, I have difficulty getting beyond the ever-evident proposition its author(s) have no reasonable appreciation for well-conceived convention. Not a strong selling point. I don't mind writing Object Pascal for example, but even the most seasoned Delphi coder has to wonder why every wannabe new tool would ever depart from syntactical conventions that are so well conceived, efficient, and worthy of standardization. C#, to its credit followed that pattern.
Anyway, I mention these considerations because *they ought* to reflect upon our prospective introduction/re-introduction to Java.
Nonetheless, if we're to break into yet another way of doing things, we have to suffer needless conventional disparities if the authors of the disparities impose them upon us. No problem. Swallow the pill. Accept weakness. Stay strong.
I should also mention then that I realize already that I might only be the most remotely tempted to write client-side Java applications. Being spoiled by Borland C++ (CPPB) and Delphi (which were perhaps the best OOP libraries and IDEs ever), Java -- even so many years afterward -- is a long step downward. So are many other tools. I *do* of course subscribe to the portable assembler (C) concept (which Java approximates in its own way), but to do so with far less than the OOP model introduced by former Borland tools is a giant leap backward for desktop type applications. That understood, now we are on the same page as to what I wanted to glean from reading the object of this review.
So I chose this book, from several candidates, to be a first read for a view of Java *today*; and for the explicit purpose of acquiring a sufficient overall view of where I would have to go to do the kinds of things * want to do.
I should also say that my only initial interest in yet another Java trial stemmed from serious frustrations with the more recent advent of Ruby (and Ruby "developers" [*implementors*]). A kindly IT gent from India steered me back toward Java as the contemporary ideal for dynamic web development. I have rather steep needs, not only in terms of project functionality and processing efficiency, but in probable dependence upon scalability. In any case, the purpose for reading this book was to feel out the whole of prospective alternative architectures, so I could put my hands upon the related technologies and skills I would need for the immediate job at hand.
So the present adventure was just customary practice. A professional approach to divorcing ourselves from the inevitable let-downs which compel us to move to ideal (proper) architectures requires making sure we can cross all the t's and dot all the i's before we jump in, head first.
Any pragmatic Java or OOP initiate would thus have the same goals; yet in regard to these common goals I can say with substantially greater confidence than I could a few days before, that I am now convicted to Java for our immediate project, because its customary patterns substantially resemble the kinds of lower-level capacities professional work depends upon.
End of story.
(It is a regular misconception to presume lower-level OOP tools aren't as "easy" as "higher-level." OOP abstractions handle difficulty as much for lower-level OOP *powers* as they do for the much more *limited* "powers" of higher-level languages. Higher-level equates to forced compliance with often poorly conceived architectural approaches -- and far more difficulty often in deviating from them [as we regularly need].)
For readers nonetheless, I should concede that a person who would rely upon such a book as this cannot well enough appraise its worth until well down the road, beyond the rudimentary training it may or may not provide.
Does it for example gloss too lightly over vital areas of necessary skill?
I may not "know," but I have some ideas it does. For instance, I believe it far too lightly addressed the issues of integrated database systems, if indeed it meant to comprise a tutorial which would provide a sufficiently comprehensive introduction to such skills. Mention is practically non-existent -- much less are we fit then after a "serious" read, to engage immediately in integrating the DBMS functionality that many of us have already so often worked with in so many toolsets. This book leaves both the initiate and seasoned professional (perhaps even moreso the latter), practically clueless. More on this in a moment. But this particular omission (if it is one, in *a tutorial*) is important, because integrated RDBMS is indispensable to virtually every serious project. My expectation or yardstick was that a "tutorial" should get us up to speed on how we're going to work with SQL and inevitable integration of RDBMS.
In fairness nonetheless, the author means to cover this vital topic moreso in his further book, "Servlet and JSP." So far, I am substantially more disappointed with the latter.
These thoughts raised, I still believe (with a Java neophyte's reservations) that the three days I spent reading this beginner's tutorial was worthwhile. I have at this point no better recommendation.
I noted as well, that when I shopped for this first read, that various reviews complained about verbosity, grammatical errors, and so forth.
Get over it. Yes, there are grammatical anomalies, and they should be corrected -- if not moreso for reputation than much else. But live with people who are likely more multi-lingual than we are.
Likewise, Mr. Kurniawan spends sometimes considerable words giving us Java's history for example -- in such ways as many of us might not at first appreciate. But these kinds of inclusions are to be expected in technical works, in which, ostensibly, an author should have a better-rounded concept of scope than his/her reader. Often, deep details are later required. Often seemingly less relevant material increases in importance as experience directs us to revisit material. You must always read for what you need. If the next three paragraphs appear not to be worth a hoot for your immediate purposes, just skip over them. Ditto for technologies or skills you have no use for -- or may never have use for. All such material has to be filtered intelligently. Smart people don't spend days and days and days mastering COM port I/O issues they're never going to depend on. Nor do we complain about the insight into COM we might otherwise depend upon.
I generally judge this book then to be better than many of its reviews might justify. It appears to provide *what seems* to be a generally well-enough-rounded, minimal introduction *to overall Java*.
No one in their right mind would expect it to take us into sufficiently deep water on the further issues of our inevitable specializations. We should expect to rely on more advanced works than tutorials, even to get our feet fully wet.
This tutorial therefore did appear to cover sufficient bases. It gives an overall picture so that we can dive into particular skillsets as needed. That's exactly what I hoped to get from it.
Aside from my disappointments regarding database integration, I generally judge the book deep enough. It is generally quite well written and organized then. I would say, that coupled with the usual bundled Java documentation on language, syntax, frameworks, and so forth, this book is a good place to start.