Operators - Revision history

Suhridk: /* Operator Precedence */

2011-09-08T09:20:14Z

Operator Precedence

2011-09-08T09:06:32Z

Logical Operator

2011-09-05T07:14:55Z

instanceof

2011-08-31T13:33:35Z

Logical Operator

2011-08-31T13:14:15Z

Logical Operator

2011-08-31T13:07:37Z

Short Circuit Logical Operators

2011-08-31T12:53:23Z

Logical Operator

2011-08-31T12:40:29Z

String concatenation operator

2011-08-31T12:19:58Z

2011-08-31T12:06:14Z

← Older revision		Revision as of 09:20, 8 September 2011
Line 339:		Line 339:
	# Conditional : ?:		# Conditional : ?:
	# Assignment: =,+=,-+,*=,/=,%=, etc		# Assignment: =,+=,-+,*=,/=,%=, etc
		+
		+	* All operators in the same row have the same precedence.
		+	* Associativity is used to determine which operator wins for those with same precedence.
		+	* Binary operators ( +, - ) have left to right associativity.
		+	** e.g. 1 + 2 - 3 is (1+2) - 3.
		+	* Relational and assignment operators and unary operators associate from right to left.
		+

← Older revision		Revision as of 09:06, 8 September 2011
Line 321:		Line 321:

	* ! inverts the boolean value, but doesnt change the original value.		* ! inverts the boolean value, but doesnt change the original value.
		+
		+	== Operator Precedence ==
		+
		+	# Postfix operators: [], ., expr++, expr--
		+	# Unary prefix : ++expr, --expr,
		+	# Unary prefix creation and cast : new, type
		+	# Multiplicative: *, / , %
		+	# Additive: + , -
		+	# Shift: <<,>>,>>>
		+	# Relational : <, <=, >. >= instanceof
		+	# Equality: == !=
		+	# Bitwise/logical AND: &
		+	# Bitwise/logical XOR: ^
		+	# Bitwise/logical OR: \|
		+	# Conditional AND: &&
		+	# Conditional OR: \|\|
		+	# Conditional : ?:
		+	# Assignment: =,+=,-+,*=,/=,%=, etc
		+
		+
		+

	[[Category:OCPJP]]		[[Category:OCPJP]]

@@ Line 68: / Line 68: @@
 * The '''instanceof''' (all small letters) is used for object variables only.
 * The first operand must be an object instance and the second operator a class name.
-* Instanceof can be used to compare operands which are in the same class hierarchy, However this restriction '''does not apply to interfaces''' !
+* Instanceof can be used to compare operands which are in the same class hierarchy, However this restriction '''does not apply to interfaces''' ! Because the class could implement the interface at some point.
 <syntaxhighlight lang="java5">
@@ Line 97: / Line 98: @@
+		}
-                 if (f instanceof Runnable) { //OK TO COMPARE
+                 if (f instanceof Runnable) { //OK TO COMPARE, Father could implement Runnable at some point.
+                 }

← Older revision		Revision as of 13:33, 31 August 2011
Line 303:		Line 303:

	</syntaxhighlight>		</syntaxhighlight>
		+
		+	=== XOR and Invert ===
		+
		+	* ^ (XOR) evaluates only boolean values. For XOR to be true, the operands must be different (one true and one false), if both are true and both are false, then XOR will be false.
		+
		+	<syntaxhighlight lang="java5">
		+
		+	System.out.println((2 < 3) ^ (4 < 5)); //False
		+	System.out.println((10 < 2) ^ (2 < 10)); //True
		+
		+	</syntaxhighlight>
		+
		+	* ! inverts the boolean value, but doesnt change the original value.

	[[Category:OCPJP]]		[[Category:OCPJP]]

@@ Line 208: / Line 208: @@
 public static void main(String[] args) {
 		if(expr1() && expr2() && expr3()) {
-			System.out.println("If");
+			System.out.println("True");
 		} else {
-			System.out.println("Else");
+			System.out.println("False");
+		}
@@ Line 216: / Line 216: @@
 		if(expr1() || expr2() || expr3()) {
-			System.out.println("If");
+			System.out.println("True");
 		} else {
-			System.out.println("Else");
+			System.out.println("Flase");
+		}
+	}
@@ Line 239: / Line 239: @@
 /* OUTPUT :
 expr1
-Else
+False
 ------------------------------
 expr1
 expr2
-If
+True
 /*
 </syntaxhighlight>
 [[Category:OCPJP]]

@@ Line 201: / Line 201: @@
 === Short Circuit Logical Operators ===
-* Short circuit && evaluates the first operand and if it resolves to false, it skips evaluating the remaining operands because the result of the expression will be false.
+* Short circuit && evaluates the first operand and if it resolves to false, it skips evaluating the remaining operands because the end result will be false.
 [[Category:OCPJP]]

← Older revision		Revision as of 12:53, 31 August 2011
Line 198:		Line 198:

	</syntaxhighlight>		</syntaxhighlight>
		+
		+	=== Short Circuit Logical Operators ===
		+
		+	* Short circuit && evaluates the first operand and if it resolves to false, it skips evaluating the remaining operands because the result of the expression will be false.
		+

	[[Category:OCPJP]]		[[Category:OCPJP]]

@@ Line 169: / Line 169: @@
 System.out.println(1 + 2 + " abc " + 3); // 3 abc 3
 System.out.println(1 + 2 + " abc " + 3 + 4); // 3 abc 34
 </syntaxhighlight>
 [[Category:OCPJP]]

← Older revision		Revision as of 12:19, 31 August 2011
Line 155:		Line 155:
	* *, /, % have a higher precedence than the + and - operators.		* *, /, % have a higher precedence than the + and - operators.

		+	== String concatenation operator ==
		+
		+	* '+' is the only "overloaded" operator in java and can be used to concatenate two strings together.
		+	* '''WATCH OUT :''' When integers are concatenated with Strings :
		+	* Evaluation runs from '''left to right'''
		+	* If both operands are integers, then addition will take place.
		+	* If one operand is a string, concatenation will happen.
		+
		+	<syntaxhighlight lang="java5">
		+
		+	System.out.println(1 + 2 + " abc"); // 3 abc
		+	System.out.println(1 + " abc " + 2); // 1 abc 2
		+	System.out.println(1 + 2 + " abc " + 3); // 3 abc 3
		+	System.out.println(1 + 2 + " abc " + 3 + 4); // 3 abc 34
		+
		+	</syntaxhighlight>

	[[Category:OCPJP]]		[[Category:OCPJP]]

← Older revision		Revision as of 12:06, 31 August 2011
Line 149:		Line 149:

	</syntaxhighlight>		</syntaxhighlight>
		+
		+	== Arithmetic Operators ==
		+
		+	* +, -, *, /, % are the arithmetic operators.
		+	* *, /, % have a higher precedence than the + and - operators.
		+

	[[Category:OCPJP]]		[[Category:OCPJP]]