Greg Stevens

What would the interface for the Add class be? How would you use an object of type Add?

I remember now that the solution is the Euclidean algorithm. Never mind. I will try some other recursive problem.

I have not searched the forums on this because I want to try to work out as much of this on my own as I can.
I know how to solve this with with a loop. If the the larger integer can be divided by the smaller integer with a remainder
of 0, then the smaller integer is the greatest common divisor. Otherwise, iterate from (smaller - 1) down to 1 and check
for divisibility for both larger and smaller integer.

I know I should be thinking in terms of a base case and a simplification of the original problem, but I don't see it.

Any small hint?

Do you know how to get a numeric value from a String representation? What kind of numeric value are you
expecting the user to input?

Also, I think lunch is a confusing name for your variable. I read it and I think it should contain a menu item or
or some type of food. I don't think this is your intention. What input exactly are you expecting from the user?

Does this demonstrate that operator precedence is not the same thing as order of evaluation?

// CookieJar attempts to demonstrate that Operator Precedence is not the same // thing as Order of Evaluation. Specifically, we will see that placing an expression // in parentheses does not necessarily cause it to be evaluated first. // We will also see that using a ++ in an expression does not necessarily cause it to // be evaluated first. // In these examples the order of evaluation is being determined not by operator precedence, // but by the rule described in the Java Language Specification 15.7 Evaluation Order which states: // "The Java programming language guarantees that the operands of operators appear to be // evaluated in a specific evaluation order, namely, from left to right." // And the Java Language Specification 15.7.1 Evaluate Left-Hand Operand First: // "The left-hand operand of a binary operator appears to be fully evaluated before any part // of the right-hand operand is evaluated." public class CookieJar { static int numCookiesInJar = 14; public static void main(String[] args) { System.out.println("Evaluating this statement: "); String statement = "int sum = askForCookie(5) + (askForCookie(4) + askForCookie(3) + (askForCookie(2) + (askForCookie(1))));"; System.out.println(statement); System.out.println(); int sum = askForCookie(5) + (askForCookie(4) + askForCookie(3) + (askForCookie(2) + (askForCookie(1)))); System.out.println("**********************"); System.out.println("Contrast with left-to-right operands of 1,2,3,4,5 as opposed to 5,4,3,2,1 (notice no \"end of the world!\")"); statement = "sum = askForCookie(1) + (askForCookie(2) + askForCookie(3) + (askForCookie(4) + (askForCookie(5))));"; System.out.println("Evaluating this statement: "); System.out.println(statement); System.out.println(); numCookiesInJar = 14; // reset numCookies in jar for second demonstration sum = askForCookie(1) + (askForCookie(2) + askForCookie(3) + (askForCookie(4) + (askForCookie(5)))); System.out.println("**********************"); System.out.println("And to make it clearer with fewer parens:"); System.out.println("In the interest of fairness, we will attempt to use parens to fulfill the request for the smallest number of cookies first."); statement = "sum = askForCookie(5) + askForCookie(4) + askForCookie(3) + askForCookie(2) + (received = askForCookie(1))"; System.out.println("Evaluating this statement: "); System.out.println(statement); System.out.println(); numCookiesInJar = 14; // reset numCookies in jar for third demonstration int received; sum = askForCookie(5) + askForCookie(4) + askForCookie(3) + askForCookie(2) + (received = askForCookie(1)); System.out.printf("Value of received: %d\n", received); System.out.println("Even though the assignment 'received = askForCookie(1)' was inside parens, it was evaluated last."); System.out.println("The expression '(received = askForCookie(1))' was the right operand of the last binary operator so it was evaluated last."); System.out.println("This demonstrates a non-trivial example (at least for the kid who got no cookie),"); System.out.println("of confusing operator precedence with order of evaluation."); System.out.println("Operator precedence is not the same thing as order of evaluation"); System.out.println(); System.out.println("**********************"); System.out.println("One last example. We will try to force the assignment 'received = askForCookie(1)' to be evaluated first by using"); System.out.println("another high precedence operator, ++. Notice this has no effect whatsoever on order of evaluation."); System.out.println("In the interest of fairness, and since he got no cookie at all last time, we will attempt to allow child who requested the"); System.out.println("fewest number of cookies to steal an extra cookie from the cookie jar this time with the ++ operator."); statement = "sum = askForCookie(5) + askForCookie(4) + askForCookie(3) + askForCookie(2) + (received = askForCookie(++one))"; System.out.println("Evaluating this statement: "); System.out.println(statement); System.out.println(); numCookiesInJar = 14; // reset numCookies in jar for third demonstration int one = 1; sum = askForCookie(5) + askForCookie(4) + askForCookie(3) + askForCookie(2) + (received = askForCookie(++one)); System.out.printf("Value of received: %d\n", received); System.out.println("Even though the assignment 'received = askForCookie(++one)' was inside parens and included ++ operator, it was evaluated last."); System.out.println("The expression '(received = askForCookie(++one))' was the right operand of the last binary operator so it was evaluated last."); System.out.println("Whether by being polite and asking for only 1 cookie, or by trying to steal a cookie from the cookie jar with ++,"); System.out.println("the child who was on the right of the binary operator got no cookie and it was the end of the world."); System.out.println("This demonstrates a non-trivial example (at least for the kid who got no cookie),"); System.out.println("of confusing operator precedence with order of evaluation."); System.out.println("Operator precedence is not the same thing as order of evaluation"); } // This method is used to request a number of cookies. // numRequested: the number of cookies requested // returns: numRequested if <= cookies in jar; otherwise returns available cookies public static int askForCookie(int numRequested) { int cookies; System.out.printf("There are %d cookies in the jar.\n", numCookiesInJar); System.out.printf("Someone requested %d cookies.\n", numRequested); if (numRequested <= numCookiesInJar) // enough cookies in the jar, give num requested { cookies = numRequested; numCookiesInJar = numCookiesInJar - numRequested; System.out.printf("There's enough cookies, someone gets %d.\n", cookies); System.out.printf("Now there's %d cookies in the jar.\n", numCookiesInJar); System.out.println(); } else // not enough cookies, give what's left in jar { cookies = numCookiesInJar; numCookiesInJar = 0; System.out.printf("There's not enough cookies in the jar, someone only gets %d.\n", cookies); if (cookies >= 1) // someone gets at least 1 cookie { System.out.println("Oh, well. At least I got something.\n"); System.out.println(); } else // someone gets no cookie at all { System.out.println("I get no cookie! It's the end of the world!"); System.out.println(); } } return cookies; } }


Any suggestions on how to make it cool and object-oriented like Campbell Ritchie's?

Concerning inheritance and overriding part of your question

You should read Sun's bicycle inheritance tutorial. Notice that the more specific type of bicycle class still uses most of the superclass's
definition (fields and methods) but may override a method or initialize some of the instance variables to different values.

Also interfaces can be used to describe a class that has two or more different sets of behavior. A class
can only have one superclass (inheritance), but it can implement the behavior of any number of interfaces.
Perhaps it will implement seemingly unrelated behavior that would never be described through inheritance
but can be expressed with interfaces:

public interface Weapon { public void attack(); // weapons can attack in many different ways, no default attack description // it will be up to the class that [i]implements[/i] this interface to describe attack } // Guitar will now have seemingly unrelated behavior of Instrument and Weapon - can't do this with inheritance public class Guitar implements Instrument, Weapon { // we're not overriding play() because there is no default definition, we are implementing it public void play(double volume) { // play guitar music here } // same here public void tune() { // do guitar tuning here } public void attack() { // swing guitar at opponent or victim } } public class Piano implements Instrument, Weapon { // Piano is also an Instrument so it must have play and tune // again, not overriding, implementing public void play(double volume) { // play piano music here } public void tune() { // do piano tuning here } public void attack() { // drop piano from window onto victim's head } }

Classes that implement interfaces don't override methods they implement them. There was never
a previous definition of the method to override. They are providing the first definition. This mechanism
of stating that a class will have a method but not providing a default implementation is useful if a set of
objects all do a certain activity, but there is no default way for doing it. They each do it their own way.

public interface Instrument { public void play(double volume); // we are using interface because it doesn't make sense to provide // default way for instrument to play - too much variety public void tune(); // same reasoning here // notice these methods have no body, because it doesn't make sense to give generic behavior } public class Guitar implements Instrument { // we're not overriding play() because there is no default definition, we are implementing it public void play(double volume) { // play guitar music here } // same here public void tune() { // do guitar tuning here } } public class Piano implements Instrument { // Piano is also an Instrument so it must have play and tune // again, not overriding, implementing public void play(double volume) { // play piano music here } public void tune() { // do piano tuning here } }

It is an introduction to object-oriented programming using Java class. The instructor clearly has operator precedence and
order of evaluation confused. I'm glad I came here, because even after reading the JLS, I knew something was wrong, but
not exactly what -- the specification is not very easy to decipher for mere mortals like myself. I would still be confused if
you guys hadn't told me operator precedence is not the same as order of evaluation.

Thanks for the patience guys. I think I am getting a little closer to understanding this.

Precedence has more to do with which operator is applied to an operand when it is shared by two operators. Precedence does not mean
order of evaluation (like order of evaluation in math).

So,

int x = 5; int z = ++x * x--; System.out.println("z: " + z); System.out.println("expected: 36 not 20"); System.out.println("x: " + x); System.out.println("expected: 5");

The higher precedence of ++ and -- compared to * means that they are each applied to their operands before *, which shares an operand
with each. There really is no meaning to saying postdecrement has higher precedence than preincrement because those two operators
would never share an operand?

And next example is the one I need to definitely be sure I understand, because this is how it is being presented in my class:
int x = 5; int z = x + x++; System.out.println("z: " + z); System.out.println("expected: 10 not 11 like the instructor says"); System.out.println("x: " + x); System.out.println("expected: 6");

The instructor is saying x++ is evaluated first (like one would do with PEMDAS and exponents), giving 5 and changing x to 6, then the first x
evaluates to 6 and we have 6 + 5 == 11. He says it is a compiler error causing it to evaluate 10 and we will have "order of evaluation
problems" on our midterm and we need to know how to do them correctly, according to the "ANSI standard". I know this is wrong. I at least
want to make sure I understand them if I get them all wrong on the test.

But now I understand that the higher precedence of ++ above only means that x is incremented before the two operands of * are
multiplied. And according to JLS 15.7.1, the left operand of a binary operator is evaluated first. This is not in contradiction to the higher
precedence of ++ because ++ is applied to its operand before * is applied to its two operands.

Precedence and Evaluation Order are two different things. I feel much better now. The world is all well again -- as well as it was before
I freaked out anyway.

I'm still confused. I've been trying to figure this out all day. I think I'll just have to let it go for a while. It just makes no sense whatsoever to me to
say post increment operator has highest precedence post decrement operator has higher precedence than pre increment operator, but
pre increment is evaluated first. Obviously I am confused about the meaning of precedence. Common usage of precedence refers to one thing happening
before another. How can something that happens first happen last?

but I hope this will teach you not to write illegible code

I would never write code like that. I have definitely learned not to use pre or post increment in an expression in which the variable occurs
more than once.

I see that the compiler gives the answer it does. Actually, my problem is that that I am studying in a class and the instructor is teaching that
the rules of precedence apply this way (obviously incorrect). I think he is confused. I am trying to figure out what is correct.

Thank you for walking through the examples. What I don't understand is what does it mean for the unary operators to have higher
precedence than the equality operators if the are not evaluated first.

In other words

num = 10
num == num++

shouldn't num++ be evaluated first (evaluating to 10, but incrementing num to 11), then when num on the left is evaluated it
would be 11. 11 == 10: false

In both of the examples the terms are simplified from left to right. The rightmost postfix operator is not applied before the middle prefix operator.
What is the point of saying postfix has higher precedence than prefix if it doesn't get evaluated first?

int i = 10;
int a, b, c, d;
a = (b = i++) + (c = ++i) + (d = i--);

if postfix evaluates first shouldn't we get

b = 10, i = 11
d = 11, i = 10
+ c = 11, i = 11
----------
a = 32

I am confused with the following code:
int num; boolean isTrue; // conditional 1 num = 10; isTrue = (num++ == num); System.out.println("(num++ == num): " + isTrue); System.out.println("expected: false"); // conditional 2 num = 10; isTrue = (num == num++); System.out.println("(num == num++): " + isTrue); System.out.println("expected: false"); // conditional 3 num = 10; isTrue = (++num == num); System.out.println("(++num == num): " + isTrue); System.out.println("expected: true"); // conditional 4 num = 10; isTrue = (num == ++num); System.out.println("(num == ++num): " + isTrue); System.out.println("expected: true");

Here is the output:
(num++ == num): false expected: false (num == num++): true expected: false (++num == num): true expected: true (num == ++num): false expected: true

"Conditional 2" and "conditional 4" do not behave as I would expect according to the operator precedence
rules. If the unary operators have higher precedence than the equality operators, then why aren't num++
and ++num evaluated first when they are on the right side of the == operator?

I am especially confused by this because the Java Language Specification says:

15.7.1 Evaluate Left-Hand Operand First
The left-hand operand of a binary operator appears to be fully evaluated before
any part of the right-hand operand is evaluated.

I'm sure I'm probably taking this out of context, but in "conditional 2" and "conditional 4", the left-hand
operands certainly seem to be evaluated first. If left-hand operands of binary operators are evaluated
first, what is the point of the higher precedence of unary operators? Are the unary operators applied
first seperately on each side of the binary operator, recusrively in some sort of tree structure. That seems
rediculously confusing. I know this is supposed to be very simple, but I can't seem to get past the apparent
contradiction. Thanks in advance for any help.