# 1. operator

## Basic concepts of 1.1 operators

```int num = 10+5;
```
• = And + are operators
• The contents of left and right variables of operators are called operands. One operand on both sides of an operator is called a single unit or two units: binocular or binary operators.
• 10 + 5 is called an expression, and there is an operation at the end.
• int num=10+5; a statement; the end is called a statement

## Classification of 1.2 Operators

• Arithmetic Operator + - */%+ -
• Relational Operator > < >= <=!==== instanceOf
• Logical Operator & |!^&&||
• Assignment operator=
• Extension operator += - = *=%= > >= <= ^=!=
• Bit Operator & | ^ > > < > > > > > > > >
• Conditional operator:?
operator operation Example Result
+ Plus sign +3 3
- Minus sign b=4; -b -4
+ plus 5+5 10
- reduce 6-4
* ride 3*4
/ except 5/5
% Mould (Remainder) 7%5
++ Self-increasing (before): First calculate, then take value a=2;b=++a a=3;b=3
++ Self-increment (after) first takes value and then calculates a=2;b=a++ a=3;b=2
Auto-subtraction (before): First calculate and then take value a=2;b=–a a=1;b=1
Self-subtracting (after): First take value, then calculate a=2;b=a– a=1;b=2
+ String connection "He"+"llo" "Hello"

### 1.2.1 assignment operator

= Store the results on the right of the assignment operator to the variables on the left

```int num = 10;
```
• Operating from right to left

### 1.2.2 arithmetic operator

+ number

```public class Operator01{
public static void main(String[] args){
int num = +5;
System.out.println(num);
num = 5+3;
System.out.println(num);
//Connection symbol
System.out.println("1+1="+1+1);
System.out.println("1+1="+(1+1));
}
}
```

Matters needing attention

• Positive sign, written before value
• The addition operation guarantees that the left and right sides of + are a specific value.
• Connector, +has an operand on both sides of the string type, at this time + is a connector, its operation rules will be around the operand as a string, and then splicing (the result of splicing or string).

- No.

```public class Operator01{
public static void main(String[] args){
int num = -5;
System.out.println(num);
num = 5-4;
System.out.println(num);
}
}
```
• % /%
```public class Operator02{
public static void main(String[] args){
int num = 3*3;
System.out.println(num);
num = num/3;
System.out.println(num);
num = num%2;//3%2
System.out.println(num);
}
}
```

+ + and -

• ++ and --- are both monocular operators
• Linkages and Differences between + + and -
• contact
• ++ operators are self-increasing on the original basis
• Operators are self-decreasing on the original basis
• When + + and --- are separate statements, ++ and --- are monotonic operators, but there is no difference between the former and the latter, they are both self-increasing 1 and self-decreasing 1.
• Distinguish (when not a single statement)
• Num++=> num++ Finally, there is a result that num itself has a result; the value of num++ expression and num are related to the value of num++ expression= the value of num.
• + + num is not a single statement, add before, add first and then calculate.
• When num++ is not a single statement, add it, first calculate it and then add it.
• num is not a single statement: subtract first, subtract first and then operate.
• num --- When not a single statement, add it, operate it first and then reduce it.
```public class Operator03{
public static void main(String[] args){
int num = 10;
//Using + + Self-Increasing Operator--Self-Decreasing Operator
--num;
System.out.println(num);
//Let num reassign 10
num = 10;
//Assign num to a new variable result after self-increment or self-decrement
int result = ++num;
//Print out num and result values
System.out.println("num:"+num+"result"+result);
int k = 5;
int j = 6;
result = k++ + ++k -k++ + j-- - ++j + j-- + ++k;
System.out.println("k:"+k+",j:"+j+",result:"+result);
}
}
```

### 1.2.3 Extended Operator

Essentially, it's a combination of arithmetic operators and bit operators plus assignment operators. += - = /= etc.

operator operation Example Result
== Equal 4==3 false
!= Not equal to 4!=3 true
< less than 4<3 false
> greater than 4>3 true
<= Less than or equal to 4<=3 false
>= Greater than or equal to 4>=3 true
instanceOf Detecting whether it is an object of a class "Hello" instanceof String true
```public class Operator04{
public static void main(String[] args){
// Calculate the sum of the scores of two students
int zhangScore = 44;
int liScore = 33;
//Summation
int sum = 0;
sum = sum+ zhangScore;//sum +=zhangScore;// sum = sum+ zhangScore;
sum = sum+ liScore;//um +=liScore;//sum /= zhangScore;
System.out.println(sum);
int num = 1000;
byte n = 0;
n += num;
System.out.println(n);
}
}
```

• Increased compilation speed
• Increased writing speed
• Automatic forced type conversion
• shortcoming

### 1.2.4 relational operator

```public class Operator05{
public static void main(String[] args){
boolean flag = 4>10;
System.out.println(flag);
flag = 4!=5;
System.out.println(flag);
flag = 1*31+22>33;
System.out.println(flag);
// Error in Operator Type of Binary Operator'>'
//System.out.println("hello">"hello");
//System.out.println(true>true);
int num = 1+true;
}
}
```

Matters needing attention:

• The final result is a boolean type of value true and false
• !===== You can compare both basic data types and reference data types.
• < > >= <== Only basic data types can be compared.

### 1.2.5 Logic Operator

a b a&b a | b a || b !a a^b
true true true true true false false
true false false false true false true
false true false false true true true
false false false false false true false
• Logical operators are used to connect Boolean expressions. They can not be written as 3 < x < 63 < x < 63 < x < 63 < x < 6, but should be written as x > 3 & x < 6 in Java.
• The Difference between "Harmony" and "Harmony"
• Single-time, the left side of the operation regardless of true or false right;
• If the left side is true, the right side is involved in the operation, and if the left side is false, the right side is not involved in the operation.
• The difference between'|','|'and'|' is the same,'|'means that when the left side is true, the right side does not participate in the operation.
• The difference between XOR (^) and OR (|) is that when both sides are true, the result is false.

Keywords: less Java

Added by Arl8 on Thu, 26 Sep 2019 14:51:05 +0300