有两个“ InstanceOf”的类？

Question

I am running into trouble writing code that requires a Fruit, a Banana, a Orange, a Edible, a Snowberry, and IceCream to be classes. In the test cases provided to me, I have to write code that makes a Orange and Banana to be an instanceof Fruit and Edible.

At this point my Banana and Orange should extend to an abstract class of Fruit.

public abstract class Fruit {

    protected String color;
    protected double weight;

    public Fruit (String color, double weight) {
        this.color = color;
        this.weight = weight;
    }

    public Fruit(double weight) {
        this.weight = weight;
    }

    public Fruit() {
    }

    public abstract double getWeight();

    public abstract String getColor();

    public abstract double getCalories();

    public boolean equals(Object fruit) {
        if ((this.getColor() == (((Fruit) fruit).getColor())&& (this.getWeight() == ((Fruit) fruit).getWeight()))) {
            return true;
        }
        else {
            return false;
        }
    }
}

public class Orange extends Fruit {

    private String color = "orange";

    public Orange (String color, double weight) {
        super("orange", weight);
    }

        public Orange (double weight) {
            super(weight);
        }

        public double getWeight() {
            return weight;
        }

        public String getColor() {
            return color;
        }

        public double getCalories() {
            return weight * 5.0;
        }
    }


public class Banana extends Fruit{

    private String color = "yellow";

    public Banana (String color, double weight) {
        super("yellow", weight);
    }

    public Banana (double weight) {
        super(weight);
    }

    public double getWeight() {
        return weight;
    }

    public String getColor() {
        return color;
    }   

    public double getCalories() {
        return weight * 10.0;
    }
}

Then, there is IceCream to be an "instanceof" my Edible. The IceCream extends to Edible, has no parameters in it's constructor, and has a getCalories() method to return 1000. From this information in the test case, I assume since it's an instance of the Edible class, the Edible class should also have no parameters in it's constructor as well?

After that, I have a Snowberry that extends to the Fruit class, has a super of "white" and .0117, a getCalories() that returns 1, and a getColor(), and getWeight() methods. The problem here is that I need to have Snowberry to be an instance of Fruit, but not an instance of Edible.

The following test case is having me stumped to write code for:

    public void test_IceCream() {
        IceCream ic = new IceCream();
        assertEquals(1000.0, ic.getCalories(), 0.0001);
        assertFalse(Fruit.class.isAssignableFrom(ic.getClass()));
        assertTrue(ic instanceof Edible);
    }

    public void test_Snowberry() {
        Snowberry sb = new Snowberry();
        assertEquals(0.117, sb.getWeight(), 0.0001);
        assertEquals("White", sb.getColor());
        assertFalse(sb instanceof Edible);
        assertTrue(sb instanceof Fruit);

From these test cases, I have got only IceCream to pass the JUnit3 test, but then run into trouble with the Banana and Orange to pass the test because it's not an instance of Edible:

 public void test_Orange() {
        Orange orange = new Orange(8);
        assertEquals(40.0, orange.getCalories(), 0.0001);
        assertTrue(orange instanceof Fruit);
        assertTrue(orange instanceof Edible);
    }

    public void test_Banana() {
        Banana banana = new Banana(5);
        Orange orange = new Orange(8);
        assertEquals(50.0, banana.getCalories(), 0.0001);
        assertTrue(banana instanceof Fruit);
        assertFalse(banana.getColor().equals(orange.getColor()));
        assertTrue(banana instanceof Edible);

As of now, my Edible class looks like this, because I am not sure how to approach this situation:

public abstract class Edible {

    public Edible() {
    }
}

Last thing to mention, is that the Edible class is required to be a class (I think) because there is a testcase that checks if it's a class, and it requires Edible to have No constructors.

    public void test_Edible() {
        try {
            // Edible should not have any constructor
            Class<Edible> clazz = Edible.class;
            Constructor<?>[] ctors = clazz.getConstructors();
            assertEquals(0, ctors.length);

            // but it should have a way to getCalories
            Method m = clazz.getMethod("getCalories", new Class[0]);
            assertNotNull(m);
            assertEquals(Double.TYPE, m.getReturnType());
        }
        catch (Exception e) {
            // not supposed to happen
            e.printStackTrace();
            fail(e.getMessage());
        }
    }

To conclude this, I would greatly appreciate any tips on what I should change in my Edible class to make sure that Snowberry is an instance of Fruit and not Edible, Banana and Orange to be an instance of Fruit and Edible, IceCream to be just an instance of Edible, and for Edible to have 0 constructors.

NOTES:

• I have tried extending Fruit to Edible, and got the Orange and Banana to completely pass the JUnit3 test, but then got stuck at Snowberry failing the test since it's a Fruit but not Edible.

• According to my professor, the Instructions never stated that Fruit has to be extended to Edible, but this has confused be because a class cannot extend to 2 other classes, so I'm not sure how to get Banana and Orange to be instance of Edible.

• A hint from the instruction (I'm not sure how this can help): "All Edible objects has a way of computing how many calories they contain".

• The topic covers: A Class Hierarchy with Abstraction and Interfaces. (There's more to this problem that isn't mentioned, like a way to compare different Calories among other items, and that would be the interface for all the classes mentioned here.

Sorry that this is a bit long, but I appreciate all the help I can get, and thank you taking the time to read all of this. I figured if I provide as much detail, that you all may understand what my problem is.

Answer 1

You have several types of Fruit , but those aren't all Edible . You also have things that aren't Fruit , but are still Edible . That means those types aren't related.

You are right that a class can only extend one other class, but there is another way. You already mentioned the Edible class as it currently is doesn't add any concrete functionality. That's a perfect use case for an interface instead instead of an abstract class.

The test case you mentioned allows this, because you can still refer to interface types as Class objects. This is also the only way to satisfy the "no constructors" requirement, as interfaces can't have constructors, but classes always have at least one. The test case also says your interface must define the getCalories method.