Can't implement methods in Subclasses from interface

Question

I know this is homework so this may sound weird. Right now I am trying to get rid of a compile error saying pool must implement abstract methods. Pool is implemented by the BackYard interface, while deck is a subclass of pool and bollards is a subclass of deck. I am not allowed to change the code in the display output method in the driver class and I am not allowed to change code in deck or bollards. The compiler keeps insisting that I recode all the subclass methods in pool or make pool abstract which I can't do either. What exactly do I need to fix. Also let me know if I really needed to code all the get methods in the Backyard interface

Here is the driver class:

public class YardOrders 
{
        //Constants
        final static int POOL_ONLY = 1;
        final static int POOL_N_DECK=2;
        final static int POOL_DECK_N_BOLLARD=3;
        final static int DISPLAY_ORDERS=4;
      final static int DEFAULT_INT=0;

      //Methods
        public static void main(String[] args) 
        {
            int numberOfOrders=DEFAULT_INT;
            BackYard backYard[] = new BackYard[100];
            int selection = DEFAULT_INT;
             do
             {
                 selection = Integer.parseInt(JOptionPane.showInputDialog(null,       
                            "Options:\nEnter "+ POOL_ONLY +" for a pool.\n" +                               
                            "Enter "+ POOL_N_DECK +
                            " for a pool and a concrete " +
                            "deck surrounding the pool.\n"+
                            "Enter "+POOL_DECK_N_BOLLARD+" for a pool," +
                            " deck, and bollards.\n"+
                            "Enter "+DISPLAY_ORDERS+" to display orders and exit.",
                            "Pool Options", JOptionPane.PLAIN_MESSAGE));
                    if(selection > DEFAULT_INT && selection < DISPLAY_ORDERS)
                    {

                            getPoolInput(backYard,numberOfOrders,selection);
                            numberOfOrders++;
                            System.out.println(numberOfOrders);
                    }
                    else if(selection==DISPLAY_ORDERS)
                    {
                        displayOrders(backYard,numberOfOrders);
                        System.out.println(numberOfOrders);
                        System.exit(DEFAULT_INT);
                    }
                    else
                    {
                        JOptionPane.showMessageDialog(null,"Invalid input. Values" +
                    " must be between 1 and 4.");
                    }
             }while(selection != DISPLAY_ORDERS);                                                   
        }     

        private static void getPoolInput(BackYard backYard[],int numberOfOrders,int selection)
        {
            //Pool attributes
            String lastName = JOptionPane.showInputDialog(null,
                    "Enter last name.\n","Last Name",
                    JOptionPane.PLAIN_MESSAGE);

            String firstName = JOptionPane.showInputDialog(null,
                    "Enter first name.","First Name",
                    JOptionPane.PLAIN_MESSAGE);

            double poolDepth = Double.parseDouble(
                    JOptionPane.showInputDialog(null,
                    "Enter pool depth in inches.","Pool Depth",
                    JOptionPane.PLAIN_MESSAGE)); //In inches.

            double poolDiameter = Double.parseDouble(
                    JOptionPane.showInputDialog(null,
                    "Enter pool diameter in feet.","Pool Diameter",
                    JOptionPane.PLAIN_MESSAGE));//In feet.
            if(selection == POOL_ONLY)
            {
              //Pool instantiation.

                backYard[numberOfOrders]= new Pool(lastName,firstName,
                            poolDepth,poolDiameter);
            }
            else
            {
                getDeckInput(backYard, 
                                numberOfOrders,selection,
                                        lastName,firstName,
                                        poolDepth, poolDiameter);
            }

        }//End of method

        private static void getDeckInput(BackYard[] backYard, 
                                                                         int numberOfOrders, int selection,
                                                                        String lastName, String firstName,
                                                                         double poolDepth, double poolDiameter)
        {
            //Deck attributes
            double deckLength=Double.parseDouble(
                    JOptionPane.showInputDialog(null,
                    "Enter deck length in feet.","Deck Length",
                    JOptionPane.PLAIN_MESSAGE));

            double deckWidth= Double.parseDouble(
                    JOptionPane.showInputDialog(null,
                    "Enter deck width in feet.","Deck Width",
                    JOptionPane.PLAIN_MESSAGE));
            if(selection==POOL_N_DECK)
            {

                backYard[numberOfOrders]= new Deck(lastName,firstName,
                                                                    poolDepth,poolDiameter,
                                                             deckLength,deckWidth);

            }
            else
            {
                getBollardInput(lastName,firstName,
                                                poolDepth,poolDiameter,
                                                deckLength,deckWidth);
            }
        }
        public static void getBollardInput(String lastName, String firstName,
                                                                         double poolDepth, double poolDiameter,
                                                                         double deckLength, double deckWidth)
        {
            //Bollard attributes
            double bollardHeight=Double.parseDouble(
                JOptionPane.showInputDialog(null,
                "Enter bollard height in inches.","Bollard Height",
                JOptionPane.PLAIN_MESSAGE));

            double bollardDiameter=Double.parseDouble(
                JOptionPane.showInputDialog(null,
                "Enter bollard diameter in incehs.","Bollard Diameter",
                JOptionPane.PLAIN_MESSAGE));

            int numberOfBollards=Integer.parseInt(
                JOptionPane.showInputDialog(null,
                "Enter the number of bollards.","Number of bollards",
                JOptionPane.PLAIN_MESSAGE));

            //Bollard instantiation
            Bollards bollards= new Bollards(lastName,firstName,
                    poolDepth,poolDiameter,
                    deckLength,deckWidth,
                    bollardHeight, bollardDiameter,
                    numberOfBollards);
        }

        private static void displayOrders(BackYard[] orders, int numberOfOrders)
        {
            DecimalFormat dec3 = new DecimalFormat("0.000");
            String divider = "******************************************************" +
                                             "***********\n";
            JTextArea textOut = new JTextArea(divider, 10, 30);
            JScrollPane scroller = new JScrollPane(textOut);

            for(int sub = 0; sub < numberOfOrders; sub++)
            {
                textOut.append("Customer Name: " + orders[sub].getLastName() + ", ");
                textOut.append(orders[sub].getFirstName() + "\n");
                textOut.append("Pool Depth:" +
                                            dec3.format(orders[sub].getInsideDepth()) + "\n");
                textOut.append("Pool Diameter: "+
                                            dec3.format(orders[sub].getInsideDiameter()) + "\n");
                textOut.append("Deck Width: " +
                                            dec3.format(orders[sub].getDeckWidth()) + "\n");
                textOut.append("Deck Length: " +
                                                dec3.format(orders[sub].getDeckLength()) + "\n");
                textOut.append("Number of Bollards Ordered: " +
                                                orders[sub].getNumberOfBollards() + "\n");
                textOut.append("Height of Bollards: " +
                                                dec3.format(orders[sub].getBollardHeight()) + "\n");
                textOut.append("Diameter of Bollards: " +
                                            dec3.format(orders[sub].getBollardDiameter()) + "\n");
                textOut.append("Cubic Yards of Concrete Needed: " +
                                            dec3.format(orders[sub].getConcreteVolume()) + "\n");
                textOut.append(divider);
            } // end for loop
            JOptionPane.showMessageDialog(null, scroller, "Orders Placed",
                                                                        JOptionPane.PLAIN_MESSAGE);
        } // end method DisplayOrders*/


}

Here is the BackYard interface:

public interface BackYard 
{
    //Universal constants 
        public static final int CU_IN_TO_CU_YD = 46656;
        public static final int FT_TO_IN = 12;
        public static final double DENSITY = 3.75; // in inches

        //Pool constants. 
        public static final String DEFAULT_NAME = "Unknown"; 
        public static final int DEFAULT_DIAM_DEPTH = 0;
        public static final int STANDARD_DEPTH = 24; // in inches
        public static final int STANDARD_DIAMETER = 6; // in feet
        public static final int MIN_DEPTH = 10; // in inches
        public static final int MAX_DEPTH = 72; // in inches
        public static final int MIN_DIAMETER = 3; // in feet
        public static final int MAX_DIAMETER = 25; // in feet

        //Deck constants
        public final static double MAX_DECK_LENGTH = 50.0; // in feet
        public static final double MAX_DECK_WIDTH = 50.0;  // in feet
        public static final int DEFAULT_WIDTH_AND_LENGTH = 0;

      //Bollard constants
        public static final double MAX_BOLLARD_HEIGHT = 60.0;  // in inches
        public static final double MIN_BOLLARD_HEIGHT = 24.0;  // in inches
        public static final double MAX_BOLLARD_DIAMETER = 18.0;  // in inches
        public static final double MIN_BOLLARD_DIAMETER = 3.0;  // in inches
        public static final int MIN_NUMBER_OF_BOLLARDS = 4; // units

        //Methods.
        public abstract String getLastName();
        public abstract String getFirstName();
        public abstract double getInsideDepth();
        public abstract double getInsideDiameter();
        public abstract  double getDeckWidth();
        public abstract double getDeckLength();
      public abstract int getNumberOfBollards();
      public abstract double getBollardHeight();
      public abstract double getBollardDiameter();
        public abstract double getConcreteVolume();
}

Here is the pool class

public class Pool implements BackYard
{
    // instance variable(s)
    private double insideDiameter; // in feet
    private double insideDepth; // in inches
    private String lastName;
    private String firstName;

    // class variable(s)
    public static int numberOfOrders;

    // Zero argument constructor.  Sets instance variables to default values
    public Pool()   
    {
        setInsideDiameter(DEFAULT_DIAM_DEPTH);
        setInsideDepth(DEFAULT_DIAM_DEPTH);
        setLastName(DEFAULT_NAME);
        setFirstName(DEFAULT_NAME);
    }

    // Two parameter constructor.  
    // Sets names to input values and measurements to standard values
    public Pool(String lastNameIn, String firstNameIn)
    {
        setInsideDiameter(STANDARD_DIAMETER);
        setInsideDepth(STANDARD_DEPTH);
        setLastName(lastNameIn);
        setFirstName(firstNameIn);
        numberOfOrders++;
    }   

    // Three parameter constructor.  
    // Sets names and depth to input values and diameter to standard value
    public Pool(String lastNameIn, String firstNameIn, double depthIn)
    {
        setInsideDiameter(STANDARD_DIAMETER);
        setInsideDepth(depthIn);
        setLastName(lastNameIn);
        setFirstName(firstNameIn);
        numberOfOrders++;
    }   

    // Three parameter constructor.  
    // Sets all instance variables to input values
    public Pool(String lastNameIn, String firstNameIn, double depthIn, 
        double diameterIn)
    {
        setInsideDiameter(diameterIn);
        setInsideDepth(depthIn);
        setLastName(lastNameIn);
        setFirstName(firstNameIn);
        numberOfOrders++;
    }   

    // returns depth
    public double getInsideDepth()
    {
        return insideDepth;
    }

    // validates input and sets depth
    public void setInsideDepth(double inDepth)
    {
        insideDepth =  ((inDepth >= MIN_DEPTH && 
                    inDepth <= MAX_DEPTH) ? inDepth : DEFAULT_DIAM_DEPTH);
    }

    // returns diameter
    public double getInsideDiameter()
    {
        return insideDiameter;
    }

    // validates diameter and sets diameter
    public void setInsideDiameter(double inDiameter)
    {
        insideDiameter = ((inDiameter >= MIN_DIAMETER && 
                    inDiameter <= MAX_DIAMETER) ? inDiameter : DEFAULT_DIAM_DEPTH);
    }

    // validates and sets last name
    public void setLastName(String lastNameIn)
    {
        lastName = ((lastNameIn.length()) > 0 ? lastNameIn : DEFAULT_NAME);
    }

    // returns last name
    public String getLastName()
    {
        return lastName;
    }

    // validates and sets first name
    public void setFirstName(String firstNameIn)
    {
        firstName = ((firstNameIn.length()) > 0 ? firstNameIn : DEFAULT_NAME);
    }

    // returns first name
    public String getFirstName()
    {
        return firstName;
    }

    // calculates total concrete necessary in cubic yards and returns that value
    @Override
    public double getConcreteVolume()
    {
        if(getInsideDiameter() == 0 || getInsideDepth() == 0)
            return 0.000;
        else
            return (getCylinderVolume(getInsideDiameter() * FT_TO_IN + DENSITY + 
                         DENSITY, getInsideDepth() + DENSITY) / CU_IN_TO_CU_YD) -
                       (getCylinderVolume(getInsideDiameter() * FT_TO_IN, 
                         getInsideDepth())) / CU_IN_TO_CU_YD;
    }

    // private utility method used to calculate the volume of a cylinder
    public double getCylinderVolume(double diameter, double height)
    {
        return (Math.PI * Math.pow(diameter / 2.0, 2)) * height;
    }
} //end class Pool

Answer 1

Ever signed a contract before?

This code:

public class Pool implements BackYard

is just like one. It's like Pool saying to Backyard: "Hey Backyard, I'm signing a contract that guarantees I'll create code for all the methods you have."

But Pool violated the contract.

The police (compiler) finds out about it and says: Do it buddy or make your kids do it.

Either you fullfil the contract yourself (i.e. create code for all methods mentioned in Backyard) or let your descendants be the ones to complete it (the subclasses will be the ones to add code). You're kind of "punished" - keeping you in an abstract state until the commitment is completed.

Answer 2

First concrete class must implement all abstract methods from its supertypes. In your case you either make Pool abstract, all implement all abstract methods from supertypes that are not already implemented.

In other words, If you allowed not abstract class Pool to have abstract methods, then client of your library could do

Pool p = new Pool();
p.getBollardHeight();

which cannot work, because this method is not implemented. If, on the other hand, you made Pool abstract, you would not be allowed to instantiate it and the problem above would not occur.

Answer 3

You must create all the methods you see in BackYard, inside the Pool class