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
