
- •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 10 ■ Building Database Applications with JDBC
(The statement while (resultSet.next()) is missing.)
6.Which of the following two statements are correct regarding RowSets in JDBC?
A.It is possible to use JdbcRowSet as a JavaBeans component.
B.WebRowSet provides result set in the JSON format.
C.The filter in a FilteredRowSet object is set at the time of its creation; a filter cannot be set once the FilteredRowSet object is created.
D.A CachedRowSet object caches data in its memory, which makes it possible to use the CachedRowSet object without always being connected to its data source.
Answer:
A.It is possible to use JdbcRowSet as a JavaBeans component.
D.A CachedRowSet object caches data in its memory, which makes it possible to use the CachedRowSet object without always being connected to its data source.
(Note that B) WebRowSet provides a result set in XML format (not JSON format which is one of the alternatives to XML) and C) The filter in a FilteredRowSet object can be set using the setFilter() method any time).
7.Which of the following interfaces does NOT extend the RowSet interface?
A.JdbcRowSet
B.CachedRowSet
C.WebRowSet
D.TraversalRowSet
E.JoinRowSet
Answer: D) TraversalRowSet
(The interfaces deriving from JdbcRowSet are CachedRowSet, WebRowSet, JoinRowSet, and FilteredRowSet.)
Summary
Define the Layout of the JDBC API
•JDBC (Java Database Connectivity) APIs provided by Java are meant for programmatic access to DataBase Management Systems (DBMSs).
•JDBC hides all the heterogeneity of all the DBMSs and offers a single set of APIs to interact with all types of databases.
•The complexity of heterogeneous interactions is delegated to JDBC driver manager and JDBC drivers; hence all the details and complications are hidden by the JDBC API from the application developer.
313
Chapter 10 ■ Building Database Applications with JDBC
•There are four types of drivers:
•Type 1 (JDBC-ODBC bridge drivers): JDBC driver calls ODBC (Open Database Connectivity) native calls using the Java Native Interface (JNI).
•Type 2 (Native-API drivers): These drivers use client-side libraries of a specific database and convert JDBC calls to native database calls.
•Type 3 (Network-protocol drivers): These drivers call database middleware and the middleware actually converts JDBC calls to database-specific native calls.
•Type 4 (Native-protocol drivers): The driver directly makes database-specific calls over the network without any support of additional client-side libraries.
Connect to a Database by Using a JDBC driver
•The java.sql.Connection interface provides a channel through which the application and the database communicate.
•The getConnection() method in the DriverManager class takes three arguments: the URL string, username string, and password string.
•The syntax of the URL (which needs to be specified to get the Connection object) is
<protocol>:<subprotocol>://<server>:<port>/. An example of a URL string is jdbc:mysql://localhost:3306/. The <protocol> jdbc is the same for all DBMSs;
<subprotocol> will differ for each DBMS, <server> depends on the location in which you host the database, and each DBMS uses a specific <port> number.
•If the JDBC API is not able to locate the JDBC driver, it will throw a SQLException. If there are jars for the drivers available, they need to be included in the classpath to enable the JDBC API to locate the driver.
•Prior to JDBC 4.0, you would have to explicitly load the JDBC driver using the Class.forName() statement; with JDBC 4.0 and above, this statement is not needed and the JDBC API will load the driver from the details given in the URL string.
Update and Query a Database
•JDBC supports two interfaces for querying and updating: Statement and Resultset.
•A Statement is a SQL statement that can be used to communicate a SQL statement to the connected database and receive results from the database. There are three types of Statements:
•Statement: You need to use Statement when you need to send a SQL statement to the database without any parameter.
•PreparedStatement: Represents a precompiled SQL statement that can be customized using IN parameters.
•CallableStatement: Used to execute stored procedures; can handle IN as well as OUT and INOUT parameters.
•A ResultSet is a table with column heading and associated values requested by the query.
•A ResultSet object maintains a cursor pointing to the current row. Initially, the cursor is set to just before the first row; calling the next() method advances the cursor position by one row.
314
Chapter 10 ■ Building Database Applications with JDBC
•The column index in the ResultSet object starts from 1 (not from 0).
•You need to call updateRow() after modifying the row contents in a ResultSet; otherwise changes made to the ResultSet object will be lost.
•By calling the getMetaData() method in the Connection interface, you can examine the capabilities of the underlying database.
Customize the Transaction Behavior of JDBC and Commit Transactions
•A transaction is a set of SQL operations that needs to be either executed all successfully or not at all.
•Transaction-related methods are supported in the Connection interface.
•By default auto-commit mode is set to true, so all changes you make through the connection are committed automatically to the database.
•You can use setAutoCommit(false); to enable manual commits. With auto-commit not enabled, you need to explicitly commit or rollback transactions.
•If the commit() method does not execute in manual commit mode, there will be no change in the database.
•You can divide a big transaction into multiple milestones. These milestones are referred to as savepoints. This way you may save the changes to a database up to a milestone once the milestone is achieved.
Use the JDBC 4.1 RowSetProvider, RowSetFactory, and RowSet Interfaces
•RowSet is a special ResultSet that supports the JavaBean component model.
•JdbcRowSet is a connected RowSet while other subinterfaces of RowSet (i.e., JoinRowSet, CachedRowSet, WebRowSet, and FilteredRowSet) are disconnected RowSets.
•RowSetProvider provides APIs to get a RowSetFactory implementation, which can in turn be used to instantiate a relevant RowSet implementation.
315