Practical
Learning: Introduction Operators
The addition is an operation used to add
things of the same nature one to another, as many as
necessary. Sometimes, the items are added one group to another.
The concept is
still the same, except that this last example is faster. The
addition is performed in mathematics using the + sign. The same
sign is used in Java.
To get the addition of two values, you add the first one to the
other. After the addition of two values has been performed, you get a new value. This
means that if you add Value1 to Value2, you would write Value1 + Value2. The result is another
value we could call Value3. You can also add more than two values, like a + b + c.
With numbers, the order you use to add two or more values doesn't matter. This means
that Value1 + Value2 is the same as Value2 + Value1. In the same way a + b + c is the same as
a + c + b the same as b + a + c and the same as c + b + a
Here is an example that adds two numbers:
public class Exercise {
public static void main(String[] args) {
System.out.print("244 + 835 = ");
System.out.print(244 + 835);
}
}
Here is the result:
244 + 835 = 1079
You can also add some values already declared and initialized in
your program. You can also get the values from the user.
In Java, you can also add string variables to add a new
string. The operation is performed as if you were using numbers. For
example, "Pie" + "Chart" would produce "PieChart".
You can also add add as many strings as possible by including the +
operator between them. Here is an example:
public class Exercise {
public static void main(String[] args) {
String firstName = "Alexander";
String lastName = "Kallack";
String fullName = firstName + " " + lastName;
System.out.print("Full Name: " + fullName);
}
}
This would produce:
Full Name: Alexander Kallack
We are used to counting numbers such as 1, 2, 3, 4, etc. In
reality, when counting such numbers, we are simply adding 1 to a number in order
to get the next number in the range. The simplest technique of incrementing a
value consists of adding 1 to it. After adding 1, the value or the variable is
(permanently) modified and the variable would hold the new value. This is
illustrated in the following example:
// This program studies value incrementing
public class Exercise {
public static void main(String[] args) {
int Value = 12;
System.out.println("Techniques of incrementing a value");
System.out.print("Value = ");
System.out.println(Value);
Value = Value + 1;
System.out.print("Value = ");
System.out.println(Value);
}
}
This would produce:
Techniques of incrementing a value Value = 12 Value = 13
C# provides a special operator that takes care of this
operation. The operator is called the increment operator and is represented by
++. Instead of writing Value = Value + 1, you can write Value++ and you would
get the same result. The above program can be re-written as follows:
// This program studies value incrementing
public class Exercise {
public static void main(String[] args) {
int Value = 12;
System.out.println("Techniques of incrementing a value");
System.out.print("Value = ");
System.out.println(Value);
Value++;
System.out.print("Value = ");
System.out.println(Value);
}
}
The ++ is a unary operator because it operates on only one
variable. It is used to modify the value of the variable by adding 1 to it.
Every time the Value++ is executed, the compiler takes the previous value of the
variable, adds 1 to it, and the variable holds the incremented value:
// This program studies value incrementing
public class Exercise {
public static void main(String[] args) {
int Value = 12;
System.out.println("Techniques of incrementing a value");
Value++;
System.out.print("Value = ");
System.out.println(Value);
Value++;
System.out.print("Value = ");
System.out.println(Value);
Value++;
System.out.print("Value = ");
System.out.println(Value);
}
}
This would produce:
Techniques of incrementing a value Value = 13 Value = 14 Value = 15
When using the ++ operator, the position of the operator
with regard to the variable it is modifying can be significant. To increment the
value of the variable before re-using it, you should position the operator on
the left of the variable:
// This program studies value incrementing
public class Exercise {
public static void main(String[] args) {
int Value = 12;
System.out.println("Techniques of incrementing a value");
System.out.print("Value = ");
System.out.println(Value);
System.out.print("Value = ");
System.out.println(++Value);
System.out.print("Value = ");
System.out.println(Value);
}
}
This would produce:
Techniques of incrementing a value Value = 12 Value = 13 Value = 13
When writing ++Value, the value of the variable is
incremented before being called. On the other hand, if you want to first use a
variable, then increment it, in other words, if you want to increment the
variable after calling it, position the increment operator on the right side of
the variable:
// This program studies value incrementing
public class Exercise {
public static void main(String[] args) {
int Value = 12;
System.out.println("Techniques of incrementing a value");
System.out.print("Value = ");
System.out.println(Value);
System.out.print("Value = ");
System.out.println(Value++);
System.out.print("Value = ");
System.out.println(Value);
}
}
This would produce:
Techniques of incrementing a value Value = 12 Value = 12 Value = 13
It is not unusual to add a constant value to a variable. All you have to do is to declare another variable that would
hold the new value. Here is an example:
// This program studies value incrementing and decrementing
public class Exercise {
public static void main(String[] args) {
double Value = 12.75;
double NewValue;
System.out.println("Techniques of incrementing and decrementing a value");
System.out.print("Value = ");
System.out.println(Value);
NewValue = Value + 2.42;
System.out.print("Value = ");
System.out.println(NewValue);
}
}
This would produce:
Techniques of incrementing and decrementing a value Value = 12.75 Value = 15.17
The above technique requires that you use an extra variable
in your application. The advantage is that each value can hold its own value
although the value of the second variable depends on whatever would happen to
the original or source variable. Sometimes in your program you will not need to keep the
original value of the source variable. You may want to permanently modify the
value that a variable is holding. In this case, you can perform the addition
operation directly on the variable by adding the desired value to the variable.
This operation modifies whatever value a variable is holding and does not need
an additional variable.
To add a value to a variable and change the value that the
variable is holding, you can combine the assignment “=” and the addition “+”
operators to produce a new operator as +=. Here is an example:
// This program studies value incrementing and decrementing
public class Exercise {
public static void main(String[] args) {
double Value = 12.75;
System.out.println("Techniques of incrementing and decrementing a value");
System.out.print("Value = ");
System.out.println(Value);
Value += 2.42;
System.out.print("Value = ");
System.out.println(Value);
}
}
This program produces the same result as the previous.
The multiplication allows adding one value to itself a certain number
of times, set by a second value. As an example, instead of adding a value to itself in
this manner: A + A + A + A, since the variable a is repeated over and over again, you
could simply find out how many times A is added to itself, then multiply a by that number
which, is this case, is 4. This would mean adding a to itself 4 times, and you would get
the same result.
Just like the addition, the multiplication is associative: a * b * c = c * b * a.
When it comes to programming syntax, the rules we learned with the addition operation also apply to the
multiplication.
Here is an example:
public class Exercise {
public static void main(String[] args) {
double value1 = 224.58, value2 = 1548.26;
double result = value1 * value2;
System.out.print(value1 + " * " + value2 + " = " + result);
}
}
This would produce:
224.58 * 1548.26 = 347708.2308
We saw that you could add or subtract a value to a variable
and assign the result to the same variable. You can perform the same operation
with the multiplication. Here is an example:
public class Exercise {
public static void main(String[] args) {
double Value = 12.75;
System.out.print("Value = ");
System.out.println(Value);
Value = Value * 2.42;
System.out.print("Value = ");
System.out.println(Value);
}
}
This would produce:
Value = 12.75 Value = 30.855
To make this operation easy, the Java language supports the
compound multiplication assignment operator represented as *=. To use it, use
the *= operator and assign the desired value to the variable. Here is an example:
public class Exercise {
public static void main(String[] args) {
double Value = 12.75;
System.out.print("Value = ");
System.out.println(Value);
Value *= 2.42;
System.out.print("Value = ");
System.out.println(Value);
}
}
The subtraction operation is used to take out or subtract a value
from another value. It is essentially the opposite of the addition. The subtraction is performed with the -
sign.
Here is an example:
public class Exercise {
public static void main(String[] args) {
// Values used in this program
double value1 = 224.58, value2 = 1548.26;
double result = value1 - value2;
System.out.print(value1);
System.out.print(" - ");
System.out.print(value2);
System.out.print(" = ");
System.out.print(result);
}
}
This would produce:
224.58 - 1548.26 = -1323.68
Unlike the addition, the subtraction is not associative. In
other words, a - b - c is not the same as c - b - a. Consider the following program
that illustrates this:
public class Exercise {
public static void main(String[] args) {
// This tests whether the addition is associative
System.out.println(" =+= Addition =+=");
System.out.print("128 + 42 + 5 = ");
System.out.println(128 + 42 + 5);
System.out.print(" 5 + 42 + 128 = ");
System.out.println(5 + 42 + 128);
System.out.println();
// This tests whether the subtraction is associative
System.out.println(" =-= Subtraction =-=");
System.out.print("128 - 42 - 5 = ");
System.out.println(128 - 42 - 5);
System.out.print(" 5 - 42 - 128 = ");
System.out.println(5 - 42 - 128);
}
}
This would produce:
=-= Subtraction =-= 128 - 42 - 5 = 81 5 - 42 - 128 = -165
Notice that both operations of the addition convey the same result.
In the subtraction section, the numbers follow the same order but produce different results.
When counting numbers backward, such as 8, 7, 6, 5, etc, we
are in fact subtracting 1 from a value in order to get the lesser value. This
operation is referred to as decrementing a value. This operation works as if a
value is decremented by 1, as in Value = Value – 1:
// This program studies value decrementing
public class Exercise {
public static void main(String[] args) {
int Value = 12;
System.out.println("Techniques of decrementing a value");
System.out.print("Value = ");
System.out.println(Value);
Value = Value - 1;
System.out.print("Value = ");
System.out.println(Value);
}
}
This would produce:
Techniques of decrementing a value Value = 12 Value = 11
As done to increment, C# provides a quicker way of
subtracting 1 from a value. This is done using the decrement operator, that is
--. To use the decrement operator, type –- on the left or the right side of the
variable when this operation is desired. Using the decrement operator, the above
program could be written:
// This program studies value decrementing
public class Exercise {
public static void main(String[] args) {
int Value = 12;
System.out.println("Techniques of decrementing a value");
System.out.print("Value = ");
System.out.println(Value);
Value--;
System.out.print("Value = ");
System.out.println(Value);
}
}
Once again, the position of the operator can be important.
If you want to decrement the variable before calling it, position the decrement
operator on the left side of the operand. This is illustrated in the following
program:
// This program studies value decrementing
public class Exercise {
public static void main(String[] args) {
int Value = 12;
System.out.println("Techniques of decrementing a value");
System.out.print("Value = ");
System.out.println(Value);
System.out.print("Value = ");
System.out.println(--Value);
System.out.print("Value = ");
System.out.println(Value);
}
}
This would produce:
Techniques of decrementing a value Value = 12 Value = 11 Value = 11
If you plan to decrement a variable only after it has been
accessed, position the operator on the right side of the variable. Here is an
example:
// This program studies value decrementing
public class Exercise {
public static void main(String[] args) {
int Value = 12;
System.out.println("Techniques of decrementing a value");
System.out.print("Value = ");
System.out.println(Value);
System.out.print("Value = ");
System.out.println(Value--);
System.out.print("Value = ");
System.out.println(Value);
}
}
This would produce:
Techniques of decrementing a value Value = 12 Value = 12 Value = 11
You may want to subtract a constant value
from a variable. To
decrement a value from a variable, use the subtraction
and apply the same technique. This is done with the -= operator. Here is an example:
// This program studies compound subtraction
public class Exercise {
public static void main(String[] args) {
double Value = 12.75;
System.out.println("Techniques of incrementing and decrementing a value");
System.out.print("Value = ");
System.out.println(Value);
Value -= 2.42;
System.out.print("Value = ");
System.out.println(Value);
}
}
This would produce:
Techniques of incrementing and decrementing a value Value = 12.75 Value = 10.33
Dividing an item means cutting it in pieces or fractions of a set value.
For example, when you cut an apple in the middle, you are dividing it
in 2 pieces. If you cut each one of the resulting pieces, you will get 4
pieces or fractions. This is considered that you have divided the apple
in 4 parts.
Therefore, the division is used to get the fraction of one number in
terms of another.
The division is performed with the forward slash /.
Here is an example:
public class Exercise {
public static void main(String[] args) {
double value1 = 224.58, value2 = 1548.26;
double result = value1 / value2;
System.out.print(value1 + " / " + value2 + " = " + result);
}
}
This would produce:
224.58 / 1548.26 = 0.145053156446592
When performing the division, be aware of its many rules. Never
divide by zero (0). Make sure that you know the relationship(s) between the numbers
involved in the operation.
Remember that you can add, subtract, or multiply a value to
a variable and assign the result to the variable itself. You can also perform
this operation using the division. Here is an example:
public class Exercise {
public static void main(String[] args) {
double Value = 12.75;
System.out.print("Value = ");
System.out.println(Value);
Value = Value / 2.42;
System.out.print("Value = ");
System.out.println(Value);
}
}
This would produce:
Value = 12.75 Value = 5.26859504132231
To perform this operation faster, the Java language provides
the /= operator. Here is an example of using it:
public class Exercise {
public static void main(String[] args) {
double Value = 12.75;
System.out.print("Value = ");
System.out.println(Value);
Value /= 2.42;
System.out.print("Value = ");
System.out.println(Value);
}
}
The division program above will give you a result of a number
with double values if you type an odd number (like 147), which is fine in some
circumstances. Sometimes you will want to get the value remaining after a division
renders a natural result. Imagine you have 26 kids at a football (soccer) stadium
and they are about to start. You know that you need 11 kids for each team to
start. If the game starts with the right amount of players, how many will seat
and wait?
The remainder operation is performed with the percent sign
(%) which is gotten from pressing Shift + 5.
Here is an example:
public class Exercise {
public static void main(String[] args) {
int Players = 16;
// When the game starts, how many players will wait?.
System.out.print("Out of ");
System.out.print(Players);
System.out.print(" players, ");
System.out.print(16 % 11);
System.out.print(" players will have to wait when the game starts.\n");
}
}
This would produce:
Out of 16 players, 5 players will have to wait when the game starts.
As seen with the other arithmetic operators, you can find
the remainder of a variable and assign the result to the variable itself. Here
is an example:
public class Exercise {
public static void main(String[] args) {
int Players = 18;
// When the game starts, how many players will wait?.
System.out.print("Out of ");
System.out.print(Players);
System.out.print(" players, ");
Players = Players % 11;
System.out.print(Players);
System.out.println(" players will have to wait when the game starts.\n");
}
}
To support a faster version of this operation, the Java language
provides the compound remainder operator represented as %=. To use it,
assign its value to the variable. Here is an example:
public class Exercise {
public static void main(String[] args) {
int Players = 18;
// When the game starts, how many players will wait?.
System.out.print("Out of ");
System.out.print(Players);
System.out.print(" players, ");
Players %= 11;
System.out.print(Players);
System.out.println(" players will have to wait when the game starts.\n");
}
}
From our introduction to variables, you may remember
that the computer stores its data in memory using small locations that each contains a bit of information. Because a bit
can be represented only either as 1 or 0, we can say that each bit
contains 1 or 0. Bit manipulation consists of changing the value (1 or 0,
or 0 or 1) in a bit. As we will see in the next few operations, it is not
just about changing a value. It can involve reversing a value or kind of
"moving" a bit from its current position to the next position.
The operations on bits are performed on 1s and 0s
only. This means that any number is decimal or hexadecimal format involved
in a bit operation must be converted to binary first.
You will almost never perform some of the operations
we are going to review. You will hardly perform some other operations.
There is only one operation you will perform on a regular basis. The OR
operation is very regular in Microsoft Windows (Win32) programming so much
that we were obliged to include this whole section in the lesson, as
opposed to mentioning only OR.
Remember that, at any time, a box (or chunk) in memory
contains either 1 or 0:
Bit reversal consists of reversing the value of a bit.
If the box contains 1, you can reverse it to 0. If it contains 0, you can
reverse it to 1. To support this operation, the Java language provides the
bitwise negation operator represented with the ~ symbol.
As an example, consider the number 286. The decimal
number 286 converted to binary is 100011110. You can reverse each bit as
follows:
To use the bitwise negation operator, type ~ on the left
side of the value. Here is an example:
public class Exercise {
public static void main(String[] args) {
int Number1 = 286;
System.out.print("Not 286 = ");
System.out.println(~Number1);
}
}
This would produce:
Not 286 = -287
Bitwise conjunction consists of adding the content of
a bit to the content of another bit. To support the bitwise
conjunction operation,
the Java language provides the & operator.
To perform the bit addition on two numbers, remember
that they must be converted to binary first. Then:
As an example, consider the number 286 bit-added to
475. The decimal number 286 converted to binary is 100011110. The decimal
number 4075 converted to binary is 111111101011. Based on the above 4
points, we can add these two numbers as follows:
Therefore, 286 & 4075 produces 100001010 which is
equivalent to:
This means that 286 & 4075 = 256 + 16 + 2 = 266. To
perform a bitwise conjunction, use the & operator. Here is an example:
public class Exercise {
public static void main(String[] args) {
int Number1 = 286;
int Number2 = 4075;
int Result = Number1 & Number2;
System.out.print("286 & 4075 = ");
System.out.println(Result);
}
}
This would produce:
286 & 4075 = 266
You can perform a bitwise conjunction on a variable and
assign the result to the same variable. Here is an example:
public class Exercise {
public static void main(String[] args) {
int Number = 286;
System.out.println(Number);
Number = Number & 48;
System.out.println(Number);
}
}
This would produce:
286 16
Instead of performing the operation on two steps, a shorter
version of this operator consists of using the &= operator. Here is an
example:
public class Exercise {
public static void main(String[] args) {
int Number = 286;
System.out.println(Number);
Number &= 48;
System.out.println(Number);
}
}
Bitwise disjunction consists of disjoining a bit
from another bit. To support this operation,
the Java language provides the bitwise disjunction operator represented
with |.
To perform a bitwise conjunction on two numbers, remember
that they must be converted to binary first. Then:
As an example, consider the number 305 bit-disjoined to
2853. The decimal number 305 converted to binary is 100110001. The decimal
number 2853 converted to binary is 101100100101. Based on the above 4
points, we can disjoin these two numbers as follows:
Therefore, 305 | 2853 produces 101100110101 which is
equivalent to:
This means that 286 | 4075 = 2048 + 512 + 256 + 32 +
16 + 4 + 1 = 2869
This can also be programmatically calculated as
follows:
public class Exercise {
public static void main(String[] args) {
int Number1 = 305;
int Number2 = 2853;
int Result = Number1 | Number2;
System.out.print("305 Or 2853 = ");
System.out.println(Result);
}
}
This would produce:
305 Or 2853 = 2869
You can disjoint a number of bits on a variable and assign
the result to the same variable. Here is an example:
public class Exercise {
public static void main(String[] args) {
int Number = 305;
System.out.println(Number);
Number = Number | 22;
System.out.println(Number);
}
}
This would produce:
305 311
A short version of this operation consists of using the |=
operator. Here is an example:
public class Exercise {
public static void main(String[] args) {
int Number = 305;
System.out.println(Number);
Number |= 22;
System.out.println(Number);
}
}
Bitwise exclusion consists of adding two bits with the
following rules. To support bitwise exclusion, the Java language provides
the ^ operator:
As an example, consider the number 618 bit-excluded
from 2548. The decimal number 618 converted to binary is 1001101010. The decimal
number 2548 converted to binary is 100111110100. Based on the above 2 points, we can
bit-exclude these two numbers as follows:
Therefore, 305 ^ 2853 produces 101110011110 which is
equivalent to:
This means that 286 ^ 4075 = 2048 + 512 + 256 + 128
+ 16 + 8 + 4 + 2 = 2974
This can also be programmatically calculated as
follows:
public class Exercise {
public static void main(String[] args) {
int Number1 = 618;
int Number2 = 2548;
int Result = Number1 ^ Number2;
System.out.println(Result);
}
}
This would produce:
2974
You can bitwise exclude a number of bits from a variable and
assign the result to the variable itself. Here is an example:
public class Exercise {
public static void main(String[] args) {
int Number = 618;
System.out.println(Number);
Number = Number ^ 38;
System.out.println(Number);
}
}
This would produce:
618 588
As an alternative, you can use the ^= operator to get the
same result. Here is an example:
public class Exercise {
public static void main(String[] args) {
int Number = 618;
System.out.println(Number);
Number ^= 38;
System.out.println(Number);
}
}
Left shifting the bits consists of pushing each bit
from right to left. You can do this by one ore more bits. Once again, to
perform this operation, the number has to be converted to its binary
equivalent. To support this operation, the Java language provides
an operator represented as <<.
Imagine you have a number as 741. Its binary
equivalent is 1011100101 and can be represented as:
To perform a left shift operation on these bits, you
push each from its position to the left, depending on the number of pushes
you want. For example, to left-shift by 1 bit, you push each bit to the
left by one position. Actually, you consider the bit at position x and the
bit to its left at position y. You replace the value of Bit y by the value
of Bit x. If Bit x is the most right bit, it receives a value of 0. This
can be illustrated as follows:
As a result, we get 10111001010. The decimal result
can be calculated as follows:
Consequently, 741 << 1 = 1024 + 256 + 128 + 64 +
8 + 2 = 1482. To programmatically perform this operation, use the <<
operator. Here is an example:
public class Exercise {
public static void main(String[] args) {
System.out.println(741 << 1);
}
}
This would produce:
1482
In the same way, you can push the bits to the left by
more than one unit. Here is an example:
public class Exercise {
public static void main(String[] args) {
int Number = 248 << 5;
System.out.println(Number);
}
}
This would produce:
7936
You can push a few bits to the left of a variable and assign
the result to the variable itself. Here is an example:
public class Exercise {
public static void main(String[] args) {
int Number = 248;
System.out.println(Number);
Number = Number << 5;
System.out.println(Number);
}
}
This would produce:
248 7936
To provide another version of this operation, the Java language
is equipped with the <<= operator. Here is an example of using it:
public class Exercise {
public static void main(String[] args) {
int Number = 248;
System.out.println(Number);
Number <<= 5;
System.out.println(Number);
}
}
You can shift the bits to the right. Everything is
done as reviewed for the left shift but in reverse order. To support this
operation, the Java language provides the >> operator.
|
Operators and Operands
Subscribe to:
Post Comments (Atom)
Related Scripting
No comments:
Post a Comment