• Post Reply Bookmark Topic Watch Topic
  • New Topic
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator

Image from Amazon
Title: Practice your Java Level 1: 1000+ Solved Exercises
Author(s): Ayo Agboola
Publisher: Plurium Press
Category: Java

Amazon wrote:Practice Your Java Level 1 is a unique Java volume targeted at those seeking to be effective and savvy Java developers. The 1000+ solved exercises in this volume are designed to help the beginning Java developer quickly achieve the following four goals: a proper understanding of the foundations of this language, high retention of the knowledge learned, solid Java programming skills and confidence in their ability both to produce usable Java programs at this level and to pursue higher levels of study of this language.


Book Preview (when available)



From the publisher


Where to get it?
  • Amazon.com
  • Plurium Press



  • Related Websites
  • Table of Contents
  • COMMENTS:
     
    Jeanne Boyarsky
    author & internet detective
    Marshal
    Posts: 37462
    537
    Eclipse IDE Java VI Editor
    • Mark post as helpful
    • send pies
    • Quote
    • Report post to moderator
    “Practice your Java” is an interesting concept. It is meant to supplement an intro to Java book or be used to provide review/practice for a class.

    There are different types of exercises including reading/describing code, writing code and predicting the output. I felt like there was a good rhythm  of reading a question, thinking about the answer and reading the explanation. The exercises drawing patterns with loops were fun. I liked the emphasis on BigInteger and BigDecimal. A lot of books lack that. And I got to learn some new APIs that I don't use.

    I wish there had been more highlighting/formatting/indenting to differentiate questions from answers. I got used to it, but it was a little jarring at first. There were also some page breaks in odd places. I like that the author underlined key words and warnings.

    The author consistently put return values in parens. I've never seen people code that way in Java before. I feel like the book is implying this is good/common practice. I also caught some errata; these are supposed to be listed on the book page in the future. There were also a couple off choices like showing contentEquals() instead of equals() on String. It works, but far less common and doesn't describe why.

    Overall, I think you are going to love or hate this book. Kind of like “Head First Java” - the book is great if you like the style and horrible if you don't like the style. If you aren't using this with a school course, I think a challenge would be mapping the chapters to the order you are learning in your other book.

    I give this book 6 out of 10 horseshoes.

    Disclosure: I received a review copy of this book from the publisher for reviewing it on behalf of CodeRanch.
     
    Campbell Ritchie
    Marshal
    Posts: 56518
    172
    • Mark post as helpful
    • send pies
    • Quote
    • Report post to moderator
    My, he has put a lot of work into this book, and covered a lot of ground. It mostly comprises little challenges, often with a hint about which method to use to solve them. Each is followed immediately by a suggested solution for the reader to inspect. The challenges assume some knowledge of Java®, and the book is not a tutorial, nor is it suitable for beginners. Most of the book has very little explanation, but there are longer more discursive sections about object, interfaces, etc. These descriptions though brief are good. Those examples show well‑encapsulated objects from classes written from well‑written object‑oriented classes. As in many books, the examples simply showing a piece of code put it into the main method.

    This book is probably intended for somebody with a bit of experience wishing to brush up their skills, maybe for an exam or an interview. The range of the topics includes collections, generics, GUIs, and file handling with NIO. It will be necessary to refer to other sources of information, for example the API documentation, alongside the exercises, to understand the code fully. I learnt lots I didn't already know particularly in the sections about NIO and use of the obscurer methods of the Collections class, and “unsigned” arithmetic. I was pleased to see a good coverage of BigDecimal and warnings about the precision of double arithmetic. I was also please to see NIO described, almost without mention of the older file handling classes. Other features were not quite as up to date. Although the importance of closing file readers and writers was stressed, neither finally nor try‑with‑resources was shown. Although there is a good description of nested classes including anonymous classes, λ expressions don't appear. Nor does the newer Stream API, which was two years old before this book was written. I have long ago stopped believing that Streams are an advanced topic, so I was disappointed not to see more than a passing mention of Streams.

    Don't try to read through this book; it is not designed for reading page by page. Read each question and attempt it without reading the answer. This is unfortunately easier said than done, because the questions and answers are adjacent to each other. Cover the page with a piece of paper until you have finished the coding, and then look at the answers. That won't be easy with a Kindle version. Only try two or three pages at a time.

    Unfortunately, many examples show what I would not regard as best practice. The character \n is used frequently, even after printf. It says one must close Scanners pointing to System.in. Indentation, formatting, and placement of {} in the code are inconsistent: sometimes in K&R style, sometimes in Allman style, and sometimes a method is compressed onto a single line. Two examples show two Iterators in scope simultaneously. Boolean variables are often followed by == true or == false. Pages 180‑181 are confused about whether private fields are inherited. There is an incorrect implementation of the “singleton pattern” on page 192. The depiction of catch blocks is inconsistent; they are sometimes shown empty. Page 293 uses GridBagLayout without a constraints object.

    Some of the explanations are less than clear. Page 3 says that the only modifier permitted for the main method is static. Page 29 calls += a shorthand operator, and fails to mention the implicit cast if the left operand is “narrower” than 32 bits. Page 30 calls Math.addExact a keyword. In a few places two terms seem to have been swapped, for example the names of \ and / on page 249. Page 291 says BorderLayout is the default layout, without further explanation.

    Why is there a chapter about Applets? They are surely obsolete. Why are there chapters about bytes and shorts? Does anybody use bytes and shorts apart from byte[]s? Why is the chapter about Swing so short? Omitting bytes shorts and Applets would have allowed more space for Swing, or a chapter about Streams. And more details about Exceptions, e.g. Exception chaining, would have been welcome.
     * * * * * *
    Unfortunately the book reads as if it had been printed without going through a review process. It is full of misspellings, the most frequent being practice. Some of the misspellings extend into the code. A few solutions will probably fail to compile without modification, and No 3 on page 291 uses the wrong method name. The pagination is inconsistent. Some questions and examples straddle page boundaries, and are difficult to read. Some occupy the full page width and some only part of its width. This book would have benefited greatly from a technical review and proofing, which would doubtless have corrected those problems. I am sure I would give a second edition with those shortcomings corrected a much better review and a much higher mark. I failed to find its errata on the publisher's website.

    I give this book 5 out of 10 horseshoes.
     * * * * * *
    Disclaimer: I was given a Kindle copy of this book free of charge to review it. That was awkward to read because the book won't open on the ordinary Kindle Cloud Reader. Also, unlike with a .pdf eBook, it is not possible to copy‑and‑paste code from a Kindle Reader so as to compile and test it for oneself.
     
    Vijitha Kumara
    Bartender
    Posts: 4001
    42
    Chrome Fedora Hibernate
    • Mark post as helpful
    • send pies
    • Quote
    • Report post to moderator
    The book is based on a question/answer type model where the author tries to introduce the concepts in the form of an exercise and then provide a solution (or a tip to solve the problem) for the same.

    The book is targeted mainly for beginner and intermediate levels where the author tries to get in to more wider usage of the chosen topics. Book covers some of the fundamental concepts of Java programming such as different primitives, looping/iteration, Date/Time handling, Input/Output, Swing etc... including some not so widely seen APIs in detail. I like the idea of trying to explain the terms with simple and minimum set of code.

    Some theoretical facts could have been explored in much better ways I thought, as some of the explanations might get a novice readers confused or may need to consult JLS (or a similar source) for further understanding. I found some compilations issues with given code samples where you may need to do some adjustments to make it work. Also there were mismatches between the explanations and the actual code being given.

    What I felt about the book in general is that this doesn't seems to have gone through a review process (technically as well as in general). Overall it needs more improvements to the content.


    I give this book 5 out of 10 horseshoes.

    Disclosure: I received a review copy (Kindle version) of this book from the publisher for reviewing it on behalf of CodeRanch.

     
    It is sorta covered in the JavaRanch Style Guide.
    • Post Reply Bookmark Topic Watch Topic
    • New Topic
    Boost this thread!