Question

Write a program to pack boxes with blobs. Write two classes and a driver program.

A Blob class

implements the following interface. (Defines the following methods.)
public interface BlobInterface {
/** getWeight accessor method.
@return the weight of the blob as a double
*/
public double getWeight();
/** toString method
@return a String showing the weight of the Blob
*/
public String toString();
}

A Blob must be between 1 and 4 pounds, with fractional weights allowed.

A default constructor creates a Blob with a weight of 2 pounds.

A one-double-parameter constructor creates a Blob with that many pounds, or throws an IllegalArgumentException if the weight is less than 1 or greater than 4 pounds.

A Box class

implements the following interface. (Note that, since the Blob class implements BlobInterface, then a Blob is a BlobInterface, so a Blob can be passed to the insert method below.)
public interface BoxInterface {
/** insert inserts a Blob into the box
@param b the Blob to insert
@return true if the blob fits, or false if it doesn't
*/
public boolean insert(BlobInterface b);

/** remainingCapacity accessor method
@return the remaining capacity of the box (how many more pounds it can hold).
*/
public double remainingCapacity();

/** toString
@return a String listing all of the Blobs in the Box, followed by the total weight
*/
public String toString();
}

A default constructor gives a Box capable of holding up to 25 pounds of Blobs.

An one-int-parameter constructor creates a Box capable of holding that number of pounds, but throws an IllegalArgumentException for 0 or negative arguments.

The driver program should

Instantiate 5 25-pound-capacity Boxes and

30 Blobs with weights that are random doubles from 1 to 4 (Math.random()*3+1).

Put the 30 Blobs into the boxes, filling the first box, then the second, etc., and then printing out each box.

Every Blob that is instantiated must be inserted into a Box.

The driver may be a console or GUI application.

Note that the driver program might not use some of the methods or constructors. You should define them anyway. Also, use ArrayLists rather than arrays.

Answer 1

Here is your program.

Code (Screenshot: Blob.java)

package com.masoomyf public class Blob implements BlobInterface //for storing it's weight. //if weight never change in future, add keyword final private double weight; //Default constructor public Blob ) f weight-2.0 //Constructor with weight parameter. public Blob (double weight) /Checking if the param weight is less than 1 or more than 4 //If yes throw the exception. if (weight <1 II weight> 4) 1 throw new IllegalArgumentException ) //assign this weight from parameter. this.weight -weight //Interface method, return the weight of blob. @Override public double getWeightO return weight: //Interface method, return weight to pound @Override public String tostring) return ""weight + " pound"; //You can use this for nice output like 23.25 pound, // instead of 23.256365962010555 pound // return string.format("%.2f pound", weight);

Box.java

ava.util.azzayLict ovs.util.ict toin hlub ee to u :(capacity 01 cepacity: w cen tha capacity ining ap builon .app Ld(''ELob ./.app.ndゆ1cb.tcStelag(11 botlce-.eppend builenz.appurd"Tot.al Wi

Main.java (Driver class)

package com.masoomy import java.util.ArrayList: import java.util.List: public class Main ( public static void main(Stringi] args) //Creating box list. Tist<Box> boxList new ArrayList<>) //Crcating blob list. List<Blob> blobList-now ArrayList<>() //Addding s //auto make it's capacity to 25 pound for (int i-0;iK5;i++) boxes to boxtist with defauit constructor, that boxlist.add (new Box)) //Adding 30 blob to bloblist, with random value between 1-4; for (int i-0:1<30;i++) Blob blob - new Blob( weight: (Math.random) 3) +1) blobList.add (blob) //Flag the current box uses. int boxInUseindex0 //Loop through each blob to insert into box. for (Blob blob:blobList) //Flag first the current blob is not added. boolean isAdded -false //Run while loop until it add. while (isAdded) [ //add the current blob to box having index boxTnUseTndex. //TF it is successful, isAdded become true and while loop break, //And next blob comes. isAdded -boxList.get (boxTnUseIndex).insert (blob) if ( ! İsAdded) { //If not successfulL, // incrcasc the box indox by 1. (mcans next box) boxInUscInaex++ //Now loop through box and print its item(blob) for (Box box:boxList) System.out.println (box.tostring0) System.out.println ("") //Adced two blank line for clear output

Code (Text Version)

BlobInterface.java

public interface BlobInterface {
    double getWeight();
    String toString();

}

BoxInterface.java

public interface BoxInterface {
    boolean insert(BlobInterface b);
    double remainingCapacity();
    String toString();
}

Blob.java

package com.masoomyf;

public class Blob implements BlobInterface {

    //for storing it's weight.
    //if weight never change in future, add keyword final
    private double weight;

    //Default constructor
    public Blob(){
        weight = 2.0;
    }


    //Constructor with weight parameter.
    public Blob(double weight) {
        //Checking if the param weight is less than 1 or more than 4.
        //If yes throw the exception.
        if(weight <1 || weight > 4){
            throw new IllegalArgumentException();
        }
        //assign this weight from parameter.
        this.weight = weight;
    }


    //Interface method, return the weight of blob.
    @Override
    public double getWeight() {
        return weight;
    }


    //Interface method, return weight to pound.
    @Override
    public String toString() {
        return "" + weight + " pound";
        //You can use this for nice output like 23.25 pound,
        // instead of 23.256365962010555 pound.
        // return String.format("%.2f pound",weight);
    }
}

Box.java

import java.util.ArrayList;
import java.util.List;

/**
 * com.masoomyf created by masoomyf on 26-01-2018.
 */
public class Box implements BoxInterface {

    //Storing capacity, assume that it will never change, once assigned.
    private final double capacity;
    //For storing the currently use space.
    //It will increase when new blob will add.
    private double usedSpace;

    //For storing blob
    private List<Blob> blobs;


    //Default constructor which assign capacity to 25
    //initialize blob's array list.
    //and assign used space to 0.
    public Box(){
        capacity = 25.0;
        blobs = new ArrayList<>();
        usedSpace = 0;
    }

    //Constructor with param capacity, which is integer as state in question.
    public Box(int capacity){
        //check is capacity is non-zero and non-negative.
        //if not throw new IllegalArgumentException.
        if(capacity <= 0){
            throw new IllegalArgumentException();
        }
        //Initialize this capacity with parameter one.
        this.capacity = capacity;

        blobs = new ArrayList<>();
        usedSpace = 0;
    }



    //Interface method.
    @Override
    public boolean insert(BlobInterface b) {
        //check if currently used space + blob weight which is to be add is
        //not more than the capacity.
        //If it is, return false.
        if(usedSpace+b.getWeight() > capacity)
            return false;

        //Else
        //Add the blob by casting it to Blob.
        //because parameter giving the blob but in BlobInterface type.
        //So cast it.
        blobs.add((Blob) b);
        //Add the blob weight to usedSpace.
        usedSpace += b.getWeight();
        //Return true, means blob is added.
        return true;

    }

    //Override method, return the remaining capacity.
    @Override
    public double remainingCapacity() {
        return capacity-usedSpace;
    }


    //To string method. (interface method)
    //It is also default override method for all object.
    @Override
    public String toString() {
        //Create new StringBuilder.
        //String builder can easily build string from many parts of string, integer etc.
        //Better to use stringBuilder rather than String s = "test";
        //s = s + "test1";   It's a bad practise and take more memory.

        StringBuilder builder = new StringBuilder();

        //Loop through each blob and print it's weight.
        //By using blob.toString() method, override at Blob.
        for (int i = 0; i < blobs.size(); i++) {
            Blob blob = blobs.get(i);
            builder.append("Blob ").append(blob.toString());
            //Check if it is last blob.
            //If yes put "." else put ", "
            if(i == blobs.size() - 1)
                builder.append(".");
            else
                builder.append(", ");
        }

        //Finally add the total weight to string builder.
        builder.append("Total Weight: ").append(usedSpace);

        //Now build the string and return it.
        return builder.toString();
    }
}

Main.java

import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        //Creating box list.
        List<Box> boxList = new ArrayList<>();
        //Creating blob list.
        List<Blob> blobList = new ArrayList<>();

        //Addding 5 boxes to boxList with default constructor, that will
        //auto make it's capacity to 25 pound.
        for (int i=0;i<5;i++)
            boxList.add(new Box());

        //Adding 30 blob to blobList, with random value between 1-4;
        for (int i=0;i<30;i++){
            Blob blob = new Blob((Math.random() * 3) + 1);
            blobList.add(blob);
        }

        //Flag the current box uses.
        int boxInUseIndex = 0;

        //Loop through each blob to insert into box.
        for (Blob blob:blobList){
            //Flag first the current blob is not added.
            boolean isAdded = false;
            //Run while loop until it add.
            while (!isAdded){
                //add the current blob to box having index boxInUseIndex.
                //If it is successful, isAdded become true and while loop break,
                //And next blob comes.
                isAdded = boxList.get(boxInUseIndex).insert(blob);
                if(!isAdded){
                    //If not successful,
                    // increase the box index by 1. (means next box)
                    boxInUseIndex++;
                }
            }

        }

        //Now loop through box and print its item(blob).
        for (Box box:boxList){
            System.out.println(box.toString());
            System.out.println("\n"); //Added two blank line for clear output.
        }
    }
}

Output

"C:\Program Files\Javaljdkl.8.0 20 bin\java" Blob 3.700415279098494, Blob 3.214989801203669, Blob 1.0619436527578667, Blob 1.0840011000586212, Blob 3.7220618334620386, Blob 2.694604670670343, Blob 3.406905964281622, Blob 1.1620968159330904, Blob 3.9593812284591636·Total Weight: 24.00640034592491 Blob 1.772094835951365, Blob 2.7039754479717732, Blob 1.7502800452842986, Blob 1.6182421785314747, Blob 2.9615451062582507, Blob 2.7734785162259814, Blob 3.670557263578909, Blob 2.3543803522577473, Blob 3.4322066063979353·Total Weight: 23.036760352457733 Blob 3.2295922173916094, Blob 3.7730573431097283, Blob 3.450797085408225, Blob 3.5884040412494826, Blob 3.245396626363852, Blob 2.6128808423246754, Blob 2.934373599756444·Total Weight: 22.834501755604016 Blob 2.6591769419990796, Blob 3.259446976430963, Blob 1.277049324928393, Blob 1.7083305794928396, Blob 2.5156422801023997.Total Weight: 11.419646002953675 Iotal Weight: 0.0 Process finished with exit code 0