You have 90 minutes to answer 50 questions. Ready. Set. Go!
Oracle University’s Java SE 17 Developer 1Z0-829 exam has been officially released. It’s time to start thinking about taking this certification exam, which means it’s time to start studying.
Many people ask why someone would bother to take a certification exam like this, particularly if that someone already has a satisfactory job as a working Java programmer. Of course, all the usual arguments apply. Perhaps you can get a better job, whether an internal promotion or elsewhere; or perhaps you could simply use your new certification as leverage for a pay raise.
My own feeling is that the effort of studying the language and its libraries with a view to measuring your skills and knowledge against an external yardstick will inevitably improve your skill set. That effort can be rewarding in its own right, even without getting a new job or increased pay at your current one.
That said, what’s in this exam, and what do you need to think about learning?
The Java 17 exam crams an enormous number of wide-ranging objectives into remarkably few questions—with rather limited time to complete the work. Fifty questions in 90 minutes, in fact. Is that enough time? It is if you know your stuff well and can think fast under pressure, which does sound a bit like the real world of professional programming.
However, 90 minutes certainly doesn’t leave any spare time for idle contemplation. Plan on going in fresh and energetic, and give it all you’ve got; you can relax after you’re done.
Pay attention to the details
The exam’s broad scope and quantity of objectives are addressed by many questions that seem to touch on multiple objectives at once. Because of that complexity, it’s more important than ever to be very attentive to detail.
Sometimes a question that looks absurdly complicated hinges on one simple observation. Spot that one detail, and the answer is immediately clear. Fail to spot it, and you could waste large amounts of time going down blind alleys.
Not all questions fall into this style, however, and sometimes you’ll be pushing the not-quite-two-minutes-per-question boundary to consider all the necessary details.
Here are some specific observations gleaned from those who’ve taken the exam (myself included). These thoughts are, necessarily, somewhat speculative. It’s hard enough to answer the exam questions, and it’s unrealistic to believe that anyone has much mental energy to spare for the task of reporting back on what they saw.
That said, here’s where you might invest your learning efforts.
Library APIs. The 1Z0-829 version of the Java SE exam seems to put a lot of emphasis on library APIs. Questions delve into some of the less-mainstream elements of those APIs. Presumably the idea is to determine whether candidates merely learned the obvious items or spread out their study and were more thorough.
For example, do you know what happens when you perform a binary search on an unsorted list? Be sure to look at all the libraries noted in the exam objectives—including all the methods of those APIs.
Wait! I hear you protest that you can’t learn all the methods, all the arguments, and all the return values of all the library APIs! You’re right, and it would be very inefficient to ask any programmer to learn what’s well documented and easy to look up whenever needed.
Therefore, you should study broad groupings of functionality, and in that way get a feel for the character of the libraries. For example, most methods that take a range will specify that range with the first value and then a fence, that is, the first value to be excluded. Thus, an integer range specified as 1, 11 would represent the values 1 to 10 inclusive. If it’s a floating-point range, it encompasses 1.0 to ten-point-nine-something—but less than 11.
Many libraries exhibit a conceptual consistency; try to find it along with getting a feel for how things work.
New language features. As you would expect, the Java SE 17 exam investigates your knowledge of language features that have been added over the past few years. Those include text blocks, switch expressions and the arrow form of switch, sealed and record types, and pattern matching for instanceof, along with a few other less-prominent features.
Take some time to get familiar with these new features and try out the corner cases. For this kind of thing, you’ll find that writing lots of code will help you become fluent with the feature and its details.
Of course, writing lots of code that exercises new Java functionality will serve you well in your day-to-day programming as soon as your project allows you to use these features. Thus, this is time well spent.
Core language functionality. Don’t forget that you’ll still need to know the core Java language fluently, for example, simple things such as identifier resolution. What happens if you have more than one identifier with the same spelling that might be reached from a particular point in the code? How can you take explicit control of that identifier, perhaps by using this or a class name as a prefix?
What about Java’s argument passing and the consequences of that?
Exception handling, particularly the declaration and catching of checked exceptions, will come up. You’ll need a strong grasp of how Java performs and controls the initialization of classes and objects. If you’re fumbling around having to think very long about these core language elements, you’ll quite likely run out of time.
Other observations
The date/time API that was added at Java 8 is back, and both the serialization feature and the threading APIs seem to have gained more prominence than in previous versions of the exam.
The Java Platform Module System (JPMS) has had varying amounts coverage in the exams since it was released in Java 9, and the current focus seems to have shifted to the migration of projects. Oracle talks about top-down and bottom-up migration styles, and questions about those seem to show up more than questions about the syntax of module-info.java files.
There is plenty of focus on streams and collectors, and even some reports of Spliterator showing up on questions. And, as has been the case for a long time, there’s at least a hint of the internationalization and localization APIs.
Source: oracle.com
Posts
0 comments:
Post a Comment