Oracle 1Z0-805 Online Practice Questions and Exam Preparation

Oracle 1Z0-805 Online Questions & Answers

• Question 61:

  What is the minimum SQL standard that a JDBC API implementation must support?

  A. SQL-92
  B. SQL 99
  C. SQL-2003
  D. JDBC 4.0
  A. SQL-92

  ---

  JDBC sets minimum SQL conformance to the SQL92 entry level SQL standard. This gives guaranteed wide portability for applications designed to run on many platforms.

• Question 62:

  Given the code fragment:

  public static void main(String[] args)

  { Path dir = Paths.get("d:\\company");

  // insert code here. Line **

  for (Path entry: stream)

  { System.out.println(entry.getFileName()

  );

  }

  } catch (IOException e) {

  System.err.println("Caught IOException: " + e.getMessage());

  }

  }

  Which two try statements, when inserted at line 11, enable you to print files with the extensions.java, .htm, end and .jar.

  A. try (DirectoryStream stream =Files.newDirectoryStream(dir, "*.{java, htm, jar}")) {
  B. try (DirectoryStream stream =Files.newDirectoryStream(dir, "*.[java, htm, jar"] }} {
  C. try (DirectoryStream stream =Files.newDirectoryStream(dir, "*.{java*, htm*, jar*}"}} {
  D. try (DirectoryStream stream =Files.newDirectoryStream(dir, "**.{java, htm, jar}")) {
  A. try (DirectoryStream stream =Files.newDirectoryStream(dir, "*.{java, htm, jar}")) {
  D. try (DirectoryStream stream =Files.newDirectoryStream(dir, "**.{java, htm, jar}")) {

• Question 63:

  Given the fragment:

  public class CustomerApplication {

  public static void main (String [] args) {

  CustomerDAO custDao = new CustomerDAOMemoryImp1 ();

  // . . . other methods

  }

  }

  Which two valid alternatives to line 3 would decouple this application from a specific implementation of customerDAO?

  A. CustomerDAO custDao = new customerDAO();
  B. CustomerDAO custDao = (CustomerDAO) new object();
  C. CustomerDAO custDao = CustomerDAO.getInstance();
  D. CustomerDAO custDao = (CustomerDAO) new CustomerDAOmemoryImp1();
  E. CustomerDAO custDao = CustomerDAOFactory.getInstance();
  C. CustomerDAO custDao = CustomerDAO.getInstance();
  E. CustomerDAO custDao = CustomerDAOFactory.getInstance();

  ---

  Note: Data Access Layer has proven good in separate business logic layer and persistent layer. 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.

• Question 64:

  What design pattern does the Drivermanager.getconnection () method characterize?

  A. DAO
  B. Factory
  C. Singleton
  D. composition
  B. Factory

  ---

  DriverManager has a factory method getConnection() that returns a Connection object.

  Note 1:A factory method is a method that creates and returns new objects. The factory pattern (also known as the factory method pattern) is a creational design pattern. A factory is a Java class that is used to encapsulate object creation

  code. A factory class instantiates and returns a particular type of object based on data passed to the factory. The different types of objects that are returned from a factory typically are subclasses of a common parent class.

  Note 2:

  The method DriverManager.getConnection establishes a database connection. This method requires a database URL, which varies depending on your DBMS. The following are some examples of database URLs: MySQL, Java DB.

• Question 65:

  Which five items are provided by the Java concurrency utilities?

  A. High-performance, flexible thread pools
  B. Dynamic adjustment of thread priorities
  C. Collection classes designed for concurrent access
  D. Atomic variables
  E. synchronized wrappers for collection classes in the java.util package,
  F. Asynchronous execution of tasks
  G. Counting semaphores
  H. Concurrent collection sorting implementations
  A. High-performance, flexible thread pools
  C. Collection classes designed for concurrent access
  D. Atomic variables
  E. synchronized wrappers for collection classes in the java.util package,
  G. Counting semaphores

  ---

  The Java 2 platform includes a new package of concurrency utilities. These are classes that are designed to be used as building blocks in building concurrent classes or applications. Just as thecollections framework simplified the organization and manipulation of in- memory data by providing implementations of commonly used data structures, the concurrency utilities simplify the development of concurrent classes by providing implementations of building blocks commonly used in concurrent designs. The concurrency utilities include a high- performance, flexible thread pool; a framework for asynchronous execution of tasks; a host of collection classes optimized for concurrent access; synchronization utilities such as counting semaphores (G); atomic variables; locks; and condition variables.

  The concurrency utilities includes:

  *

  Task scheduling framework. The Executor interface standardizes invocation, scheduling, execution, and control of asynchronous tasks according to a set of execution policies. Implementations are provided that enable tasks to be executed within the submitting thread, in a single background thread (as with events in Swing), in a newly created thread, or in a thread pool, and developers can create customized implementations of Executor that support arbitrary execution policies. The built-in implementations offer configurable policies such as queue length limits and saturation policy that can improve the stability of applications by preventing runaway resource use.

  *

  Fork/join framework. Based on the ForkJoinPool class, this framework is an implementation of Executor. It is designed to efficiently run a large number of tasks using a pool of worker threads (A) . A work-stealing technique is used to keep all the worker threads busy, to take full advantage of multiple processors.

  *

  (C) Concurrent collections. Several new collections classes were added, including the new Queue, BlockingQueue and BlockingDeque interfaces, and high-performance, concurrent implementations of Map, List, and Queue. See the Collections Framework Guide for more information.

  *

  (D) Atomic variables. Utility classes are provided that atomically manipulate single variables (primitive types or references), providing high-performance atomic arithmetic and compare-and-set methods. The atomic variable implementations in the java.util.concurrent.atomic package offer higher performance than would be available by using synchronization (on most platforms), making them useful for implementing high-performance concurrent algorithms and conveniently implementing counters and sequence number generators.

  *

  (E) Synchronizers. General purpose synchronization classes, including semaphores, barriers, latches, phasers, and exchangers, facilitate coordination between threads.

  *

  Locks. While locking is built into the Java language through the synchronized keyword, there are a number of limitations to built-in monitor locks. The java.util.concurrent.locks package provides a high-performance lock implementation with the same memory semantics as synchronization, and it also supports specifying a timeout when attempting to acquire a lock, multiple condition variables per lock, nonnested ("hand-over-hand") holding of multiple locks, and support for interrupting threads that are waiting to acquire a lock.

  *

  Nanosecond-granularity timing. The System.nanoTime method enables access to a nanosecond-granularity time source for making relative time measurements and methods that accept timeouts (such as the BlockingQueue.offer, BlockingQueue.poll, Lock.tryLock, Condition.await, and Thread.sleep) can take timeout values in nanoseconds. The actual precision of the System.nanoTime method is platform-dependent.

  Reference: Java SE Documentation, Concurrency Utilities

• Question 66:

  Given the code fragment: public static void processFile () throws IOException { Try (FileReader fr = new FileReader ("logfilesrc.txt"); FileWriter fw = new FileWriter ("logfilesdst.txt") ) { int i = fr.read(); } } Which statement is true?

  A. The code fragment contains compilation errors.
  B. The java runtime automatically closes the FileWriter Instance first and the FileReader instance next.
  C. The java runtime automatically closes the FileReader Instance first and the FileWriter instance next.
  D. The developer needs to close the FileReader instance first and the FileWriter instance explicitly in a catch block.
  E. The Java runtime may close the FileReader and FileWriter instance in an intermediate manner. Developers should not rely on the order in which they are closed.
  B. The java runtime automatically closes the FileWriter Instance first and the FileReader instance next.

  ---

  The try-with-resources statement is a try statement that declares one or more resources. Aresource is an object that must be closed after the program is finished with it. The try- with-resources statement ensures that each resource is closed at the end of the statement. Any object that implements java.lang.AutoCloseable, which includes all objects which implementjava.io.Closeable, can be used as a resource.

  Reference: The Java Tutorials,The try-with-resources Statement

• Question 67:

  Given:

  public class DAOManager {

  public AccountDAO getAccountDAO() {

  return new AccountJDBCDAO();

  }

  }

  Which design pattern best describes the class?

  A. Singleton
  B. DAO
  C. Factory
  D. Composition
  B. DAO

  ---

  Data Access Object

  Abstracts and encapsulates all access to a data source

  Manages the connection to the data source to obtain and store data Makes the code independent of the data sources and data vendors (e.g. plain-text, xml, LDAP, MySQL, Oracle, DB2)

• Question 68:

  Which code fragment is required to load a JDBC 3.0 driver?

  A. DriverManager.loadDriver("org.xyzdata.jdbc.network driver");
  B. Class.forname ("org.xyzdata.jdbc.NetWorkDriver");
  C. Connection con = Connection.getDriver ("jdbc:xyzdata: //localhost:3306/EmployeeDB");
  D. Connection con = Drivermanager.getConnection ("jdbc:xyzdata: //localhost:3306/EmployeeDB");
  B. Class.forname ("org.xyzdata.jdbc.NetWorkDriver");

  ---

  Note that your application must manually load any JDBC drivers prior to version 4.0. The simplest way to load a driver class is to call the Class.forName() method. If the fully-qualified name of a class is available, it is possible to get the corresponding Class using the static method Class.forName().

• Question 69:

  Which is true regarding the java.nio.file.Path Interface?

  A. The interface extends WatchService interface
  B. Implementations of this interface are immutable.
  C. Implement at ions of this interface arc not safe for use by multiple concurrent threads.
  D. Paths associated with the default provider are not interoperable with the
  A. The interface extends WatchService interface

  ---

  The java.nio.file.Path interface extends Watchable interface so that a directory located by a path can be registered with a WatchService and entries in the directory watched.

  Note: An object that may be used to locate a file in a file system. It will typically represent a system dependent file path.

  A Path represents a path that is hierarchical and composed of a sequence of directory and file name elements separated by a special separator or delimiter. A root component, that identifies a file system hierarchy, may also be present. The

  name element that is farthest from the root of the directory hierarchy is the name of a file or directory. The other name elements are directory names. A Path can represent a root, a root and a sequence of names, or simply one or more name

  elements. A Path is considered to be an empty path if it consists solely of one name element that is empty. Accessing a file using an empty path is equivalent to accessing the default directory of the file system. Path defines the getFileName,

  getParent, getRoot, and subpath methods to access the path components or a subsequence of its name elements.

  Reference: java.nio.file.Path Interface

• Question 70:

  Given:

  public class StringApp {

  public static void main(String[] args) {

  String[] str="Java SE,java EE,Java ME,java FX".split(",");

  int count=0;

  for(int i=0;i

  switch(str[i]) { case

  "Java SE":

  count++; continue;

  case "Java EE":

  count++; break;

  case "Java ME":

  count++; break;

  case "Java FX":

  count++; break;

  }

  }

  System.out.println("Total match found="+count);

  }

  }

  What is the result?

  A. 1
  B. 2
  C. 3
  D. 4
  B. 2

  ---

  Java SE and Java ME will increase the count variable as it matches. java EE and java FX does not match.