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);
	}
}

Analysis of Advantages and Disadvantages of Extended Operators

• Advantage
  • Increased compilation speed
  • Increased writing speed
  • Automatic forced type conversion
• shortcoming
  • Not conducive to reading

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.