Two questions uppon a deitel's project

[Nick Petas]

I am reading a deitel book and I am in the chapter 26 about multithreading.
There is a project there with the following code :

SharedBufferTest.java

//Application with two threads manipulating an unsynchronized buffer.

package consumerproducer1;

//imports
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SharedBufferTest {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //create new thread pool with two threads
        ExecutorService application = Executors.newCachedThreadPool();

        //create UnsynchronizedBuffer to store ints
        Buffer sharedLocation = new UnsynchronizedBuffer();

        System.out.println("Action\t\tValue\tSum of Produced\tSum of Consumed");
        System.out.println("------\t\t-----\t---------------\t---------------");

        //execute the Producer and Consumer, giving each of them access to sharedLocation
        application.execute(new Producer(sharedLocation));
        application.execute(new Consumer(sharedLocation));

        application.shutdown(); //terminate application when tasks complete
    }//end main

}//end class SharedBufferTest

Buffer.java

//Buffer interface specifies methods called by Producer and Consumer

package consumerproducer1;

public interface Buffer
{
    //place int value into Buffer
    public void set(int value) throws InterruptedException;

    //return int value from Buffer
    public int get() throws InterruptedException;
}//end interface Buffer

Producer.java

//Producer with a run method that inserts the values 1 to 10 in buffer

package consumerproducer1;

//imports
import java.util.Random;


public class Producer implements Runnable{

    private final static Random generator = new Random();
    private final Buffer sharedLocation;    //reference to shared object

    //constructor
    public Producer(Buffer shared)
    {
        sharedLocation = shared;
    }//end Producer constructor

    //store values from 1 to 10 in sharedLocation
    public void run()
    {
        int sum = 0;

        for (int count = 1; count <= 10; count++)
        {
            try //sleep 0 to 3 seconds, then place value in Buffer
            {
                Thread.sleep(generator.nextInt(3000) ); //random sleep
                sharedLocation.set(count);  //set value in buffer
                sum += count;   //increment sum of values
                System.out.printf("\t%2d\n", sum);
            }//end try
            //if lines 25 or 26 get interrupted, print stack trace
            catch(InterruptedException exception)
            {
                exception.printStackTrace();
            }//end catch
        }//end for

        System.out.println("Producer done producing\nTerminating Producer");
    }//end method run
}//end class Producer

Consumer.java

//Consumer with a run method that loops, reading 10 values from buffer

package consumerproducer1;

//imports
import java.util.Random;

public class Consumer implements Runnable{

    private final static Random generator = new Random();
    private final Buffer sharedLocation;    //reference to shared object

    //constructor
    public Consumer(Buffer shared)
    {
        sharedLocation = shared;
    }//end Consumer constructor

    //read sharedLocation's value 10 times and sum the values
    public void run()
    {
        int sum = 0;

        for (int count = 1; count <=10; count++)
        {
            //sleep 0 to 3 seconds, read value from buffer abd add to sum
            try
            {
                Thread.sleep(generator.nextInt(3000) );
                sum += sharedLocation.get();
                System.out.printf("\t\t\t%2d\n", sum);
            }//end try
            //if lines 26 or 27 get interripted, print stack trace
            catch(InterruptedException exception)
            {
                exception.printStackTrace();
            }//end catch
        }//end for

        System.out.printf("\n%s %d\n%s\n", "Consumer read values totaling", sum, "Terminating Consumer");
    }//end method run

}//end class Consumer

UnsynchronizedBuffer.java

//UnsynchronizedBuffer maintains the shared integer that is accessed by
//a producer thread and a consumer thread via methods set and get

package consumerproducer1;

/**
 *
 * @author Admin
 */
public class UnsynchronizedBuffer implements Buffer{

    private int buffer = -1;    //shared by producer and consumer threads

    //place value into buffer
    public void set(int value) throws InterruptedException
    {
        System.out.printf("Producer writes\t%2d", value);
        buffer = value;
    }//end method set

    //return value from buffer
    public int get() throws InterruptedException
    {
        System.out.printf("Consumer reads\t%2d", buffer);
        return buffer;
    }//end method get

}//end class UnsynchronizedBuffer

My first question is why we declare the InterruptedException in the interface and the second question is when we can use object without declaration as we do in SharedBufferTest.java with Producer and Consumer objects.
Thank you.

[Steve Luke]

Nick Petas wrote:My first question is why we declare the InterruptedException in the interface

Declaring the InterruptedException indicates the task may take some time, may block execution, and may be interrupted by some other process. The InterruptedException is a checked exception, which means it needs to be handled by client code, and having as part of the method signature in the interface suggests to users of the interface that they need to handle cases where the InterruptedException may occur. Not all implementations will use throw the exception, but perhaps one may throw it, so the caller has to be able to handle it.

and the second question is when we can use object without declaration as we do in SharedBufferTest.java with Producer and Consumer objects.

You can do it whenever you need to create an Object but don't need to hold on to a local reference to it. The main method in the test class needs to create the Producer and Consumer in order to call the 'execute' command, but main method doesn't do anything else with the Producer/Consumer objects. The main method just needs to pass the references to other classes/methods. So why hold on to a reference itself?

[Nick Petas]

Probably the author is doing so because he uses the same interface with other class implementations provided by java api that have corresponding methods thate throw InterruptedException errors like ArrayBlockingQueue put() and take().

[Steve Luke]

Nick Petas wrote:Probably the author is doing so because he uses the same interface with other class implementations provided by java api that have corresponding methods thate throw InterruptedException errors like ArrayBlockingQueue put() and take().

Possibly, but that is an implementation detail. All it says for certain is that the task can be interrupted via Thread#interrupt(), and that the method itself does not handle the interruption, the caller needs to.