Project 2: Calculator

The goal of this project is to review the basics of object-oriented programming and to give you an initial try at system design.

1. Introduction and setup

In this project you will make a program that emulates a 4-function calculator. This program will use a GUI; a window looking like a calculator will appear on the screen, and the user can manipulate it by clicking on the buttons.

I have made the "face" of the calculator already-- the GUI is given to you. You need to write the rest of the program, which will interact with the window.

After moving into your directory for this course, copy the given files for this project:

cp -r ~tvandrun/Public/cs245/proj2/calc .

You should get a folder calc the following files:

CalculatorFace.java               
ConcreteCalculatorFace.java
NoSuchButtonException.java
SetUp.java

• CalculatorFace is an interface that defines the method signatures for the object representing the calculator window. In particular this contains everything you need to know to interact with the calculator window.
• ConcreteCalculatorFace is a class implementing CalculatorFace, that is, it makes/models the window. You do not need to modify this class. In fact, you do not need even to look at this class. Again, the interface CalculatorFace gives you everything you need to know to interact with this class. The only reason I'm even giving you the source code is because Eclipse doesn't play nice with only the classfiles; the easiest thing was to just give you the source. Also, if you work on this project on your own computer instead of the lab machines, then there is one adjustment you might make so that the window will appear right on another platform; see the documentation in the file for details.
• After you (or Eclipse) compiles ConcreteCalculatorFace, you may notice a files ConcreteCalculatorFace$1.class in the folder. It is a class that ConcreteCalculatorFace makes use of. You don't need to know anything about it.
• NoSuchButtonException is an exception class that will be thrown if your code uses the calculator face incorrectly.
• SetUp is a short program that shows you what the window looks like. When you compile and run it, and you will see the calculator window; it doesn't do anything yet, though. You may choose to write your project using this program as a starting point, but that's not necessary. You don't need to use this file at all. Don't put anything critical to your calculator in it.

Make a new project in Eclipse; make it from existing source, specifically from the folder containing the calc folder.

2. The calculator face

As you can see from inspecting the code in CalculatorFace.java, the only interaction with the window available to use is

• Writing a message to the "screen" on the calculator window
• Adding action listeners to the buttons

Note that the buttons do not do anything out of the box. They will not do anything unless you attach action listeners to them.

3. Writing action listeners

You will have to write action listeners for the buttons. If you have never used the ActionListener interface (or other GUI components), you can read the relevant sections in the textbook (from chapter 17, particularly chapter 17.2), and look at the Java API. Here's a quick review/overview:

An action listener is an object that is "attached" to a GUI component-- for example, a button. Action listener classes implement the interface ActionListener in the package awt.event, which has the method actionPerformed(ActionEvent ae). For our purposes, you can ignore the parameter (but don't let that stop you from finding out how to use it, if you're curious). When the button is pressed by the user, the method actionPerformed() is invoked.

There are two basic strategies for using action listeners, and the choice between them is up to you (as we go on this semester, we'll discuss some of the trade-offs in a decision like this): Either you can write very busy actionPerformed() methods, which do a lot of the actual work of the calculator themselves; or you can write simple actionPerformed() methods which merely call another method in a central object.

So, if we suppose you have written a class PlusListener that implements ActionListener and handles the pressing of the plus button, you can attach an object to the button by

    CalculatorFace face = new ConcreteCalculatorFace();
    face.addActionListener('+', new PlusListener());

Don't hesitate to ask for help if you would like a fuller explanation or some guidance.

4. Other requirements and helpful information

Make this program work just like a hand-held four-function calculator. You can find a decent example for reference here. Don't try to implement anything fancy; don't use Ubuntu's built-in calculator as a reference.

ConcreteCalculatorFace has a constructor that takes no parameters (as used in the example above). A window automatically appears. I've worked on the window so that it appears nicely on the machines in the lab. If you work on this project on your own computer, the window's size might not be right (it isn't, for example, on my Macintosh). You can either adjust it by mouse whenever you run the program, or you can play around with the variables WINDOW_Y_POSITION etc at the beginning of the class ConcreteCalculator. Repeat: This is the only reason you would have to modify the file ConcreteCalculator.java.

In this project, you want your program to work like a real-life hand-held calculator. This is actually pretty hard to do. Even the best students rarely get full marks on the first try of this project. (Calculators will be a recurring theme in the projects of this course.)

Specifically, here are some expectations for your calculator:

• After the equals sign is pressed, the user can either build on the result (by pressing an operation key) or start over (by pressing a number key). So, if the user keys in 3 + 5 = + 8 + 2 =, then the displayed result will be 18 (after the first = is pressed, it will display 8; after the third + is pressed, it will display 16). If, on the other hand, the user keys in 3 + 5 = 8 + 2 =, the final displayed result will be 10.
• The clear button C should reset the calculator at any time.
• Your program shoule not crash on division by zero. Either an error message should be displayed or the calculator should reset.
• The screen should not overflow. For example, if the user keys in 1 / 9, the answer should be rounded so that it fits in the calculator's screen.

Hint: Don't try to write this entire project at once. Start implementing the number buttons first, making numbers appear on the screen. Then implement the plus button. When that's working, start doing the other operator buttons.

Important: The "screen" on the calculator is only 15 characters wide. Java displays double numbers using more than 15 characters. Make sure that when you display results that you do not run off the end of the screen. You need to think about how to format your results. There are several ways to do this. One way is to use the DecimalFormat class; it's described in Absolute Java (check the index, pages differ with edition) or the Java API. You also can devise your own formating strategy using String manipulation.

Also, be sure your code is documented according to the specifications given in the style principles.

5. To turn in

Please turn in all the files you wrote or modified (ie, the files you didn't modify don't need to be turned in) to a turn-in directory. To turn in a specific file, do

cp (some file) /cslab.all/ubuntu/cs245/turnin/(your user id)/proj2

To turn every file in whatever directory you are currently in, do

cp * /cslab.all/ubuntu/cs245/turnin/(your user id)/proj2

DUE: 5:00 pm Wednesday, Oct 8, 2014, 5:00 pm. Note that this is also the duedate of Project 3.