lesson 6 – arithmetic operators java programming
TRANSCRIPT
LESSON 6 – Arithmetic Operators
JAVA PROGRAMMING
Arithmetic operators and expressionsAs in most languages, expressions can be formed in
Java using variables, constants, and arithmetic operators.
Java has five (5) arithmetic operators.Operator Meaning Type Example+ Addition Binary total = cost + tax;- Subtraction Binary cost = total –
tax;* Multiplication Binary tax = cost * rate;/ Division Binary salePrice = original /
2;% Modulus Binary remainder = value
% 5;
Shorthand assignment statementShorthand assignment notation combines the
assignment operator (=) and an arithmetic assignment operator
It is used to change the value of a variable by adding, subtracting, multiplying, or dividing by a specified value
The general form isVariable Op = Expression
which is equivalent toVariable = Variable Op (Expression)
o The Expression can be another variable, a constant, or a more complicated expression
o Op can be are +, -, *, /, or %Example:
a += 4;Equivalent to: a = a + 4;
Shorthand assignment statementExample: Equivalent To:count += 2; count = count + 2;sum -= discount; sum = sum – discount;bonus *= 2; bonus = bonus * 2;time /= rushFactor; time = time /
rushFactor;change %= 100; change = change % 100;amount *=count1+count2 amount = amount *
(count1 + count2);
Arithmetic Operators and ExpressionsPromotionIf an arithmetic operator is combined with int
operands, then the resulting type is intIf an arithmetic operator is combined with one or
two double operands, then the resulting type is double
If different types are combined in an expression, then the resulting type is the right‐most type on the following list that is found within the expressionbyte→short→int→long→float→doublechar
Exception: If the type produced should be byte or short (according to the rules above), then the type produced will actually be an int
Arithmetic Operators and ExpressionsAn expression can be fully parenthesized in
order to specify exactly what subexpressions are combined with each operator
If some or all of the parentheses in an expression are omitted, Java will follow precedence rules to determine, in effect, where to place them
However, it's best (and sometimes necessary) to include them
Precedence ruleParentheses rule: Evaluate expressions in parentheses
separately.Evaluate nested parentheses from the inside out.Operator precedence rule: Operators in the same
expression are evaluated in the order determined by their precedence (from the highest to the lowest).
Operator Precedencemethod call highest precedence- (unary)new, type cast*, /, %+, - (binary)= Lowest precedence
Left associative rule: Operators in the same expression and at the same precedence level are evaluated in left-to-right order.
Precedence ruleWhen two operations have equal precedence, the order ofoperations is determined by associativity rulesUnary operators of equal precedence are grouped right‐
toleft +‐+rate is evaluated as +(‐(+rate))
Binary operators of equal precedence are grouped left‐torightbase + rate + hours is evaluated as (base + rate) + hours
Exception: A string of assignment operators is groupedright‐to‐left
n1 = n2 = n3; is evaluated as n1 = ( n2 = n3);
Precedence ruleEvaluation of z – (a + b / 2) * w / yz ‐ (a + b / 2) * w / y Operator, reason
evaluated‐‐/‐‐‐ /, parens and precedence‐‐‐+‐‐‐‐‐‐‐ +, parens‐‐‐‐‐‐‐‐‐‐‐‐‐*‐‐ *, precendence, left assoc.‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐/‐‐ /, precedence
Increment and decrement operatorOperator Name Description++var preincrement The expression (++var) increments
var by 1 and evaluates to the new value in var after the increment.
var++ postincrement The expression (var++) evaluates to the
original value in var and increments var by 1.‐‐var predecrement The expression (‐‐var) decrements
var by 1 and evaluates to the new value in var after the decrement.
var‐‐ postdecrement The expression (var‐‐) evaluates to the
original value var and 10 in decrements var by 1.
Increment and decrement operatorIf n is equal to 2, then 2*(++n)
evaluates to 6If n is equal to 2, then 2*(n++)
evaluates to 4Using increment and decrement operators
makes expressions short, but it also makes them complex and difficult to read.
Avoid using these operators in expressions that modify multiple variables, or the same variable for multiple times such as this: int k = ++i + i.
JAVA PROGRAMMING
THE END