Oracle Certified Associate, Java SE 7 Programmer Study Guide

Let's digress for a moment and consider why we are using Java at all. One of the most significant aspects of Java is that it is an object-oriented (OO) language. OO technologies are a popular paradigm for developing applications. This approach models an application around a series of real world objects, such as an employee or a ship. In order to solve a problem, it is useful to think of the real world objects that make up the problem domain.

The OO approach is based on three distinct activities:

The products of the analysis and design steps are often referred to as analysis and design artifacts. While there may be several different types produced, the one of most interest to the OOP step is called the class diagram . The following diagram shows a partial class UML diagram depicting two classes: Customer and CustomerDriver. In the A simple Java application section, we will examine the code for these classes. The Unified Modeling Language (UML) is a widely used OO technique used to design and document an application. A class diagram is one of the end products of the technique and is used by programmers to create the application:

Each box represents a class and is divided into three sections:

The symbols preceding the variable and method names specify the visibility of these class members. The following are the class diagram symbols used:

Normally, a class diagram consists of many classes and is interconnected with annotated lines showing the relationship between the classes.

The class diagram is intended to clearly show what objects make up the system and how they interact. Once a class diagram is complete it can be implemented using an OOP language such as Java.

While there is some disagreement in what actually makes a programming language an OOP programming language, there are generally three underlying principles that must be supported by an OOP language:

Data encapsulation is concerned with hiding irrelevant information from the users of a class and exposing the relevant. The primary purpose of data encapsulation is to reduce the level of software development complexity. By hiding the details of what is needed to perform an operation, the use of that operation is simpler. How to achieve data encapsulation in Java is explained in the Access modifiers section, later in this chapter.

Data encapsulation is also used to protect the internal state of an object. By hiding the variables that represent the state of an object, modifications to the object are controlled through the methods. Any changes to the state are verified by the code in the methods. Also, by hiding variables, sharing of information between classes is eliminated. This reduces the amount of coupling possible in an application.

Inheritance describes the relationship between two classes such that one class re-uses the capabilities of another class. This enables the re-use of software resulting in a more productive developer. Inheritance is covered in detail in Chapter 7, Inheritance and Polymorphism.

The third principle is polymorphism and its primary concern is to make the application more maintainable and extendable polymorphism behavior is where the behavior of one or identical methods is dependent upon the object it is executing against. For example, a person object and a square object can both have a draw method. What it draws depends on the object the method is executed against. Polymorphism is discussed in Chapter 7, Inheritance and Polymorphism.

These principles are summarized in the following table:

The implements keyword is used in support of polymorphic behavior as is explained in Chapter 7, Inheritance and Polymorphism.

There are several types of Java applications. These types have allowed Java to flourish in a number of different areas and contributed to Java becoming a very popular programming language. Java is used to develop the following:

While a basic understanding of the types of Java applications is useful in putting Java into context, it also helps to be able to recognize the basic code for these applications. You may not completely understand all of the ins and outs of these application types, but it is useful to see simple code examples.

Reading the code goes a long way towards understanding a language and a specific program. Throughout the book we will use numerous examples to illustrate and explain various aspects of Java. The basic types of Java applications are shown below by presenting short code snippets that are central to that application type.

A simple console application consists of a single class with a main method, as shown in the following code snippet:

public class Application {
   public static void main(String[] args) {
      // Body of method
   }
}

We will examine this type of application in more depth.

Applets are normally embedded within an HTML page and offer a means of achieving client-side execution of a code. It does not have a main method but uses a series of callback methods used by the browser to manage the application. The following code provides an idea of the general appearance of an applet:

import java.applet.*;
import java.awt.Graphics;

public class SimpleApplet extends Applet {

   @Override
   public void init() {
      // Initialization code
   }

   @Override
   public void paint( Graphics g ) {
      // Display graphics
   }
}

The @Override annotation is used to ensure that the method that follows is actually overridden. This is discussed in more detail in the Annotations section of this chapter.

A servlet is a server-side application which renders an HTML page sent to a client. A doGet or doPut method responds to client-side request. The out variable in the following example represents the HTML page. The println methods are used to write the HTML code, as shown in the following code snippet:

class Application extends HttpServlet {
   public void doGet(HttpServletRequest req,
            HttpServletResponse res)
            throws ServletException, IOException {
      res.setContentType("text/html");

      // then get the writer and write the response data
      PrintWriter out = res.getWriter();
      out.println(
         "<HEAD><TITLE> Simple Servlet</TITLE></HEAD><BODY>");
      out.println("<h1> Hello World! </h1>");
      out.println(
         "<P>This is output is from a Simple Servlet.");
      out.println("</BODY>");
      out.close();
   }
}

A JavaServer Page (JSP) is actually a disguised Servlet. It provides a more convenient way of developing web pages. The following example uses a JavaBean to display "Hello World" on the web page. The JavaBean is detailed in the following example:

<html>
<head>
   <title>A Simple JSP Page</title>
</head>
<body>
Hello World!<br/>
    
<%
   // This is a scriptlet that can contain Java code
%>
<hr>
<jsp:useBean id="namebean" class="packt.NameBean" scope="session" >
<jsp:setProperty name="namebean" property="name" value=" Hello world"" />
</jsp:useBean>
<h1> <jsp:getProperty name="namebean" property="name" /></h1>
</body>
</html>

JavaBeans are building blocks for shared application functionality. They are frequently designed to be used in multiple applications and follow a standard naming convention. The following is a simple JavaBean designed to hold a name (it was used in the previous JSP page):

package packt;
public class NameBean {
  
  private String name= "Default Name"";
  
  public String getName() {
     return this.name;
  }
  public void setName(String name) {
     this.name = name;
  }
}

Enterprise Java Beans (EJB) are components designed to be used in a client/server configuration from a web server. This is a fairly specialized topic that is not relevant to the associate level of certification.

There are several other types of Java technologies such as JSF and Facelets that are a part of JEE. These are improvements over the older Servlet and JSP technologies used to develop web pages.

In this book we will only use simple Java console applications. This type of application is more than sufficient to explain the essence of Java.

Our simple program defines a Customer class and then uses it in the CustomerDriver class as follows:

package com.company.customer;

import java.math.BigDecimal;
import java.util.Locale;

public class Customer {
  private String name;
  private int accountNumber;
  private Locale locale;
  private BigDecimal balance;
  
  public Customer() {
    this.name = "Default Customer";
    this.accountNumber = 12345;
    this.locale = Locale.ITALY;
    this.balance = new BigDecimal("0");
  }
  
  public String getName() {
    return name;
  }
  public void setName(String name) throws Exception {
    if(name == null) {
         throw new IllegalArgumentException(
            "Names must not be null");
    } else {
      this.name = name;
    }
  }
  public int getAccountNumber() {
    return accountNumber;
  }

  public void setAccountNumber(int accountNumber) {
    this.accountNumber = accountNumber;
  }
  
  public BigDecimal getBalance() {
    return balance;
  }

  public void setBalance(float balance) {
    this.balance = new BigDecimal(balance);
  }
  
   public String toString() {
      java.text.NumberFormat format =
         java.text.NumberFormat.getCurrencyInstance(locale);
      StringBuilder value = new StringBuilder();
      value.append(String.format("Name: %s%n", this.name));
      value.append(String.format("Account Number: %d%n", 
            this.accountNumber));
      value.append(String.format("Balance: %s%n",
            format.format(this.balance)));
      return value.toString();
    }  
}


package com.company.customer;

public class CustomerDriver {

  public static void main(String[] args) {
      // Define a reference and creates a new Customer object
    Customer customer;      
    customer = new Customer();
    customer.setBalance(12506.45f);
    System.out.println(customer.toString());
  }

The details of how to compile and execute this application are provided in the Developing Java applications without an IDE section. When this application is executed you will get the following output:

Name: Default Customer
Account number: 12345
Balance: € 12.506,45

Understanding the application in detail The following sections detail the significant aspects of the example program. These will be elaborated upon later in more detail in the chapters that follow. Notice, that there are two classes in this application. The CustomerDriver class contains the main method and is executed first. An instance of the Customer class is created and used within the main method.

A class is the fundamental building block of object-oriented programs. It generally represents a real-world object. A class definition in Java consists of member variable declarations and method declarations. It begins with the class keyword. The body of the class is enclosed with brackets and contains all instance variables and methods:

  class classname {
    // define class level variables
    // define methods
  }

  interface Drawable {
    final int unit = 1;
    public void draw();
  }

All executable code executes either within an initializer list or a method. Here, we will examine the definition and use of methods. The initializer list is discussed in Chapter 6, Classes, Constructors, and Methods. Methods will always be contained within a class. The visibility of a method is controlled by its access modifiers as detailed in the Access modifiers section. Methods may be either static or instance. Here, we will consider instance methods. As we will see in Chapter 6, Classes, Constructors, and Methods, static methods typically access static variables that are shared between objects of a class.

Regardless of the type of method, there is only a single copy of a method. That is, while a class may have zero, one, or more methods, each instance of the class (an object) uses the same definition of the method.

  public void setName(String name) throws Exception {
    if(name == null) {
      throw new Exception("Names must not be null");
    } else {
      this.name = name;
    }
  }

    public static void main(String[] args) {
       // Body of method
    }

    System.exit(0);

Variables and methods can be declared as one of four types, shown in the following table:

Most of the time, a member variable is declared as private and a method is declared as public. However, the existence of the other access types implies other potential ways of controlling the visibility of a member. These usages will be examined in Chapter 7, Inheritance and Polymorphism.

In the Customer class, all of the class variables were declared as private and all of the methods were made public. In the CustomerDriver class, we saw the use of the setBalance and toString methods:

    customer.setBalance(12506.45f);
    System.out.println(customer.toString());

As these methods were declared as public, they can be used with the Customer object. It is not possible to directly access the balance instance variable. The following statement attempts this:

    customer.balance = new BigDecimal(12506.45f);

The compiler will issue a compile-time error similar to the following:

balance has private access in com.company.customer.Customer

The documentation of a program is an important part of the software development process. It explains the code to other developers and provides reminders to the developers of what and why they did what they did.

Documentation is achieved through several techniques. Here, we will address three common techniques:

  /* A multi-line comment
     …
  */

  /* A single line comment */

  // The entire line is a comment
  int total;	// Comment used to clarify variable
  area = height*width; 	// This computes the area of a rectangle

    /**
     * This method computes the area of a rectangle
     *
     * @param height	The height of the rectangle
     * @param width	The width of the rectangle
     * @return		The method returns the area of a rectangle
     *
     */
   public int computeArea(int height, int width)  {
      return height * width;
   }

Using Javadocs

The Javadoc tool produces a series of HTML files based on the source code and Javadoc tags embedded in the source code. This tool is also distributed with the JDK. While the following example is not an attempt to provide a complete treatment of Javadocs, it should give you a good idea of what Javadocs can do for you:

public class SuperMath {
   /**
    * Compute PI - Returns a value for PI.
    *    Able to compute pi to an infinite number of decimal 
    *    places in a single machine cycle.
    * @return A double number representing PI
   */

   public static double computePI() {
      //
   }
}

The javadoc command, when used with this class, results in the generation of several HTML files. A part of the index.html file is shown in the following screenshot:

Note

More information on the use and creation of Javadoc files can be found at http://www.oracle.com/technetwork/java/javase/documentation/index-137868.html.

The general steps used to develop a Java application include:

This process is summarized in the following diagram:

Java source code files are compiled to bytecode files. These bytecode files have a .class extension. When a Java package is distributed, the source code files are not normally stored in the same location as the .class files.

The Java Software Development Kit (SDK) can be downloaded and used to create and execute many types of Java applications. The Java Enterprise Edition (JEE) is a different SDK and is used to develop enterprise applications typified by web-based applications. The SDK also known as the Java 2 Enterprise Edition (J2EE) and you may see it referenced as J2EE. Here, we will only deal with the Java SDK.

While the actual structure of the SDK distribution will vary by release, the typical SDK consists of a series of directories, listed as follows:

The SDK may include the actual source code for the core classes. This is usually found in the src.zip file located under the JAVA_HOME root directory.

Each IDE has a preferred way of organizing the files that make up an application. These organization schemes are not always hard and fast but those presented here are the common ways of arranging the files.

For example, a simple application in the Eclipse IDE consists of two project files and three sub-directories. These files and directories are listed as follows:

This organization scheme is used by the development tools. The tools often include editors, compilers, linkers, debuggers, and others. These languages frequently use a Make tool to determine which files need to be compiled or otherwise manipulated.

In this section we will demonstrate how to compile and execute a Java application on a Windows platform using Java 7. The approach is very similar to that used for other operating systems.

Before we can compile and execute the sample program we need to:

The latest version of the JDK can be found at http://www.oracle.com/technetwork/java/javase/downloads/index.html. Download and install the version that meets your needs. Note the location of the installation, as we will use this information shortly.

As explained earlier, the Java classes must be located in a specific file structure as mirrored in its package name. Create a file structure somewhere in your filesystem that has a top-level directory called com under which is a directory called company and then under the company directory, a directory called customer.

In the customer directory create two files called Customer.java and CustomerDriver.java. Use the corresponding classes as found earlier in the A simple Java application section.

The JDK tools are found in the JDK directory. When the JDK is installed, the environmental variables are normally set up to allow the successful execution of the JDK tools. However, it is necessary to specify the location of these tools. This is accomplished using the set command. In the following command, we set the path environmental variable to reference C:\Program Files\Java\jdk1.7.0_02\bin directory, which was the most recent release at the time this chapter was written:

set path= C:\Program Files\Java\jdk1.7.0_02\bin;%path%

This command prefixes the path to the bin directory in front of any previously assigned paths. The path environmental variable is used by the operating system to look for the command that is executed at the command prompt. Without this information, the operating system is not aware of the location of the JDK commands.

To compile the program using the JDK, navigate to the directory above the com directory. As the classes used as part of this application are part of the com.company.customer package we need to:

As there are two files that make up this application we need to compile both of them. This can be done using two separate commands as follows:

javac com.company.customer.Customer.java
javac com.company.customer.CustomerDriver.java

Or, it can be done using a single command and the asterisk wild card character as follows:

javac com.company.customer.*.java

The output of the compiler is a bytecode file with the name CustomerDriver.class. To execute the program, invoke the Java interpreter with your class file, as shown in the following command. The class extension is not included and its inclusion as part of the filename will result in an error:

java com.company.customer.CustomerDriver

The output of your program should be as follows:

Name: Default Customer
Account number: 12345
Balance: € 12.506,45

The Java environment is the operating system and file structure used to develop and execute Java applications. Earlier, we examined the structure of the JDK which are part of the Java environment. Associated with this environment are a series of environmental variables that are used from time-to-time to facilitate various operations. Here, we will examine a few of them in more detail:

These variables are summarized in the following table:

The CLASSPATH environmental variable is used to identify the root directory of the packages. It is set as follows:

  c:>set CLASSPATH=d:\development\increment1;%CLASSPATH%

The CLASSPATH variable only needs to be set for non-standard packages. The Java compiler will always implicitly append the system's class directories to CLASSPATH. The default CLASSPATH is the current directory and the system's class directories.

There are many other environmental variables associated with an application. The following code sequence can be used to display a list of these variables:

    java.util.Properties properties = System.getProperties();
    properties.list(System.out);

A partial display of the output of this code sequence is as follows:

-- listing properties --
java.runtime.name=Java(TM) SE Runtime Environment
sun.boot.library.path=C:\Program Files\Java\jre7\bin
java.vm.version=22.0-b10
java.vm.vendor=Oracle Corporation
java.vendor.url=http://java.oracle.com/
path.separator=;
java.vm.name=Java HotSpot(TM) 64-Bit Server VM
…

Annotations provide information about a program. This information does not reside in the program and does not affect its execution. Annotations are used to support tools such as the compiler and during the execution of the program. For example, the @Override annotation informs the compiler that a method is overriding a base class method. If the method does not actually override the base class method because it is misspelled, the compiler will generate an error.

Annotations are applied to elements of the application such as a class, method, or field. It begins with the at sign, @, is followed by the name of the annotation, and optionally a list of values enclosed in a set of parentheses.

Common compiler annotations are detailed in the following table:

Annotations can be added to an application and used by the third-party tools for specific purposes. It is also possible to write your own annotations when needed.

Java includes a number of libraries of classes that support the development of applications. These include the following, among others:

These libraries are organized in packages. Each package holds a set of classes. The structure of a package is reflected in its underlying file system. The CLASSPATH environmental variable holds the location of packages.

There are a core set of packages that are part of the JDK. These packages provide a crucial element in the success of Java by providing easy access to a standard set of capabilities that were otherwise not readily available with other languages.

The following table shows a list of some of the more commonly used packages: