Core Java

Objects and Classes

Slide navigation: Forward with space bar, → arrow key, or PgDn. Backwards with ← or PgUp.

Understand the fundamental concepts of object-oriented programming

Why OOP?

• 1970s: “Structured” programming.
  • Algorithms + Data Structures = Programs.
  • Procedures operate on shared data.
• 1980s: Object-oriented programming.
  • Each object has data and methods.
  • Encapsulation: Only methods can access object data.
    
• Java is thoroughly object-oriented.
  • Everything other than a primitive type value is an object.

Classes and Objects

• Class: “Cookie cutter” for objects.
• Describes object data and method behavior.
• Object = instance of class.
• Object has:
  • Behavior
  • State
  • Identity
• OOP starts with identifying classes:
  • Nouns are often classes: Item, Order, and so on.
  • Verbs are often methods: add an item to an order, ship an order.

Work with predefined classes

Using Predefined Classes

• Math is an atypical class. You don't make objects to call Math.sqrt(x).
• The Date class is more typical. Each object describes a point in time such as “December 31, 1999, 23:59:59 GMT”
• Construct instance with new operator:

  Date birthday = new Date();
  

  
• Now you can call methods:

  String s = birthday.toString();

Object Variables

• An object variable holds a reference to an object.
• Copying a variable makes a copy of the reference:

  deadline = birthday;

  
• A null reference refers to no object:

  deadline = null;

• Caution: Don't call a method on null.

  if (deadline != null)
     s = deadline.toString();
  

Working with LocalDate

• A Date is a point in time, measured in UTC.
• A LocalDate is a date (day, month, year) in a particular location.
• Use factory methods to create instances:

  LocalDate rightNow = LocalDate.now();
  LocalDate newYearsEve = LocalDate.of(1999, 12, 31);
  

• LocalDate methods:

  LocalDate aThousandDaysLater = newYearsEve.plusDays(1000);
  year = aThousandDaysLater.getYear(); // 2002
  month = aThousandDaysLater.getMonthValue(); // 09
  day = aThousandDaysLater.getDayOfMonth(); // 26
  

• How is a LocalDate stored? How do these methods do their job? You don't know, and you don't care. That's encapsulation.

Accessor and Mutator Methods

• Accessor method doesn't modify object state.
• All LocalDate methods are accessors.
• Older version of calendar date class has mutator methods:

  GregorianCalendar someDay = new GregorianCalendar(1999, 11, 31);
  someDay.add(Calendar.DAY_OF_MONTH, 1000);
     // someDay has been mutated
  int year = someDay.get(Calendar.YEAR); // 2002
  

• Tip: Minimize mutator methods. They make it more difficult to share objects in concurrent programs.

CalendarTest

Define your own classes

Defining Your Own Classes

class Employee
{
   // Fields
   private String name; 
   private double salary;
   private LocalDate hireDay;

   // Constructors
   public Employee(String n, double s, int year, int month, int day)
   {
      name = n;
      salary = s;
      hireDay = LocalDate.of(year, month, day);
   }

   // Methods
   public String getName() { return name; }
   . . .
}

Constructors

• In general, instance fields are private.
• Initialized in constructor:

  public Employee(String n, double s, int year, int month, int day)
  {
     name = n;
     salary = s;
     hireDay = LocalDate.of(year, month, day);
  }

• The call

  new Employee("James Bond", 100000, 1950, 1, 1)

  sets the fields as follows:

  name = "James Bond";
  salary = 100000;
  hireDay = LocalDate.of(1950, 1, 1);
  

• Name of constructor = class name.
• Constructor only works with new.

Implicit and Explicit Parameters

• Methods access and modify fields:

  public void raiseSalary(double byPercent)
  {
     double raise = salary * byPercent / 100;
     salary += raise;
  }

• In the call number007.raiseSalary(5), these steps occur:

  double raise = number007.salary * 5 / 100;
  number007.salary += raise;

• The call depends on two parameters:
  • byPercent is an explicit parameter.
  • The object on which the method is invoked is the implicit parameter.
• Can optionally use this to denote implicit parameter:

  public void raiseSalary(double byPercent)
  {
     double raise = this.salary * byPercent / 100;
     this.salary += raise;
  }

EmployeeTest

Benefits of Encapsulation

• Note the private field and public method:

  private String name;
  
  public String getName() { return name; }
  

• Benefit 1: The field is “read-only”.
• Benefit 2: The internal representation can evolve:

  private String firstName;
  private String lastName;
  
  public string getName() { return firstName + " " + lastName; }
  

Understand advanced concepts of classes in Java

Final and Static Fields

• A final field cannot change:

  private final String name;

• Caution: A final object can still be mutated:

  private final StringBuilder evaluations;
  public Employee() { evaluations = new StringBuilder(); . . . }
  public void giveGoldStar() { evaluations.append("Gold star!\n"); }
  

• A static field exists once per class:

  private static int nextId; // one field per class
  private int id; // one field per object
  public void setId() { id = nextId; nextId++; }
  

• A static final field is a shared constant:

  public class Math
  {
     public static final double PI = 3.14159265358979323846;
        // Accessible anywhere as Math.PI
     . . .
  }

Static Methods

• A static method doesn't operate on objects.
• Example: Math.pow(a, b) computes a^b without using a Math object.
• In other words, a static method uses no this.
• Static methods can only access static fields:

  public static int getNextId()
  {
     return nextId; // returns static field
  }
  

• Supply class name when calling the method:

  int n = Employee.getNextId();

• The main method is static because no objects have been constructed when the program starts.

StaticTest

Understand parameter passing in Java

Call by Value

• Call by value: The method gets copies of the argument values.
• A method cannot change the contents of variables passed to it.
• Example:

  public static void tripleValue(double x) // doesn't work
  {
     x = 3 * x;
  }

• In the following call, the percent variable is not changed:

  double percent = 10;
  tripleValue(percent);

Call with Object References

• A method can mutate objects:

  public static void tripleSalary(Employee x) // works
  {
     x.raiseSalary(200);
  }

• In the following call, the salary is changed:

  harry = new Employee(. . .);
  tripleSalary(harry);

  

Object References Are Passed by Value

• Some people say: “In Java, numbers are passed by value and objects are passed by reference.”
• That's nonsense. In Java, everything is passed by value.
• Object references are passed by value.
• If objects were passed by reference, you could swap them:

public static void swap(Employee x, Employee y) // doesn't work
{
   Employee temp = x;
   x = y;
   y = temp;
}

• But in the following call, a and b are not swapped:

  Employee alice = new Employee("Alice", . . .);
  Employee bob = new Employee("Bob", . . .);
  swap(alice, bob);
    

ParamTest

Learn more about object construction

Overloading

• A class can have more than one constructor:

  StringBuilder messages = new StringBuilder();
  StringBuilder todoList = new StringBuilder("To do:\n");

• The constructor name is overloaded.
• Name + parameter types = Method signature.
• Overloading resolution: The compiler picks the appropriate version from the argument types.
• You can overload any method:

  String.indexOf(int)
  String.indexOf(int, int)
  String.indexOf(String)
  String.indexOf(String, int)

• The return type is not a part of the method signature.

Default Construction

• A field that isn't explicitly set in a constructor is 0, false, or null.
• Caution: Accidentally uninitialized variables can lead to null pointer errors.

  public Employee() { name = ""; }
  . . .
  LocalDate h = harry.getHireDay();
  int year = h.getYear(); 
  

• If a class has no constructor, a no-argument constructor is provided.
• It sets all fields to their default values.
• If a class has at least one constructor, the no-argument constructor is not provided.
• But you can provide it:

  public Employee() {}
  

Field Initialization

• You can override the 0/false/null default for fields:

  class Employee
  {
     private String name = "";
     . . .
  }

• The initialization value can be computed:

  class Employee
  {
     private static int nextId;
     private int id = assignId();
     . . .
     private static int assignId()
     {
        int r = nextId;
        nextId++;
        return r;
     }
     . . .
  }

Construction Parameter Names

• Some programmers like single-letter parameter names:

  public Employee(String n, double s)
  {
     name = n;
     salary = s;
  }

• For better documentation, can use a prefix:

  public Employee(String aName, double aSalary)
  {
     name = aName;
     salary = aSalary;
  }

• Can use this to distinguish between parameters and fields:

  public Employee(String name, double salary)
  {
     this.name = name;
     this.salary = salary;
  }

Calling Another Constructor

• A constructor can call another constructor in the first statement.
• Use this (and not the class name) for the call:

  public Employee(double s)
  {
     // calls Employee(String, double)
     this("Employee #" + nextId, s);
     nextId++;
  }

• Allows you to factor out common construction code.
• Keyword reuse: Not related to using this for the implicit parameter.

Initialization Blocks

• Class declarations can contain arbitrary blocks of code.
• Executed whenever an object is constructed:

  class Employee
  {
     private static int nextId;
     private int id;
     // object initialization block
     {
        id = nextId;
        nextId++;
     }
  
     public Employee(. . .) { . . . } // constructor
     . . .
  }
  

• Static initialization block is executed when class is loaded:

  static
  {
     Random generator = new Random();
     nextId = generator.nextInt(10000);
  }

ConstructorTest

Work with packages and imports

Packages

• Related classes are organized into packages:

  java.lang
  java.util
  java.time
  . . .
  

• Avoids name conflict: java.util.Date ≠ java.sql.Date
• Use reverse domain name for your own packages: com.horstmann.corejava
• Packages do not nest: No relationship between java.util and java.util.jar

Imports

• Can access classes from any package with fully qualified name:

  java.time.LocalDate today = java.time.LocalDate.now();
  

• Import statements remove the tedious repetition:

  import java.time.*;
  . . .
  LocalDate today = LocalDate.now();
  

• Can import single class:

  import java.time.LocalDate;
  

• Cannot have multiple wildcards (import java.*.*).
• If two packages import the same class, you still need fully qualified names:

  import java.util.*;
  import java.sql.*;
  . . .
  Date today; // Error--java.util.Date or java.sql.Date?
  

• Or add a disambiguating import to the wildcard imports:

  import java.util.Date;
  

Static Imports

• Imports static fields and methods:

  import static java.lang.System.*;
  

• Now you can refer to System.out and System.exit without the class name:

  out.println("Goodbye, World!"); // i.e., System.out
  exit(0); // i.e., System.exit

• Can import a specific method or field:

  import static java.lang.System.out;

• Can be handy for mathematical functions:

  import static java.lang.Math.*;
  . . .
  r = sqrt(pow(x, 2) + pow(y, 2));
  

Adding a Class to a Package

• Put a package declaration at the top of the file:

  package com.horstmann.corejava;
  
  public class Employee
  {
     . . .
  }
  

• A class without a package declaration is in the default package.
• Place the source file into a subdirectory that matches the package name.
  
• Compile from the base directory:

  javac com/horstmann/corejava/Employee.java
  

PackageTest

Package Scope

• A feature that is not public, private, or protected (see next lesson) has package scope.
• All methods of all classes of a package can access it.
• Caution: Package scope is open-ended. Any class can add itself to (almost) any package.
• This Window class is in the java.awt package:

  public class Window extends Container
  {
     String warningString;
     . . .
  }

• In Java ≤ 1.1, I was able to add my own class like this:

  package java.awt;
  ...
  window.warningString = "Trust me!";
  

• No longer possible—java and javax packages enjoy special protection.
• You can seal packages in a JAR file.

The Class Path

• Class path=list of directories and JAR files.
• JAR file=zip file containing class files.
• Directories are base directories, containing package directories (such as com/horstmann/corejava).
• Class path elements are separated by : (Unix) or ; (Windows).
• Can include current directory as .
• Can specify all JAR files in a directory as directory/*
  • Caution: In Unix, must escape * as '*' or \*
• Pass to javac/java with -classpath option:

  java -classpath /home/user/classdir:.:/home/user/archives/archive.jar MyProg
  

• Or set CLASSPATH environment variable:

  export CLASSPATH=/home/user/classdir:.:/home/user/archives/archive.jar

Java 9 News Flash - Modules

• Modules are collections of packages.
• Implementation packages can be encapsulated.
• “Package private” features are not visible outside the module.
• An important feature for programming in the large.
• See Lesson 6 of Core Java 9 Advanced LiveLessons.

Use the javadoc utility to produce class documentation

Documentation Comments

• Add comments delimited by /** ... */ to source files.
• javadoc tool generates HTML documentation.
• Can document:
  • Packages
  • Public classes and interfaces
  • Public and protected fields, constructors, and methods
• The first sentence should be a summary statement.
• Can use HTML tags such as <em>...</em> for formatting.
• For code, use {@code ...} so you don't have to escape < characters.
• Place images into doc-files subdirectory.

Method Comments

/**
* Raises the salary of an employee. 
* @param byPercent the percentage by which to raise the salary (e.g. 10 means 10%)
* @return the amount of the raise
*/
public double raiseSalary(double byPercent)
{
   double raise = salary * byPercent / 100;
   salary += raise;
   return raise;
}

Class and Field Comments

/**
 * A {@code Card} object represents a playing card, such
 * as "Queen of Hearts". A card has a suit (Diamond, Heart,
 * Spade or Club) and a value (1 = Ace, 2 . . . 10, 11 = Jack,
 * 12 = Queen, 13 = King)
 */
public class Card
{
   /**
    * The "Hearts" card suit
    */
   public static final int HEARTS = 1;
   ...
}

Other Comments

• @author name
• @version text
• @since text
• @deprecated text
• @see reference
  • package.class#feature, such as com.horstmann.corejava.Employee#raiseSalary(double)
  • <a href="...">...</a>
  • "text"
• Can include {@link package.class#feature} anywhere in a comment.
• Place package comments in package-info.java, inside /** ... */ preceding a package statement.
• Overview comment is taken from overview.html.

Comment Extraction

• Change to the source directory.
• Run:

  javadoc -d docDirectory nameOfPackage1 nameOfPackage2 ...

• To link to online API, add this option:

  -link http://docs.oracle.com/javase/8/docs/api

• Many additional options: http://docs.oracle.com/javase/8/docs/technotes/guides/javadoc/

Design classes effectively

Class Design Hints

• Always keep data private.
• Always initialize data.
• Don't use too many basic types in a class:

  public class Customer { private String street; private String city; private String state; private int zip; ... }

  ⇒

  public class Customer { private Address shippingAddress; ... }

• Not all fields need field accessors and mutators:

  public class Address
  {
     ...
     private int zip;
     public void setZip(int newZip) { zip = newZip; }
     ...
  }
  

Class Design Hints

• Break up classes that have too many responsibilities:

  public class CardDeck // bad design { private int[] value; private int[] suit; ... public void shuffle() { . . . } public int getTopValue() { . . . } public int getTopSuit() { . . . } public void draw() { . . . } }

  ⇒

  public class CardDeck { private Card[] cards; ... public void shuffle() { . . . } public Card getTop() { . . . } public void draw() { . . . } } public class Card { private int value; private int suit; ... public int getValue() { . . . } public int getSuit() { . . . } }

• Make the names of your classes and methods reflect their responsibilities.
• Prefer immutable classes.