Scribd Logo
Upload

Welcome to Scribd!

  • 67 views

    Sections 14.1-14.7: Comparable) Modify The

    Uploaded by

    Irene Sultana
    The document describes exercises to modify and extend existing geometric shape classes to implement the Comparable interface and enable comparison of objects. It involves: 1. Modifying the GeometricObject class to implement Comparable and add a max method to find the larger of two objects. 2. Creating a ComparableCircle class that extends Circle and implements Comparable to compare circles based on area. 3. Designing a Colorable interface and Square class to demonstrate interfaces.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd

    Sections 14.1-14.7: Comparable) Modify The

    Uploaded by

    Irene Sultana
    67 views4 pages
    The document describes exercises to modify and extend existing geometric shape classes to implement the Comparable interface and enable comparison of objects. It involves: 1. Modifying the GeometricObject class to implement Comparable and add a max method to find the larger of two objects. 2. Creating a ComparableCircle class that extends Circle and implements Comparable to compare circles based on area. 3. Designing a Colorable interface and Square class to demonstrate interfaces.

    Original Title

    abstarctCassesandInterfaces

    Copyright

    © © All Rights Reserved

    Available Formats

    DOCX, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document describes exercises to modify and extend existing geometric shape classes to implement the Comparable interface and enable comparison of objects. It involves: 1. Modifying the GeometricObject class to implement Comparable and add a max method to find the larger of two objects. 2. Creating a ComparableCircle class that extends Circle and implements Comparable to compare circles based on area. 3. Designing a Colorable interface and Square class to demonstrate interfaces.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    67 views4 pages

    Sections 14.1-14.7: Comparable) Modify The

    Uploaded by

    Irene Sultana
    The document describes exercises to modify and extend existing geometric shape classes to implement the Comparable interface and enable comparison of objects. It involves: 1. Modifying the GeometricObject class to implement Comparable and add a max method to find the larger of two objects. 2. Creating a ComparableCircle class that extends Circle and implements Comparable to compare circles based on area. 3. Designing a Colorable interface and Square class to demonstrate interfaces.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    of 4

    Sections 14.1–14.

    7
    14.1* (Enabling GeometricObject comparable) Modify the GeometricObject
    class to implement the Comparable interface, and define a static max method in
    the GeometricObject class for finding the larger of two GeometricObject
    objects. Draw the UML diagram and implement the new GeometricObject
    class. Write a test program that uses the max method to find the larger of two circles
    and the larger of two rectangles.

    package
    exercise1
    ;
    /** SimpleGoemetricObject UML
    * -------------------------------------
    * -color: String +s +g
    * -filled: boolean +s +g
    * -dateCreated: Date +g
    * -------------------------------------
    * +SimpleGeoMetricObject()
    * +SimpleGoometricObject(color: String, filled: boolean)
    * +toString(): String
    * -------------------------------------
    *
    * @author Amadeusz
    *
    */
    public abstract class SimpleGeometricObject {
    private String color = "white";
    private boolean filled;
    private java.util.Date dateCreated;

    /** Construct a default geometric object */


    public SimpleGeometricObject() {
    dateCreated = new java.util.Date();
    }
    /** Construct a geometric object with the specified color
    * and filled value */
    public SimpleGeometricObject(String color, boolean filled) {
    dateCreated = new java.util.Date();
    this.color = color;
    this.filled = filled;
    }
    /** Return color */
    public String getColor() {
    return color;
    }

    /** Set a new color */


    public void setColor(String color) {
    this.color = color;
    }

    /** Return filled. Since filled is boolean,


    its getter method is named isFilled */
    public boolean isFilled() {
    return filled;
    }

    /** Set a new filled */


    public void setFilled(boolean filled) {
    this.filled = filled;
    }

    /** Get dateCreated */


    public java.util.Date getDateCreated() {
    return dateCreated;
    }

    /** Return a string representation of this object */


    public String toString() {
    return "created on " + dateCreated + "\ncolor: " + color
    +
    " and filled: " + filled;
    }
    }
    14.2* (The ComparableCircle class) Create a class named ComparableCircle that
    extends Circle and implements Comparable. Draw the UML diagram and
    implement the compareTo method to compare the circles on the basis of area.
    Write a test class to find the larger of two instances of ComparableCircle
    objects.

    package
    Chapter_13.Chapter_Classes
    ;
    import Chapter_10.Chapter_Classes.Circle2D;
    public class ComparableCircle extends Circle2D implements
    Comparable<ComparableCircle> {
    // default no-arg constructor invoked from superclass
    public ComparableCircle(){
    }

    // args constructor invoked from superclass


    public ComparableCircle(double x, double y, double
    radius){
    super(x, y, radius);
    }

    @Override
    public int compareTo(ComparableCircle o) {
    if (getArea() > o.getArea()){
    return 1;
    } else if(getArea() < o.getArea()){
    return -1;
    } else {
    return 0;
    }
    }

    /** Overrided method allows to check if two objects


    * of ComparableCircle class are equals */
    @Override
    public boolean equals(Object obj) {
    return (obj instanceof ComparableCircle &&
    this.getRadius() == ((ComparableCircle) obj).getRadius());
    }
    /** Returns max from 2 objects using compareTo method
    (Comparable interface) */
    public static ComparableCircle max(ComparableCircle c1,
    ComparableCircle c2){
    if (c1.compareTo(c2) >= 0){
    return c1;
    } else{
    return c2;
    }
    }
    }

    14.3* (The Colorable interface) Design an interface named Colorable with a void
    method named howToColor(). Every class of a colorable object must implement
    the Colorable interface. Design a class named Square that extends
    GeometricObject and implements Colorable. Implement howToColor to
    display a message "Color all four sides".
    Draw a UML diagram that involves Colorable, Square, and GeometricObject.
    Write a test program that creates an array of five GeometricObjects.
    For each object in the array, invoke its howToColor method if it is
    colorable.
    14.4* (Revising the House class) Rewrite the House class in Listing 14.9 to perform a
    deep copy on the whenBuilt field.
    14.5* (Enabling Circle comparable) Rewrite the Circle class in Listing 14.2 to extend
    GeometricObject and implement the Comparable interface. Override the
    equals method in the Object class. Two Circle objects are equal if their radii
    are the same. Draw the UML diagram that involves Circle, GeometricObject,
    and Comparable.
    14.6* (Enabling Rectangle comparable) Rewrite the Rectangle class in Listing 14.3
    to extend GeometricObject and implement the Comparable interface. Override
    the equals method in the Object class. Two Rectangle objects are equal
    if their areas are the same. Draw the UML diagram that involves Rectangle,
    GeometricObject, and Comparable.
    14.7* (The Octagon class) Write a class named Octagon that extends GeometricObject
    and implements the Comparable and Cloneable interfaces. Assume that all eight
    sides of the octagon are of equal size. The area can be computed using the following
    formula:
    Draw the UML diagram that involves Octagon, GeometricObject,
    Comparable, and Cloneable. Write a test program that creates an Octagon
    object with side value 5 and displays its area and perimeter. Create a new
    object using the clone method and compare the two objects using the
    compareTo method.

    You might also like