chapter1 | chapter2 | chapter3 | chapter4 | chapter5 | chapter6 |

chapter7 | chapter8 | chapter9 | chapter10 | chapter11 |

• A Relational Operator compares two values and determines the relationship between them.

• Java supports five binary conditional operators.

• Short Circuit Operators: Under specific conditions the && and || operators do not evaluate both operands.
• case 1: In the statement if((x>0) && (y>0)). If the result of first operand (x>0) is evaluated as false then the compiler knows that the result can be false, so the right operand (y>0) is not evaluated.
• case 2: in the statement if((x>0) || (y>0)). If the result of the first operand is evaluated as true then the compiler knows that the result cand be true, so the right operand (y>0) is not evaluated.
• Java supports other conditional operator ?: operator. This operator is a Ternary Operator and is basically short hand for nested if-else statements.
• The line "a = x ? b : c" is shorthand for "if (x), a = b, else a =c"
• Bitwise Operators:A bitwise operator allows you to perform bit manipulation in data.

• The three shift operators (>>= <<= >>>) simply shift the bits of the left hand operand over by the number of positions indicated by the right hand operand.
• The shift occurs in the direction indicated by the operator itself.

• A right shift of 1 bit is equivalent to,but more effecient than, dividing the left hand operand by 2.
• A left shift of 1 bit is equivalent to multiplying by 2.

• The bitwise and operator performs the 'and' function on each parallel pair of bits in each operand. The 'and' function sets the resulting bit to 1 if both operands are 1.

  Suppose you should 'and' the values 12, 13

  12-->1101 13-->1100

  12&13 1100

• The | operator performs the inclusive or operation and ^ performs the exclusive or operation
• inclusive or means that if either of the two bits are 1 then the result is 1.

• Exclusive or

• The ~ complement operator inverts the value of each bit of the operand.
• If the operand bit is 1 the result is 0 and if the operand bit is 0 the result is 1.
• Ex: complement of 111000 would be 000111

• byte b=37; short c=2; int d=b+c;

  In the above example both b and c are converted to int values before performing the addition.

• Widening conversions: These conversions are those that dont lose information on overall magnitude.
• widening conversion is referred to as promotion of a number
• Ex. The integer primitives byte,char, can all be converted to an int primitive.
• int primitive can be converted to a long without loss of information.

• Widening conversions are also done in method calls.
• Casting: conversion of operands can also be directed by a cast operator, which consists of a type enclosed in parentheses.

long X=0x100024L; int b=40; int c=b+(int)X;

the compiler will change the value of X from a long to an int before adding b and assigning the result to c

 

• Narrowing conversions: The conversion that lose significant bits are called narrowing conversions.
• compiler always requires a specific cast for narrowing conversion
• Compile time conversion: If the literal value is in the right range the compiler will do some narrowing conversions without requiring a specific cast.

• Errors associated with primitives: integers are not protected for making arithmetic errors. integers may throw an ArithmeticException
• double and float do not throw any exceptions
• division by 0 in integer will result in ArithmeticException
• division by 0 in floating point numbers results in positive or negitive infinity.

• instanceof type requires a type as the right operand.
• null is not instanceof anything. All instanceof tests with null will result in false.
• also instanceof operator cannot be used with primitives.

• Comparision operator (==) applied on objects/ equals() method: '==' determines whether the variables reference the same object in memory rather than comparing them.
• If you construct two strings with same literal without using new keyword then

a="Hello";

b="Hello";

if(a= =b) // this returns true

• '==' operator returns true only if references are to same object .
• equals() method tests for equality of content .

Ex : Long a1= new Long (100);

Long a2= new Long (100);

Long a3=a1 // a3,a1 refer to same object now.

boolean flag=(a1==a2)// false.

flag=(a1==a3) // flag is assigned true.

flag= a1.equals(a2) // flag is assigned true

• equals() method signature is public boolean equals(Object obj)
• equals returns true only if obj is of the same type and a comparision of the contents are identical
• however Boolean and String classes overide this with more meaning.

String operators:

• java interprets the + operator to mean concatenation.
• It also attempts to convert any other primitives or references in the expression to String objects.

• If a String expression contains an object reference the compiler uses that object's toString method that is inherited or overridden by every other class.

• When a String object is concatenated actually a new String object is created, the previously reffered String is eligible for garbage collection.

   

  • take an exam on this topic here

    Please submit your ideas on this topic here

    sign my guest book here

  • Tutorial Home

    certification Home

    Home