• What is a class?
  A definition of a set that is written in terms of the properties of the elements (i.e., an intensive definition of a set)
  The set of elements so defined
• What is an enum?
  An extensive definition of a set
  The set of elements so defined
• What is an object?
  An element of the set

• Definition:
  • An abstract class is a class that can't have any instances (i.e., one can't, even conceptually, create instances of an abstract class)
• An Obvious Question:
  • Why have a class if you can't create any instances of it?
• A Conceptual Answer:
  Definitions of things, even things that don't exist, can help us understand complex systems and organize elements of those systems

• An Important Practical Rationale:
  • Abstract classes can be used to reduce code duplication (i.e., if multiple classes require the same functionality then it can be put in an abstract base class)
• A Question:
  • Isn't that what specialization is for?
• An Answer:
  Yes, but sometimes you want to prevent the creation of instances of the base class

• Concrete Methods:
  • Methods that include both a declaration and a body (i.e., an implementation)
• Abstract Methods:
  • Methods that include only a declaration

• In Abstract Classes:
  • Abstract classes may or may not contain abstract methods (i.e., methods that have not been implemented)
  • Abstract methods may be overloaded
  • Abstract methods in abstract classes may be called by concrete methods in the abstract class
• In Concrete Classes:
  • A concrete class may not have abstract methods

• In Abstract Classes:
  • In principle, abstract classes need not contain concrete methods
  • In practice, abstract classes should contain at least one concrete method (because there is a better way to achieve the goals of an abstract class with all abstract methods)
• In Concrete Classes:
  • Concrete methods in concrete classes can implement abstract methods and override concrete methods

• A Likely Question If You Know About Both:
  • Isn't an interface just an abstract class in which all of the methods are abstract?
• An Answer:
  • They are similar, but interfaces don't involve inheritance and, hence, are simpler and more flexible

• Visualization of Abstract Classes:
  • The name of an abstract class is italicized
  • The declaration of an abstract method is italicized
• Conventions:
  • A concrete subclass (typically) does not explicitly list the abstract methods it implements from its abstract superclass

• Syntax of an Abstract Class:
  • accessibility abstract class name { body }
• Syntax of an Abstract Method:
  • accessibility abstract type name([parameter...]);

• The Setting:
  • We have a variety of different classes for different media (e.g., images, audio, video)
  • Objects in every class have an author, a creation date, and a title
  • The methods needed to manipulate these attributes do not vary from class to class
  • The method used to "show" a particular object is medium-specific
• The Abstract Class:
  • 

• A Question:
  • Why do we need the abstract modifier, couldn't we just not have constructors?
• Some Answers:
  • It's not very elegant
  • Java adds a default constructor if there are no constructors
  • Sometimes we want abstract classes to have constructors (as we'll see in a moment)
• A Better Question:
  • Why do we need the abstract modifier, couldn't we just make the constructors private?
• Some Answers:
  • The abstract modifier is more direct/straightforward
  • private constructors are used for other purposes along with factory methods (more on this later)

• The Seeming Contradiction:
  • A constructor is for creating instances of the classes but abstract classes can't be instantiated
• Rationale:
  • Derived classes may need to perform the same construction-related tasks
• Remember:
  • Constructors in derived classes should call a specific constructor in the base class (or the default constructor will be called)

javaexamples/oopbasics/AbstractContent.java

import java.util.*;

/**
 * An abstract "piece of" content that will be extended 
 * to create concrete media (e.g., Image, VideoClip)
 *
 * @version 1.0
 * @author  Prof. David Bernstein, James Madison University
 */
public abstract class AbstractContent
{
    private Date   creationDate;
    private String author, title;



    /**
     *  "Constructs" a new AbstractContent
     *  (Note: This method should be called by the 
     *  constructor of all child classes)
     */
    protected AbstractContent()
    {
        creationDate = new Date();
    }

    /**
     * Returns the author of this AbstractContent
     */
    public String getAuthor()
    {
        return author;
    }

    /**
     * Returns the creation date
     */
    public Date getCreationDate()
    {
        return creationDate;
    }

    /**
     * Returns the title of this AbstractContent
     */
    public String getTitle()
    {
        return title;
    }


    /**
     *  Show/play/render this AbstractContent
     */
    public abstract void show();


    /**
     * Sets the author of this AbstractContent
     */
    public void setAuthor(String author)
    {
        this.author = author;
    }


    /**
     * Sets the title of this AbstractContent
     */
    public void setTitle(String title)
    {
        this.title = title;
    }
}
        

• Descendants of Abstract Classes:
  • Abstract classes can have concrete derived classes -- a concrete derived class must implement all abstract methods in the base class
  • Abstract classes can have abstract derived classes (in fact, if a derived class doesn't implement all of the abstract methods in the base class it must be declared abstract)
• Abstract Descendants of Concrete Classes:
  • Concrete classes can have abstract derived classes (indeed, all classes, including abstract classes, extend Object which is concrete)

• The Setting:
  • Each day, all financial securities have an opening price, a high price, a low price, a closing price and a volume (the number bought and sold)
  • A "stock" is a financial security that has a ticker symbol that represents the name of the company (e.g., Microsoft's ticker symbol is MSFT)
  • A "future" is a financial security that has a ticker symbol that represents the commodity (e.g., the Australian Dollar's ticker symbol is AD) and the future delivery date (e.g., December is Z). For example, a futures contract with the symbol AD2016Z is a promise to buy/sell Australian Dollars in December of 2016.
• The Classes in UML:
  • 

javaexamples/oopbasics/finance/SecurityQuotation.java

import java.util.Calendar;
import java.util.GregorianCalendar;


/**
 * An abstract SecurityQuotation (extended by StockQuotation, 
 * FutureQuotation, etc...).
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public abstract class SecurityQuotation
{
    protected GregorianCalendar   date;
    protected double              open, high, low, close;
    protected int                 volume;
    

    /**
     * Explicit Value Constructor.
     *
     * @param date      The date of the entry
     * @param open      The opening price
     * @param high      The high price
     * @param low       The low price
     * @param close     The closing price
     * @param volume    The volume traded
     */
    protected SecurityQuotation(GregorianCalendar date, 
                                double open,double high,double low,double close,
                                int volume)
    {
       this.date = date;
       this.open = open;
       this.high = high;
       this.low = low;
       this.close = close;
       this.volume = volume;
    }
    
    /**
     * Return the closing price.
     *
     * @return    The closing price
     */
    public double getClose()
    {
       return close;
    }

    /**
     * Return the date.
     *
     * @return    The date of this quotation
     */
    public GregorianCalendar getDate()
    {
       return date;
    }

    /**
     * Return the high price.
     *
     * @return    The high price
     */
    public double getHigh()
    {
       return high;
    }

    /**
     * Return the low price
     *
     * @return    The low price
     */
    public double getLow()
    {
       return low;
    }

    /**
     * Return the opening price.
     *
     * @return    The opening price
     */
    public double getOpen()
    {
       return open;
    }

    /**
     * Return the ticker symbol.
     */
    public abstract String getSymbol();
        

    /**
     * Returns the volume.
     *
     * @return    The volume
     */
    public int getVolume()
    {
       return volume;
    }

    /**
     * Return a String representation.
     *
     * @return   The String representation
     */
    public String toString()
    {
        return getSymbol() + "\t" +
            (date.get(Calendar.MONTH)+ 1) + "/" +
            date.get(Calendar.DAY_OF_MONTH) + "/" +
            date.get(Calendar.YEAR) +
            "\tO: " + open + "\tH: " + high +
            "\tL: " + low + "\tC: " + close + 
            "\tV: " + volume;
    }
}
        

• An Important Observation:
  • The toString() method sends the getSymbol() message to this (i.e., the abstract getSymbol() method is called in the concrete toString() method)
• What Happens?
  • At Compile Time - The compiler checks syntax (i.e., is the signature correct?)
  • At Run Time - Dynamic binding
• Why Is This OK?
  • this refers to an object that was instantiated, so it must be an element of a concrete class, it must have an implementation

This class adds a ticker symbol attribute. Since it is a concrete class, it must implement the getSymbol() method.

javaexamples/oopbasics/finance/StockQuotation.java

import java.util.GregorianCalendar;


/**
 * A stock quotation (i.e., open, high, low, close and  volume).
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class StockQuotation extends SecurityQuotation
{
    protected String           symbol;


    /**
     * Explicit Value Constructor.
     *
     * @param symbol    The ticker symbol of the stock
     * @param date      The date of the entry
     * @param open      The opening price
     * @param high      The high price
     * @param low       The low price
     * @param close     The closing price
     * @param volume    The volume traded
     */
    public StockQuotation(String symbol, GregorianCalendar date, 
                          double open,double high,double low,double close,
                          int volume)
    {
        super(date, open, high, low, close, volume);
        this.symbol = symbol;
    }

    /**
     * Return the ticker symbol (required by SecurityQuotation).
     *
     * @param symbol     The ticker symbol
     */
    public String getSymbol()
    {
        return symbol;
    }
}
        

This class adds an attribute for the open interest, the code for the commodity, and the month and year of the contract. It also adds an accessor for the open interest and, since it is concrete, implements the getSymbol() method.

javaexamples/oopbasics/finance/FutureQuotation.java

import java.util.GregorianCalendar;

/**
 * A future's contract quotation (i.e., open, high, low, close,
 * volume, and open interest).
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class FutureQuotation extends SecurityQuotation
{
    protected int              openInterest;
    protected String           commodity, month, year;

    /**
     * Explicit Value Constructor.
     *
     * @param commodity The commodity code
     * @param year      The year code
     * @param month     The month code
     * @param date      The date of the entry
     * @param open      The opening price
     * @param high      The high price
     * @param low       The low price
     * @param close     The closing price
     * @param volume    The volume traded
     */
    public FutureQuotation(String commodity, String year, String month, 
                           GregorianCalendar date, 
                           double open,double high,double low,double close,
                           int volume, int openInterest)
    {
        super(date, open, high, low, close, volume);

        this.commodity    = commodity;
        this.year         = year;
        this.month        = month;
        this.openInterest = openInterest;
    }

    /**
     * Return the open interest for this security.
     *
     * @return  The open interest
     */
    public int getOpenInterest()
    {
        return openInterest;
    }

    /**
     * Return the symbol for this security.
     *
     * @param symbol     The ticker symbol for this stock
     */
    public String getSymbol()
    {
        return commodity + year + month;        
    }

    /**
     * Return a String representation.
     *
     * @return   The String representation
     */
    public String toString()
    {
        return (super.toString()+"\tOI: " + openInterest);
    }
}
        

• Polymorphism:
  • Abstract classes must behave in exactly the same way as concrete classes
• Methods:
  • Can't be both abstract and static since an abstract method must be bound dynamically (and, as you can tell from the modifier, static methods aren't)