Operators are special symbols that perform operations.
Arithmetic operation from arithmetic expression (a+b, a/b)
The result of arithmetic expression is integer literal or floating point literal.
Example:
package com.javabykiran.basics;
public class Lab3Test {
public static void main(String[] args) {
byte b1 = 10;
byte b2 = b1 + 2; // error type mismatch
System.out.println(b2);
float f1 = 9.9f;
float f2 = f1 + 10.0; // error type mismatch
System.out.println(f1);
System.out.println(f2);
}
}
byte b2=b1+2 to byte b2=(byte)(b1+2); // type casting
float f2=f1+10.0 to float f2=(float)(f1+10.0);
package com.javabykiran.basics;
public class Lab3Test {
public static void main(String[ ] args) {
byte b1 = 10;
//byte b2 = b1 + 2;
byte b2=(byte)(b1+2);
System.out.println(b2);
float f1 =9.9f;
//float f2 = f1 + 10.0;
float f2 = (float)(f1 + 10.0); // type casting
System.out.println(f1);
System.out.println(f2);
}
}
| Type byte | Operator + | Type byte | Result Type byte |
|---|---|---|---|
| byte | + | short | Byte |
| byte | + | int | Int |
| byte | + | long | Long |
| byte | + | float | Float |
| byte | + | double | Double |
| short | + | short | Short |
| short | + | int | Int |
| short | + | long | Long |
| short | + | float | Float |
| short | + | double | Double |
| int | + | int | Int |
| int | + | long | long |
Example:
package com.javabykiran.basics;
public class Lab4Test {
public static void main(String[] args) {
int a=0/10;
System.out.println(a); //0
// int b=10/0;
// java.lang.ArithmeticExcepton:/by zero
// system.out.println(b);
double dl = 0.0/10.;
System.out.println(dl); //0.0
double d2= 10.0/00;
System.out.println(d2); //Infinity
int x=10%3;
System.out.println(x); //1
double d3=10.0/10.0;
System.out.println(d3); //1.0
int x1=10;
System.out.println(x1); //10
double d=10.0%1.0;
System.out.println(d); //0.0
}
}
Output:
0
0.0
Infinity 1
1.0
10
0.0
It is a form of relational expression whose result is the ‘boolean’ value a < b.
A Logical operator forms logical expression, which is a combination of one or more relational expressions
(a>b) && (a>c)
(a>b) || (a>c)
The result of logical expression is based on Boolean values, which in turn is based on the following table:
| A | B | A&&B [and] | A||B [OR] |
|---|---|---|---|
| T | T | T | T |
| T | F | F | T |
| F | T | F | T |
| F | F | F | F |
int x = 10+9.9; // error - Type mismatch: cannot convert from double to int
System.out.println(10+9.9); //ok
byte b = 10; // ok
int x = b; //ok
Implicit casting
Explicit casting
Implicit casting : When the destination is bigger than the source, then conversion happens automatically, which is called implicit casting. Another term for it is widening.
Explicit casting : When the destination is smaller than the sources, then you have to do explicit casting or narrowing
int x = 10+9.9; // error-Type mismatch: cannot convert from double to int
int x1=(int)10+9.9; // error-Type mismatch: cannot convert from double to int
int x2=(int) (10+9.9); // ok
int x3=10+(int)9.9; // ok
It is a type of arithmetic operator. It allows you to add and subtract 1 from variables.
Example:
package com.javabykiran.basics;
class Lab5 {
public static void main(String[] args) {
int x = 10;
System.out.println(x); // o/p 10
int a = ++x; // prefix increment
int b = --x; // prefix decremennt
int c = x++; // postfix increment
int d = x--; // postfix decrement
int e = ++x; // prefix increment
int f = ++x; // prefix increment
int g = x++;
System.out.println(a); // 11 11 11
System.out.println(b); // 10 10 10
System.out.println(c); // 10 11 10
System.out.println(d); // 11 11 11
System.out.println(e); // 11 12 11
System.out.println(f); // 12 12 12
System.out.println(g); // 12 13 12
}
}
Output:
10
11
10
10
11
11
12
12
Ternary operator is used to perform simple conditional checking
First, the given expression is evaluated. If the expression is true, then s1 will be executed. If the expression is false, then s2 will be executed.
package com.javabykiran.basics;
public class Lab6 {
public static void main(String[] as) {
int a = Integer.parseInt(as[0]);
int b = Integer.parseInt(as[1]);
int min=(a < b) ? a:b;
int max=(a > b) ? a:b;
System.out.println("Min :: "+min);
System.out.println("Max :: "+max);
}
}
Output:
20
1) javaLab6
// ArrayIndexOutOfBoundsException:0
2) java Lab6 10 [when we pass single parameter below error will occur]
// ArrayIndexOutOfBoundException:1
3) java Lab6 10 20 [output would be]
4) Min :: 10
Max :: 20
package com.javabykiran.basics;
public class Lab7 {
public static void main(String[] args) {
int a=10;
int b=20;
//int min=(a+b) ? a:b; // error-Type mismatch: cannot convert
// from int to boolean
int min=(a>b) ? a:b;
System.out.println(min);
}
}
/*error: incompatible types
found: int
required: boolean
int min= (a+b) ? a:b;
*/
package com.javabykiran.basics;
public class Lab8 {
public static void main(String[] a5) {
int a =Integer.parseInt(a5[0]);
int b =Integer.parseInt(a5[1]);
int c =Integer.parseInt(a5[2]);
int max=(a > b) ? (a > c) ? a:c: (b > c) ? b:c;
int min=(a < b) ? (a < c) ? a:c: (b < c) ? b:c;
System.out.println("Min:" +min);
System.out.println("Max:" +max);
}
}
Output:
Min: 5
Max 15
Bitwise operator acts on individuals bits of given numbers.
| 1. | Left shift operator | << |
| 2. | Right shift operator | >> |
| 3. | Bitwise AND | & |
| 4. | Bitwise OR | | |
| 5. | Bitwise XOR | ^ |
| 6. | Bitwise NOT | ~ |
Example:
package com.javabykiran.basics;
public class Lab10Test {
public static void main(String[] args) {
int a = 2; // 0010
int b = 4; // 0100
System.out.println("value of a before:"+a);
System.out.println("value of b before:"+b);
// bitwise unary complement operator (~)
System.out.println("value of a after negation: " + ~a); //-3
System.out.println("value of a after negation: " + ~b); //-5
// bitwise AND operator &
System.out.println("Result of a&b is:"+(a & b)); //0
// bitwise OR operator |
System.out.println("Result of a|b is:"+(a| b)); // 6
// bitwise XOR operator ^
System.out.println("Result of a^b is:"+(a^ b)); // 6
int no = 8; // 0000 1000
System.out.println("Original number:"+no); // 8
// left shifting bytes with 1 position
no = no << 1; // should be 16 i.e. 0001 0000
// equivalent of multiplication of 2
System.out.println("value after left shift:" + no); //16
no = -8;
//right shifting bytes with sign 1 position
no=no>>1; //should be 16 i.e.00010000
// equivalent of division of 2
System.out.println("value after right shift with sign:"+no); //-4
no = -8;
//right shifting bytes without sign 1 position no=no>>>1;
//should be 16 i.e.00010000
// equivalent of division of 2
System.out.println("value after right shift with sign: " + no);
// 2147483644
}
}
Output:
38
76
9
6
15
9
-16
-501
130
32
-1
A new operator is used to create an object of a given class.
Hello h = new Hello();A dot operator is used to refer members of a class using class name or object.
Hello h = new Hello();
h.a;
h.show();| bitwise AND | & |
| bitwise exclusive OR | ^ |
| bitwise inclusive OR | | |
| logical AND | && |
| logical OR | || |
| ternary | ? |
| assignment | =++-=*=/=%=&=^=|=<=>= |
| Operator | Precedence |
|---|---|
| Post fix | expr ++ expr -- |
| Unary | ~ ! +!expr -- expr+expr-expr |
| Multiplicative | * / % |
| Additive | + - |
| Shift | < < > >>>> |
| Relational | < > <=> = instance of |
Note: no sizeof operator in java
Example:
package com.javabykiran.basics;
public class Lab11 {
public static void main(String[] args) {
double a=19.9;
//System.out.println(a>>1); //error- operator <<
//cannot be applied to double
//int x = 09; //error - The literal Octal 09 (digit 9)
//of type int is out of range
//System.out.println(x); // integer number too large :09
int y = 0101;
System.out.println(y); //65 - octal conversion
}
}
Output:
65