无法在接口的子类中实现方法

Question

我知道这是作业，所以这可能听起来很奇怪。现在我试图摆脱编译错误，说池必须实现抽象方法。池由BackYard接口实现，而deck是池的子类，而bollards是deck的子类。我不允许更改驱动程序类中显示输出方法中的代码，我不允许更改卡座或系柱中的代码。编译器一直坚持我重新编码池中的所有子类方法或者使用池抽象，我也做不到。我究竟需要解决什么问题。如果我真的需要在Backyard接口中编写所有get方法

，请告诉我

这是驱动程序类：

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*/


}

这是BackYard界面：

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();
}

这是池类

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

之前签了合约？

此代码：

public class Pool implements BackYard

就像一个。这就像游泳池对 Backyard 说：“ Hey Backyard，我签了一份合同，保证我会为你拥有的所有方法创建代码。“

但是Pool违反了合同。

警察（编制者）发现并说：做好友或让你的孩子这样做。

要么你自己完成合同（即为Backyard中提到的所有方法创建代码），要么让你的后代成为完成它的人（子类将是添加代码的子类）。你有点“受到惩罚” - 让你处于抽象状态直到承诺完成。

Answer 2

第一个具体类必须从其超类型实现所有抽象方法。在你的情况下，你要么使用Pool摘要，所有都是从尚未实现的超类型实现所有抽象方法。

换句话说，如果你不允许抽象类Pool有抽象方法，那么你的库的客户端可以做

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

哪个不行，因为这个方法没有实现。另一方面，如果你将Pool抽象化，则不允许实例化它，并且不会出现上述问题。

Answer 3

您必须在BackYard类

内创建Pool中看到的所有方法