Oracle 1Z0-805 Online Practice Questions and Exam Preparation

Oracle 1Z0-805 Online Questions & Answers

• Question 71:

  The advantage of a CallableStatement over a PreparedStatement is that it:

  A. Is easier to construct
  B. Supports transactions
  C. Runs on the database
  D. Uses Java instead of native SQL
  C. Runs on the database

  ---

  A Statement is an interface that represents a SQL statement. You execute Statement objects, and they generate ResultSet objects, which is a table of data representing a database result set. There are three different kinds of statements:

  *

  Statement: Used to implement simple SQL statements with no parameters.

  *

  PreparedStatement: (Extends Statement.) Used for precompiling SQL statements that might contain input parameters.

  *

  CallableStatement: (Extends PreparedStatement.) Used to execute stored procedures that may contain both input and output parameters.

  A stored procedure is a group of SQL statements that form a logical unit and perform a particular task, and they are used to encapsulate a set of operations or queries to execute on a database server.

  Reference: The Java Tutorials:

  Executing Queries

  Using Stored Procedures

• Question 72:

  In the Java SE7 API, which method is most commonly used by factories to instantiate objects?

  A. new ()
  B. make ()
  C. create ()
  D. getObject ()
  E. getInstance ()
  F. createObject ()
  E. getInstance ()

  ---

  For example: KeyFactory.getInstance, ObjectFactory. getObjectInstance.

• Question 73:

  Given:

  public class MyGrades {

  private final List myGrades = new ArrayList();

  private final ReadWriteLock rwlock = new ReentrantReadWriteLock();

  public void addGrade(Integer grade) {

  /*

  lock and modify

  */

  }

  public void averageGrades() {

  // acquire lock Line **

  double sum = 0;

  int i = 0;

  for (i = 0; i < myGrades.size(); i++) {

  sum += myGrades.get(i);

  }

  // release lock Line ***

  System.out.println("The average is: " + sum/(i+1));

  } } Which pair's statements should you insert at line ** and line *** (respectively) to acquire and release the most appropriate lock?

  A. rwlock.readLock().acquire(); rwlock.readLock().release();
  B. rwlock.readLock().lock(); rwlock.readLock().unlock();
  C. rwlock.getLock().acquire(); rwlock.getLock().release();
  D. rwlock.getLock().lock(); rwlock.getLock().Unlock();
  E. rwlock.WriteLock().acquire(); rwlock.writeLock().release();
  F. rwlock.writeLock().lock(); rwlock.WriteLock().unlock();
  B. rwlock.readLock().lock(); rwlock.readLock().unlock();

  ---

  We need a read lock, not a write lock, we are just reading data, not writing/updating data. To aquire and release the lock the method lock() and unlock are used.

  Reference: Class ReentrantReadWriteLock

• Question 74:

  Given the code fragment:

  Path path1 = Paths.get("D:\\sales\\.\\quarterly\\..\\report");

  path1 = path1.normalize();

  Path path2 = path1.relativize(Paths.get("d:\\empdetails.dat"));

  path2 = path2.resolve(path1);

  System.out.println(path1);

  System.out.println(path2);

  }

  What is the result?

  A. D: \sales\report
  B. \sales\report
  C. D: \sales\quarterly\ . . . \report
  D. \sales\report
  E. D: \sales\quarterly\ . . .\report
  F. \sales\report\empdetails.dat
  G. D: \sales\report
  H. \sales\report\empdetails.dat
  A. D: \sales\report

  ---

  Path1 is the normalized result of D:\\sales\\.\\quarterly\\..\\report namely D: \sales\report.

  The normalize method removes any redundant elements, which includes any "." or "directory/.." occurrences.

  Consider path2.

  With the relativize line path2 is set to../../empdetails.dat

  In this scenario the following applies to the resolve statement: Passing an absolute path to the resolve method returns the passed-in path.So Path2 will be set to Path1 in the statementpath2 = path2.resolve(path1);

  Note:

  A common requirement when you are writing file I/O code is the capability to construct a path from one location in the file system to another location. You can meet this using the relativizemethod. This method constructs a path originating

  from the original path and ending at the location specified by the passed-in path. The new path is relative to the original path.

  You can combine paths by using the resolve method. You pass in a partial path , which is a path that does not include a root element, and that partial path is appended to the original path.

  Reference: The Java Tutorials,Path Operations

• Question 75:

  Which two fragments can be combined into a statement that returns an ExecuteService instance?

  A. Executors
  B. Executor
  C. ExecutorService
  D. .getSingleThreadExecutor ();
  E. .newSingleThreadExecutor ();
  F. .createSingleThreadExecutor ();
  G. .buildSingleThreadExecutor ();
  A. Executors
  E. .newSingleThreadExecutor ();

  ---

  The Executors.newSingleThreadExecutor() method creates an Executor that uses a single worker thread operating off an unbounded queue. Reference: java.util.concurrent.Executors

• Question 76:

  Which two statements are true?

  A. Implementing a DAO often includes the use of factory.
  B. To be implemented properly, factories rely on the private keyword.
  C. Factories are an example of the OO principle "program to an interface."
  D. Using factory prevents your replication from being tightly coupled with a specific Singleton
  E. One step in implementing a factory is to add references from all the classes that the factory will merge.
  A. Implementing a DAO often includes the use of factory.
  C. Factories are an example of the OO principle "program to an interface."

  ---

  A: The DAO design pattern completely hides the data access implementation from its clients. The interfaces given to client does not changes when the underlying data source mechanism changes. this is the capability which allows the DAO to adopt different access scheme without affecting to business logic or its clients. generally it acts as a adapter between its components and database. The DAO design pattern consists of some factory classes, DAO interfaces and some DAO classes to implement those interfaces.

  C: The essence of the Factory method Pattern is to "Define an interface for creating an object, but let the classes which implement the interface decide which class to instantiate. The Factory method lets a class defer instantiation to subclasses."

  Note:The factory method pattern is an object-oriented design pattern to implement the concept of factories. Like other creational patterns, it deals with the problem of creating objects (products) without specifying the exact class of object that will be created. The creation of an object often requires complex processes not appropriate to include within a composing object. The object's creation may lead to a significant duplication of code, may require information not accessible to the composing object, may not provide a sufficient level of abstraction, or may otherwise not be part of the composing object's concerns. The factory method design pattern handles these problems by defining a separate method for creating the objects, whichsubclasses can then override to specify the derived type of product that will be created. Some of the processes required in the creation of an object include determining which object to create, managing the lifetime of the object, and managing specialized build-up and tear-down concerns of the object.

• Question 77:

  Given the code fragment:

  List pList = new CopyOnWriteArrayList();

  Which statement is true?

  A. Read access to the List should be synchronized.
  B. Write access to the List should be synchronized.
  C. Person objects retrieved from the List are thread-safe.
  D. A Person object retrieved from the List is copied when written to.
  E. Multiple threads can safely delete Person objects from the List.
  C. Person objects retrieved from the List are thread-safe.

  ---

  CopyOnWriteArrayList produces a thread-safe variant of ArrayList in which all mutative operations (add, set, and so on) are implemented by making a fresh copy of the underlying array.

  Note: his is ordinarily too costly, but may be more efficient than alternatives when traversal operations vastly outnumber mutations, and is useful when you cannot or don't want to synchronize traversals, yet need to preclude interference

  among concurrent threads. The "snapshot" style iterator method uses a reference to the state of the array at the point that the iterator was created. This array never changes during the lifetime of the iterator, so interference is impossible and

  the iterator is guaranteed not to throw ConcurrentModificationException. The iterator will not reflect additions, removals, or changes to the list since the iterator was created. Element-changing operations on iterators themselves (remove, set,

  and add) are not supported.

  These methods throw UnsupportedOperationException.

  All elements are permitted, including null.

  Memory consistency effects: As with other concurrent collections, actions in a thread prior to placing an object into a CopyOnWriteArrayList happen-before actions subsequent to the access or removal of that element from the

  CopyOnWriteArrayList in another thread.

  Reference: java.util.concurrent.CopyOnWriteArrayList

• Question 78:

  Which statement is true about the DSYNC constant defined in standardopenoptions enums?

  A. DSYNC keeps only the file content and not the metadata synchronized with the underlying storage device.
  B. DSYNC keeps thefile (both content and metadata) synchronized with the underlying storage device.
  C. DSYNC keeps only the file metadata and not the file content synchronized with the underlying storage device.
  D. DSYNC keeps the file (both content and metadata) de-synchronized with copies in the und< storage device.
  A. DSYNC keeps only the file content and not the metadata synchronized with the underlying storage device.

  ---

  DSYNC keeps the file content synchronized with the underlying storage device.

  Note:SYNC keeps the file (both content and metadata) synchronized with the underlying storage device.

  Note 2: These are from the java.nio.file.StandardOpenOption enum class.

• Question 79:

  Given the code fragment:

  dataFormat df;

  Which statement defines a new DataFormat object that displays the default date format for the UK Locale?

  A. df = DateFormat.getDateInstance (DateFormat.DEFAULT, Locale(UK));
  B. df = DateFormat.getDateInstance (DateFormat.DEFAULT, UK);
  C. df = DateFormat.getDateInstance (DateFormat.DEFAULT, Locale.UK);
  D. df = new DateFormat.getDataInstance (DataFormat.DEFAULT, Locale.UK);
  E. df = new DateFormat.getDateInstance (DateFormat.DEFAULT, Locale(UK));
  C. df = DateFormat.getDateInstance (DateFormat.DEFAULT, Locale.UK);

  ---

  DateFormat is an abstract class that provides the ability to format and parse dates and times. The getDateInstance() method returns an instance of DateFormat that can format date information. It is available in these forms:

  static final DateFormat getDateInstance( )

  static final DateFormat getDateInstance(int style)

  static final DateFormat getDateInstance(int style, Locale locale)

  The argument style is one of the following values: DEFAULT, SHORT, MEDIUM, LONG, or FU These are int constants defined by DateFormat.

• Question 80:

  Given the code fragment:

  public void processFile() throws IOException, ClassNotFoundException {

  try (FileReader fr = new FileReader ("logfilesrc.txt");

  FileWriter fw = new FileWriter ("logfiledest.txt"))

  { Class c = Class.forName ("java.lang.JString");

  }

  }

  If exception occur when closing the FileWriter object and when retrieving the JString class object, which exception object is thrown to the caller of the processFile method?

  A. java.io.IOException
  B. java.lang.Exception
  C. java.lang.ClassNotException
  D. java.lang.NoSuchClassException
  A. java.io.IOException