- •Contents at a Glance
- •Contents
- •About the Authors
- •About the Technical Reviewer
- •Acknowledgments
- •Introduction
- •Oracle Java Certifications: Overview
- •FAQ 1. What are the different levels of Oracle Java certification exams?
- •FAQ 4. Is OCPJP 7 prerequisite for other Oracle certification exams?
- •FAQ 5. Should I take the OCPJP 7 or OCPJP 6 exam?
- •The OCPJP 7 Exam
- •FAQ 7. How many questions are there in the OCPJP 7 exam?
- •FAQ 8. What is the duration of the OCPJP 7 exam?
- •FAQ 9. What is the cost of the OCPJP 7 exam?
- •FAQ 10. What are the passing scores for the OCPJP 7 exam?
- •FAQ 11. What kinds of questions are asked in the OCPJP 7 exam?
- •FAQ 12. What does the OCPJP 7 exam test for?
- •FAQ 13. I’ve been a Java programmer for last five years. Do I have to prepare for the OCPJP 7 exam?
- •FAQ 14. How do I prepare for the OCPJP 7 exam?
- •FAQ 15. How do I know when I’m ready to take the OCPJP 7 exam?
- •Taking the OCPJP 7 Exam
- •FAQ 16. What are my options to register for the exam?
- •FAQ 17. How do I register for the exam, schedule a day and time for taking the exam, and appear for the exam?
- •The OCPJP 7 Exam: Pretest
- •Answers with Explanations
- •Post-Pretest Evaluation
- •Essentials of OOP
- •FunPaint Application: An Example
- •Foundations of OOP
- •Abstraction
- •Encapsulation
- •Inheritance
- •Polymorphism
- •Class Fundamentals
- •Object Creation
- •Constructors
- •Access Modifiers
- •Public Access Modifier
- •Private Access Modifier
- •Protected and Default Access Modifier
- •Overloading
- •Method Overloading
- •Constructor Overloading
- •Overload resolution
- •Points to Remember
- •Inheritance
- •Runtime Polymorphism
- •An Example
- •Overriding Issues
- •Overriding: Deeper Dive
- •Invoking Superclass Methods
- •Type Conversions
- •Upcasts and Downcasts
- •Casting Between Inconvertible Types
- •Using “instanceof” for Safe Downcasts
- •Java Packages
- •Working with Packages
- •Static Import
- •Summary
- •Abstract Classes
- •Points to Remember
- •Using the “final” Keyword
- •Final Classes
- •Final Methods and Variables
- •Points to Remember
- •Using the “static” Keyword
- •Static Block
- •Points to Remember
- •Flavors of Nested Classes
- •Static Nested Classes (or Interfaces)
- •Points to Remember
- •Inner Classes
- •Points to Remember
- •Local Inner Classes
- •Points to Remember
- •Anonymous Inner Classes
- •Points to Remember
- •Enum Data Types
- •Points to Remember
- •Summary
- •Interfaces
- •Declaring and Using Interfaces
- •Points to Remember
- •Abstract Classes vs. Interfaces
- •Choosing Between an Abstract Class and an Interface
- •Object Composition
- •Composition vs. Inheritance
- •Points to Remember
- •Design Patterns
- •The Singleton Design Pattern
- •Ensuring That Your Singleton Is Indeed a Singleton
- •The Factory Design Pattern
- •Differences Between Factory and Abstract Factory Design Patterns
- •The Data Access Object (DAO) Design Pattern
- •Points to Remember
- •Summary
- •Generics
- •Using Object Type and Type Safety
- •Using the Object Class vs. Generics
- •Container Implementation Using the Object Class
- •Container Implementation Using Generics
- •Creating Generic Classes
- •Diamond Syntax
- •Interoperability of Raw Types and Generic Types
- •Generic Methods
- •Generics and Subtyping
- •Wildcard Parameters
- •Limitations of Wildcards
- •Bounded Wildcards
- •Wildcards in the Collections Class
- •Points to Remember
- •The Collections Framework
- •Why Reusable Classes?
- •Basic Components of the Collections Framework
- •Abstract Classes and Interfaces
- •Concrete Classes
- •List Classes
- •ArrayList Class
- •The ListIterator Interface
- •The LinkedList Class
- •The Set Interface
- •The HashSet Class
- •The TreeSet Class
- •The Map Interface
- •The HashMap Class
- •Overriding the hashCode() Method
- •The NavigableMap Interface
- •The Queue Interface
- •The Deque Interface
- •Comparable and Comparator Interfaces
- •Algorithms (Collections Class)
- •The Arrays Class
- •Methods in the Arrays Class
- •Array as a List
- •Points to Remember
- •Summary
- •Generics
- •Collections Framework
- •Processing Strings
- •String Searching
- •The IndexOf() Method
- •The regionMatches() Method
- •String Parsing
- •String Conversions
- •The Split() Method
- •Regular Expressions
- •Understanding regex Symbols
- •Regex Support in Java
- •Searching and Parsing with regex
- •Replacing Strings with regex
- •String Formatting
- •Format Specifiers
- •Points to Remember
- •Summary
- •Reading and Writing from Console
- •Understanding the Console Class
- •Formatted I/O with the Console Class
- •Special Character Handling in the Console Class
- •Using Streams to Read and Write Files
- •Character Streams and Byte Streams
- •Character Streams
- •Reading Text Files
- •Reading and Writing Text Files
- •“Tokenizing” Text
- •Byte Streams
- •Reading a Byte Stream
- •Data Streams
- •Writing to and Reading from Object Streams: Serialization
- •Serialization: Some More Details
- •Points to Remember
- •Summary
- •A Quick History of I/O APIs
- •Using the Path Interface
- •Getting Path Information
- •Comparing Two Paths
- •Using the Files Class
- •Checking File Properties and Metadata
- •Copying a File
- •Moving a File
- •Deleting a File
- •Walking a File Tree
- •Revisiting File Copy
- •Finding a File
- •Watching a Directory for Changes
- •Points to Remember
- •Summary
- •Introduction to JDBC
- •The Architecture of JDBC
- •Two-Tier and Three-Tier JDBC Architecture
- •Types of JDBC Drivers
- •Setting Up the Database
- •Connecting to a Database Using a JDBC Driver
- •The Connection Interface
- •Connecting to the Database
- •Statement
- •ResultSet
- •Querying the Database
- •Updating the Database
- •Getting the Database Metadata
- •Points to Remember
- •Querying and Updating the Database
- •Performing Transactions
- •Rolling Back Database Operations
- •The RowSet Interface
- •Points to Remember
- •Summary
- •Define the Layout of the JDBC API
- •Connect to a Database by Using a JDBC driver
- •Update and Query a Database
- •Customize the Transaction Behavior of JDBC and Commit Transactions
- •Use the JDBC 4.1 RowSetProvider, RowSetFactory, and RowSet Interfaces
- •Introduction to Exception Handling
- •Throwing Exceptions
- •Unhandled Exceptions
- •Try and Catch Statements
- •Programmatically Accessing the Stack Trace
- •Multiple Catch Blocks
- •Multi-Catch Blocks
- •General Catch Handlers
- •Finally Blocks
- •Points to Remember
- •Try-with-Resources
- •Closing Multiple Resources
- •Points to Remember
- •Exception Types
- •The Exception Class
- •The RuntimeException Class
- •The Error Class
- •The Throws Clause
- •Method Overriding and the Throws Clause
- •Points to Remember
- •Custom Exceptions
- •Assertions
- •Assert Statement
- •How Not to Use Asserts
- •Summary
- •Introduction
- •Locales
- •The Locale Class
- •Getting Locale Details
- •Resource Bundles
- •Using PropertyResourceBundle
- •Using ListResourceBundle
- •Loading a Resource Bundle
- •Naming Convention for Resource Bundles
- •Formatting for Local Culture
- •The NumberFormat Class
- •The Currency Class
- •The DateFormat Class
- •The SimpleDateFormat Class
- •Points to Remember
- •Summary
- •Introduction to Concurrent Programming
- •Important Threading-Related Methods
- •Creating Threads
- •Extending the Thread Class
- •Implementing the Runnable Interface
- •The Start( ) and Run( ) Methods
- •Thread Name, Priority, and Group
- •Using the Thread.sleep() Method
- •Using Thread’s Join Method
- •Asynchronous Execution
- •The States of a Thread
- •Two States in “Runnable” State
- •Concurrent Access Problems
- •Data Races
- •Thread Synchronization
- •Synchronized Blocks
- •Synchronized Methods
- •Synchronized Blocks vs. Synchronized Methods
- •Deadlocks
- •Other Threading Problems
- •Livelocks
- •Lock Starvation
- •The Wait/Notify Mechanism
- •Let’s Solve a Problem
- •More Thread States
- •timed_waiting and blocked States
- •waiting State
- •Using Thread.State enum
- •Understanding IllegalThreadStateException
- •Summary
- •Using java.util.concurrent Collections
- •Semaphore
- •CountDownLatch
- •Exchanger
- •CyclicBarrier
- •Phaser
- •Concurrent Collections
- •Apply Atomic Variables and Locks
- •Atomic Variables
- •Locks
- •Conditions
- •Multiple Conditions on a Lock
- •Use Executors and ThreadPools
- •Executor
- •Callable, Executors, ExecutorService, ThreadPool, and Future
- •ThreadFactory
- •The ThreadLocalRandom Class
- •TimeUnit Enumeration
- •Use the Parallel Fork/Join Framework
- •Useful Classes of the Fork/Join Framework
- •Using the Fork/Join Framework
- •Points to Remember
- •Summary
- •Using java.util.concurrent Collections
- •Applying Atomic Variables and Locks
- •Using Executors and ThreadPools
- •Using the Parallel Fork/Join Framework
- •Chapter 3: Java Class Design
- •Chapter 4: Advanced Class Design
- •Chapter 5: Object-Oriented Design Principles
- •Chapter 6: Generics and Collections
- •Chapter 7: String Processing
- •Chapter 8: Java I/O Fundamentals
- •Chapter 9: Java File I/O (NIO.2)
- •Chapter 10: Building Database Applications with JDBC
- •Chapter 11: Exceptions and Assertions
- •Chapter 12: Localization
- •Chapter 13: Threads
- •Chapter 14: Concurrency
- •OCPJP7 Exam (1Z0-804 a.k.a. Java SE 7 Programmer II) Topics
- •OCPJP 7 Exam (1Z0-805, a.k.a. Upgrade to Java SE 7 Programmer) Topics
- •Answers and Explanations
- •Answer Sheet
- •Answers and Explanations
- •Index
Chapter 1 ■The OCPJP 7 Exam: FAQ
Table 1-3. Comparison of the Oracle Exams Leading to OCPJP 6 and OCPJP 7 Certification
|
|
|
Exam Number |
1Z0-851 |
1Z0-804 |
Expertise Level |
Beginner to intermediate |
Intermediate |
Pre-requisite |
None |
OCAJP7 |
Certification |
|
|
Exam Name |
Java SE 6 Programmer |
Java SE 7 Programmer II |
Associated |
Oracle Certified Professional, Java SE 6 |
Oracle Certified Professional, Java SE 7 |
Certification |
Programmer (OCPJP 6) |
Programmer (OCPJP 7) |
Exam Duration |
2 hrs 30 minutes (150 mins) |
2 hrs 30 minutes (150 mins) |
Number of |
60 Questions |
90 Questions |
Questions |
|
|
Pass Percentage |
61% |
65% |
Cost |
~ USD 300 |
~ USD 300 |
Exam Release Status |
Released |
Released |
Exam Topics |
Declarations, Initialization, and Scoping |
Java Class Design |
|
Flow Control |
Advanced Class Design |
|
API Contents |
Object-Oriented Design Principles |
|
Concurrency |
Generics and Collections |
|
OO Concepts |
String Processing |
|
Collections/Generics |
Exceptions and Assertions |
|
Fundamentals |
Java I/O Fundamentals |
|
|
Java File I/O (NIO.2) |
|
|
Building Database Applications with JDBC |
|
|
Threads |
|
|
Concurrency |
|
|
Localization |
|
|
|
The OCPJP 7 Exam
FAQ 7. How many questions are there in the OCPJP 7 exam?
In both the 1Z0-804 and 1Z0-805 versions of the OCPJP 7 exam, there are 90 questions.
FAQ 8. What is the duration of the OCPJP 7 exam?
The 1Z0-804 and 1Z0-805 versions of the OCPJP 7 exam last 150 and 180 minutes respectively (2 hours 30 minutes, and 3 hours).
5
Chapter 1 ■the OCpJp 7 exam: FaQ
FAQ 9. What is the cost of the OCPJP 7 exam?
The cost of the 1Z0-804 and 1Z0-805 versions of the OCPJP 7 exam is the same, but that cost varies according to the currency of the country in which you take the exam: currently $300 in US, £202 in UK, Rs. 8,500 in India, €238 in Eurozone countries, and so on. (The cost of the exam is shown on the Oracle web site in the viewer’s local currency.)
FAQ 10. What are the passing scores for the OCPJP 7 exam?
The passing scores for the 1Z0-804 and 1Z0-805 versions of the OCPJP 7 exam are 65% and 60%, respectively. (There are no negative marks for wrong answers.)
FAQ 11. What kinds of questions are asked in the OCPJP 7 exam?
Some questions on the OCPJP 7 exam test your conceptual knowledge without reference to a specific program or code segment. But most of the questions are programming questions of the following types:
•Given a program or code segment, what is the output or expected behavior?
•Which option(s) would compile without errors or give the desired output?
•Which option(s) constitute the correct usage of a given API (in particular, newly introduced APIs such as those associated with new classes of JDBC)?
All questions are multiple-choice. Most of them present four or five options, but some have six or seven options. Many questions are designed to have a set of multiple correct answers. Such questions are clearly flagged (usually at the left top corner in the exam test screen) with the number of options you need to select.
Exam questions are not constrained to be exclusively from the topics on the exam syllabus. You might, for example, get questions on Java fundamentals (a topic in OCAJP syllabus) concerning the basics of exception handling and using wrapper types. You might also get questions on topics related to those on the exam syllabus but not specified in it. For example, serialization and use of the transient keyword are not explicitly mentioned in the OCPJP exam syllabus, but they can come up in the actual exam because they are related to reading and writing streams—and one of these is ObjectStreams, which relates to serialization!
A given question is not constrained to test only one topic. Some questions are designed to test multiple topics with a single question. For instance, you may find a question testing the concepts of threads and inner classes as they relate to each other.
FAQ 12. What does the OCPJP 7 exam test for?
The OCPJP 7 exam tests your understanding of the Java language features and APIs that are essential for developing real-world programs. The exam focuses on the following areas:
•Language concepts that are useful for problem solving: The exam tests not only your knowledge of how language features work, but also covers your grasp of the nitty-gritty and corner cases of language features. For example, you need to understand not only the generics feature in Java but also problems associated with type-erasure, mixing legacy containers with generic containers, and so on.
•Java APIs: The exam tests your familiarity with using the Java class library, as well as such unusual aspects or corner cases, such as the following:
•What does the remove() method of Deque do? (Answer: It removes the first element from the underlying deque instance).
6
Chapter 1 ■The OCPJP 7 Exam: FAQ
•What will happen if sleep() method is interrupted? (Answer: You’ll get an
InterrputedException).
•Underlying concepts: For example, the exam might test your understanding of how serialization works, the differences between overloading and overriding, how autoboxing and unboxing work in relation to generics, the different kinds of drivers in JDBC, how multithreaded programming is platform-dependent, the different kinds of liveness problems with threads, etc.
Although the exam does not test memory skills, some questions presume rote knowledge of key elements, such as the following:
•Letters used for creating custom date and time formats (“string patterns”) for use with
SimpleDateFormat class.
•Characters used for forming pattern strings in regular expressions.
•Format specifiers and their meaning for use in format() method in String and in printf().
FAQ 13. I’ve been a Java programmer for last five years. Do I have to prepare for the OCPJP 7 exam?
Short answer: It’s good that you have work experience, but you still need to prepare for the OCPJP 7 exam.
Long answer: No matter how much real-world programming experience you might have, there are two reasons why you should prepare for this exam to improve your chances of passing it:
•You may not have been exposed to certain topics on the exam. Java is vast, and you might not have had occasion to work on every topic covered in the exam. For example, you may not be familiar with localization if you have never dealt the locale aspects of the applications you were engaged with. Or your work might not have required you to use JDBC. Or you’ve always worked on single-threaded programs, so multithreaded programming might be new to you. Moreover, OCPJP 7 emphasizes Java 7, and you might not have been exposed yet to such Java 7 topics as NIO.2, new concurrency APIs, and enhancements such as try-with-resource statements.
•You may not remember the unusual aspects or corner cases. No matter how experienced you are, there is always an element of surprise involved when you program. The OCPJP 7 exam tests not just your knowledge and skills in respect of regular features, but also your
understanding of unusual aspects or corner cases, such as the behavior of multithreaded code and the use of generics when both overloading and overriding are involved. So you have to bone up on pathological cases that you rarely encounter in your work.
A good way to gauge how much preparation you’ll need in the various topics before you can feel confident that you’ll pass the OCPJP 7 exam is to take the pre-test in Chapter 2 and the two full-length sample exams in Appendix B and C.
FAQ 14. How do I prepare for the OCPJP 7 exam?
Study this book. In addition,
•Code, code, code! Write lots and lots of small programs, experiment with them, and learn from your mistakes.
•Read, read, read! Read this book and the tutorial and reference resources on Oracle’s site, especially.
7