Operators & Assignments

1. increment & decrement operators

2. arithmetic operators

3. string concatenation operators

4. Relational operators

5. Equality operators

6. instanceof operators

7. Bitwise operators

8. Short circuit operators

9. type cast operators

10. assignment operator

11. conditional operator

12. new operator

13. [] operator

14. Precedence of java operators

15. Evaluation order of java operands

16. new Vs newInstance()

17. instanceof Vs isInstance()

18. ClassNotFoundException Vs NoClassDefFoundError

Increment & Decrement operators:
The following table will demonstrate the use of increment and
decrement operators.

Expression initial value of x value of y final value of x

y=++x 10 11 11
y=x++ 10 10 11
y=--x 10 9 9
y=x-- 10 10 9

Ex:

1. Increment & decrement operators we can apply only for variables but
not for constant values. Otherwise we will get compile time error.

Ex:

int x = 4;

int y = ++x;

System.out.pritnln(y); //output: 5

Ex 2:
int x = 4;

int y = ++4;

System.out.pritnln(y);

C.E: unexpected type

required: varialbe

found: value

2. We can't perform nesting of increment or decrement operator,

Otherwise we will get compile time error.

int x= 4;
int y = ++(++x);

System.out.println(y);

C.E: unexpected type

required: varialbe

found : value

3. For the final variables we can't apply increment or decrement

operators, Otherwise we will get compile time error.

Ex:

final int x = 4;

x++; // x = x + 1

System.out.println(x);

C.E: can't assign a value to final variable 'x'.

4. We can apply increment or decrement operators even for primitive

data types except boolean.
int x=10;

x++;

System.out.println(x); //output:11

char ch='a';

ch++;

System.out.println(ch); //b

double d=10.5;

d++;

System.out.println(d); //11.5

boolean b=true;

b++;

System.out.println(b);

CE: operator ++ can't be applied to Boolean.

Difference between b++ and b = b+1?

  If we are applying any arithmetic operators b/w 2 operands 'a' &
'b' the result type is max(int, type of a , type of b).

Ex 1:

byte a=10;

byte b=20;

byte c=a+b; //byte c=byte(a+b); valid

System.out.println(c);

CE: possible loss of precession

found: int

required: byte

Ex 2:

byte b=20;

byte b=b+1; //byte b=(byte)b+1 ; valid

System.out.println(c);
CE: possible loss of precession

found: int

required: byte

In the case of Increment & Decrement operators internal type casting

will be performed automatically by the compiler.

b++; => b=(type of b)b+1;

Ex:

byte b=10;

b++;

System.out.println(b); //output : 11

Arithmetic Operator:
1. If we apply any Arithmetic operation b/w 2 variables a & b,the
result type is always max(int, type of a , type of b).

Example:

byte + byte=int;

byte+short=int;

short+short=int;
 short+long=long;

double+float=double;

int+double=double;

char+char=int;

char+int=int;

char+double=double;

System.out.println('a' + 'b'); // output : 195

System.out.println('a' + 1); // output : 98

System.out.println('a' + 1.2); // output : 98.2

 In integral arithmetic (byte , int , short , long) there is no

way to represents infinity, if infinity is the result we will get
the ArithmeticException / by zero

System.out.println(10/0); // output RE : ArithmeticException / by zero

 But in floating point arithmetic(float , double) there is a way

represents infinity.

System.out.println(10/0.0); // output : infinity

  For the Float & Double classes contains the following constants:
1. POSITIVE_INFINITY
2. NEGATIVE_INFINITY
 Hence , if infinity is the result we won't get any
ArithmeticException in floating point arithmetics.

Ex:
System.out.println(10/0.0); // output : infinity
System.out.println(-10/0.0); // output : - infinity

 NaN(Not a Number) in integral arithmetic (byte,short,int,

long) there is no way to represent undefine the results.
Hence the result is undefined we will get
ArithmericException in integral arithmetic

System.out.println(0/0); // output RE : ArithmeticException / by zero

 But floating point arithmetic (float , double) there is a way to

represents undefined the results .
 For the Float, Double classes contains a constant NaN , Hence the
result is undefined we won't get ArithmeticException in floating
point arithmetics .

System.out.println(0.0/0.0); // output : NaN

System.out.println(-0.0/0.0); // output : NaN

 For any 'x' value including NaN , the following expressions

returns false.

// Ex: x=10;
  System.out.println(10 < Float.NaN ); // false
 System.out.println(10 <= Float.NaN ); // false
 System.out.println(10 > Float.NaN ); // false
 System.out.println(10 >= Float.NaN ); // false
 System.out.println(10 == Float.NaN ); // false
 System.out.println(Float.NaN == Float.NaN ); // false
 System.out.println(10 != Float.NaN ); //true
 System.out.println(Float.NaN != Float.NaN ); //true

ArithmeticException:
1. It is a RuntimeException but not compile time error

2. It occurs only in integral arithmetic but not in floating point

arithmetic.

3. The only operations which cause ArithmeticException are: ' / ' and
' % '.
String Concatenation operator:
1. The only overloaded operator in java is '+' operator sometimes it
access arithmetic addition operator & sometimes it access String
concatenation operator.

2. If acts as one argument is String type, then '+' operator acts as

concatenation and if both arguments are number type, then operator
acts as arithmetic operator.

Ex:

String a="ashok";

int b=10 , c=20 , d=30 ;

System.out.println(a+b+c+d); //output : ashok102030

System.out.println(b+c+d+a); //output : 60ashok

System.out.println(b+c+a+d); //output : 30ashok30

System.out.println(b+a+c+d); //output : 10ashok 2030

Example:
Example:

 consider the following declaration

String a="ashok";

int b=10, c=20 , d=30;

a=b+c+d;

CE : incompatible type

found : int

required : java.lang.String

a=a+b+c; // valid

b=a+c+d;

CE: incompatible type

found: java.lang.String

required: int
 Example:

b=b+c+d; // valid

Relational Operators(< , <= , > , >= ):

 We can apply relational operators for every primitive type except

boolean.

System.out.println(10 < 10.5); //true

System.out.println('a' > 100.5); //false

System.out.println('b' > 'a'); //true

System.out.println(true > false);

//CE: operator > can't be applied to boolean , Boolean

We can't apply relational operators for object types.

System.out.println("ashok123" > "ashok");

// CE: operator > can't be applied to java.lang.String ,

java.lang.String
Nesting of relational operator is not allowed

System.out.println(10 > 20 > 30); // System.out.println(true >

30);

//CE: operator > can't be applied to boolean , int.

Equality Operators: (==,!=)

 We can apply equality operators for every primitive type
including boolean type also

System.out.println(10 == 20) ; //false

System.out.println('a' == 'b' ); //false

System.out.println('a' == 97.0 ) //true

System.out.println(false == false) //true

 We can apply equality operators for object types also.

 For object references r1 and r2 , r1 == r2 returns true if and
only if both r1 and r2 pointing to the same object. i.e., ==
operator meant for reference-comparision Or address-comparision.

Thread t1=new Thread( ) ;

Thread t2=new Thread( );

Thread t3=t1 ;

System.out.println(t1==t2); //false

System.out.println(t1==t3); //true
  To use the equality operators between object type compulsory
these should be some relation between argument types(child to
parent , parent to child), Otherwise we will get Compiletime
error incompatible types

Thread t=new Thread( ) ;

Object o=new Object( );

String s=new String("durga");

System.out.println(t ==o); //false

System.out.println(o==s); //false

System.out.println(s==t);

CE: incompatible types : java.lang.String and java.lang.Thread

 For any object reference of on r==null is always false , but

null==null is always true.

String s= new String("ashok");

System.out.println(s==null); //output : false

String s=null ;
System.out.println(r==null); //true

System.out.println(null==null); //true

 What is the difference between == operator and .equals( )

method ?
1. In general we can use .equals( ) for content comparision where as
== operator for reference comparision.

String s1=new String("ashok");

String s2=new String("ashok");

System.out.println(s1==s2); //false

System.out.println(s1.equals(s2)); //true

instanceof operator:
1. We can use the instanceof operator to check whether the given an
object is perticular type or not
Object o = l.get(0); // l is an array name

if (o instanceof Student) {

Student s = (Student)o ; //perform student specific operation

else if(o instanceof Customer) {

Customer c = (Customer)o; //perform Customer specific operations

 instanceof X here O is object reference , X is

ClassName/Interface name.

Thread t = new Thread( );

System.out.println(t instanceof Thread); //true

System.out.println(t instanceof Object); //true

System.out.println(t instanceof Runnable); //true

Ex:

public class Thread extends Object implements Runnable {

}
  To use instance of operator compulsory there should be some
relation between argument types (either child to parent Or parent
to child Or same type) Otherwise we will get compile time error
saying inconvertible types.

Thread t=new Thread( );

System.out.println(t instanceof String);

CE: inconvertable errors

found : java.lang.Thread

required : java.lang.String

 Whenever we are checking the parent object is child type or not

by using instanceof operator that we get false.

Object o=new Object( );

System.out.println(o instanceof String ); //false

Object o=new String("ashok");

System.out.println(o instanceof String); //true

 For any class or interface X null instanceof X is always returns

false

System.out.println(null instanceof X); //false

Bitwise Operators : ( & , | , ^)

1. & (AND): If both arguments are true then only result is true.

2. | (OR): if at least one argument is true. Then the result is true.

3. ^ (X-OR): if both are different arguments. Then the result is true.

Example:

System.out.println(true&false);//false

System.out.println(true|false);//true

System.out.println(true^false);//true

 We can apply bitwise operators even for integral types also.

Example:

System.out.println(4&5);//4 using binary digits

System.out.println(4|5);//5 4-->100

System.out.println(4^5);//1 5-->101

Example:
Bitwise complement (~) (tilde symbol) operator:

1. We can apply this operator only for integral types but not for
boolean types.

Example:

System.out.println(~true); // CE :opetator ~ cannot be applied to

boolean

System.out.println(~4); //-5

description about above program:

4--> 0 000.......0100 0-----+ve

~4--> 1 111.......1011 1--- -ve

2's compliment of ~4 --> 000....0100 add 1

result is : 000...0101 =5

Note: The most significant bit access as sign bit 0 means +ve number,
1 means -ve number. +ve number will be represented directly in memory
whereas -ve number will be represented in 2's complement form.
Boolean complement (!) operator:
 This operator is applicable only for boolean types but not for
integral types.

Example:

System.out.println(!true);//false

System.out.println(!false);//true

System.out.println(!4);//CE : operator ! cannot be applied to int

Summary:

&

| Applicable for both boolean and integral types.

~ --------Applicable for integral types only but not for boolean

types.
! --------Applicable for boolean types only but not for integral
types.

Short circuit (&&, ||) operators:

These operators are exactly same as normal bitwise operators &(AND), |
(OR) except the following differences.

& , | && , ||
 Both arguments should be  Second argument evaluation
evaluated always. is optional.
 Relatively performance is  Relatively performance is
low. high.
 Applicable for both integral  Applicable only for boolean
and boolean types. types but not for integral
types.
1. x&&y: y will be evaluated if and only if x is true.(If x is false
then y won't be evaluated i.e., If x is ture then only y will be
evaluated)
2. x||y: y will be evaluated if and only if x is false.(If x is true
then y won't be evaluated i.e., If x is false then only y will be
evaluated)

Example:

int x=10 , y=15 ;

if(++x < 10 || ++y > 15) { //instead of || using &,&&, | operators

x++;

else {

y++;

System.out.println(x+"----"+y);
Example:

int x=10 ;

if(++x < 10 && ((x/0)>10) ) {

System.out.println("Hello");

else {

System.out.println("Hi");

output: Hi

Type Cast Operator:

There are 2 types of type-casting

1. implicit

2. explicit

implicit type casting:

int x='a';

System.out.println(x); //97

1. The compiler is responsible to perform this type casting.

2. Whenever we are assigning lower datatype value to higher datatype
variable then implicit type cast will be performed.

3. It is also known as Widening or Upcasting.

4. There is no lose of information in this type casting.

5. The following are various possible implicit type casting.

Diagram:

Example 1:

int x='a';

System.out.println(x);//97

Note: Compiler converts char to int type automatically by implicit

type casting.

Example 2:

double d=10;

System.out.println(d);//10.0

Note: Compiler converts int to double type automatically by implicit

type casting.

Explicit type casting:

1. Programmer is responsible for this type casting.

2. Whenever we are assigning bigger data type value to the smaller

data type variable then explicit type casting is required.

3. Also known as Narrowing or down casting.

4. There may be a chance of lose of information in this type casting.

5. The following are various possible conversions where explicit type

casting is required.

Diagram:

Example:

int x=130;

byte b=(byte)x;

System.out.println(b); //-126
Example 2:

int x=130;

byte b=x;

System.out.println(b); //CE : possible loss of precision

 Whenever we are assigning higher datatype value to lower datatype

value variable by explicit type-casting ,the most significant
bits will be lost i.e., we have considered least significant
bits.

Example 3:

int x=150;

short s=(short)x;

byte b=(byte)x;

System.out.println(s); //150

System.out.println(b); //-106

 Whenever we are assigning floating point value to the integral

types by explicit type casting, the digits of after decimal point
will be lost.

Example 4:

double d=130.456 ;

int x=(int)d ;

System.out.println(x); //130

byte b=(byte)d ;

System.out.println(b); //-206
Assignment Operator:
 There are 3 types of assignment operators

Simple assignment:
Example:

int x=10;

Chained assignment:
Example:

int a,b,c,d;

a=b=c=d=20;

System.out.println(a+"---"+b+"---"+c+"---"+d);//20---20---20---20

int b , c , d ;

int a=b=c=d=20 ; //valid

  We can't perform chained assignment directly at the time of
declaration.

Example 2:

int a=b=c=d=30;

CE: can ot find symbol

symbol: variable b

location: class Test

Compound assignment:
 Sometimes we can mixed assignment operator with some other
operator to form compound assignment operator.

Ex:

int a=10 ;

a +=20 ;

System.out.println(a); //30
 The following is the list of all possible compound assignment
operators in java.

 In the case of compound assignment operator internal type casting

will be performed automatically by the compiler (similar to
increment and decrement operators.)
Ex:

int a , b , c , d ;

a=b=c=d=20 ;

a += b-= c *= d /= 2 ;

System.out.println(a+"---"+b+"---"+c+"---"+d); // -160...-180--200--10

Conditional Operator (?:)

 The only possible ternary operator in java is conditional
operator

Ex 1:

int x=(10>20)?30:40;

System.out.println(x); //40

Ex 2:

int x=(10>20)?30:((40>50)?60:70);

System.out.println(x); //70

Nesting of conditional operator is possible

new operator:
1. We can use "new" operator to create an object.

2. There is no "delete" operator in java because destruction of

useless objects is the responsibility of garbage collector.

[ ] operator:
 We can use this operator to declare under construct/create
arrays.

Java operator precedence:

1. Unary operators: [] , x++ , x-- , ++x , --x , ~ , ! , new , <type>

2. Arithmetic operators : * , / , % , + , -.

3. Shift operators : >> , >>> , << .

4. Comparision operators : <, <=,>,>=, instanceof.

5. Equality operators: == , !=

6. Bitwise operators: & , ^ , | .

7. Short circuit operators: && , || .

8. Conditional operator: (?:)

9. Assignment operators: += , -= , *= , /= , %= . . .

Evaluation order of java operands:

 There is no precedence for operands before applying any operator
all operands will be evaluated from left to right.

Example:

package fundamental_java;

public class OperatorsDemo {

public static void main(String[] args) {
System.out.println(m1(1) + m1(2) * m1(3) / m1(4) * m1(5) +
m1(6));
}

public static int m1(int i) {

System.out.println(i);
return i;
}
}
Ex 2:

int i=1;

i+=++i + i++ + ++i + i++;

System.out.println(i); //13

description:

i=i + ++i + i++ + ++i + i++ ;

i=1+2+2+4+4;

i=13;

new Vs newInstance( ):
 new is an operator to create an objects , if we know class name
at the beginning then we can create an object by using new
operator .
 newInstance( ) is a method presenting class " Class " , which can
be used to create object.
 If we don't know the class name at the beginning and its
available dynamically Runtime then we should go for newInstance()
method
public class Test {

public static void main(String[] args) Throws Exception {

Object o=Class.forName(arg[0]).newInstance( ) ;

System.out.println(o.getClass().getName( ) );

} }

 If dynamically provide class name is not available then we will

get the RuntimeException saying ClassNotFoundException
 To use newInstance( ) method compulsory corresponding class
should contains no argument constructor , otherwise we will get
the RuntimeException saying InstantiationException.

Difference between new and newInstance( ):

new newInstance( )

 new is an operator, which  newInstance( ) is a method ,

can be used to create an present in class Class, which can
object. be used to create an object .
 We can use new operator if  We can use the newInstance()
we know the class name at method, If we don't class name at
the beginning. the beginning and available
Test t= new Test( ); dynamically Runtime.
 Object o =
Class.forName(arg[0]).newInstance
( );
 If the corresponding .class  If the corresponding .class file
file not available at not available at Runtime then we
Runtime then we will get will get RuntimeException saying
RuntimeException saying NoClassDefFoundError, It is
NoClassDefFoundError, It is unchecked.
unchecked.
 To used new operator the  To used newInstance( ) method the
corresponding class not corresponding class should
required to contain no compulsory contain no argument
argument constructor. constructor , Otherwise we will
get RuntimeException saying
 InstantiationException.

Difference between ClassNotFoundException &

NoClassDefFoundError:
 For hard coded class names at Runtime in the corresponding .class
files not available we will get NoClassDefFoundError , which is
unchecked.

Test t = new Test( );

In Runtime Test.class file is not available then we will get

NoClassDefFoundError.

 For Dynamically provided class names at Runtime , If the

corresponding .class files is not available then we will get the
RuntimeException saying ClassNotFoundException.

Ex: Object o=Class.forname("Test").newInstance( );

At Runtime if Test.class file not available then we will get the

ClassNotFoundException , which is checked exception.

Difference between instanceof and isInstance( ):

instanceof isInstance( )

 instanceof an  isInstance( ) is a method , present in class Class

operator which can , we can use isInstance( ) method to checked
be used to check whether the given object is perticular type or not
whether the given We don't know at the type at beginning it is
object is available Dynamically at Runtime.
perticular type or
not We know at the
type at beginning
it is available.
String s = new class Test {
String("ashok");
System.out.println(s public static void main(String[] args) {
instanceof Object );
 Test t = new Test( ) ;
//true System.out.println(Class.forName(args[0]).isInstance())
;
 If we know the type
at the beginning //arg[0] --- We don't know the type
only. at beginning

}
}
java Test Test //true
java Test String //false
java Test Object //true