java 计税算法实现 java计算法则

   ⛵ ⛵ ⛵ ⛵ ⛵ 🚀 🚀 🚀 🚀 🚀
  大家好🤝，我是👉老孙👈，未来学习路上多多关照🤝，一个喜欢用✍️博客记录人生的程序猿🙉，或许这是一件很有意义又有趣的事📖 ⏰🏘️⛵
  🔥 🔥 🔥 🔥 🔥 ⭐ ⭐ ⭐ ⭐ ⭐

---

Java基础语法

• 一、运算规则

• 1、自动类型提升
• 2、强制类型转换

• 二、Java中的六种运算符

• 1、算术运算符
• 2、赋值运算符
• 3、比较运算符
• 4、逻辑运算符
• 5、位运算符
• 6、三元运算符

一、运算规则

基本数据之间的运算规则：这里只讨论7种基本数据类型变量间的运算（不包含boolean类型）

1、自动类型提升

自动类型提升结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。

• byte、char、short ------> int ------> long ------> float ------> double
• 特别：当byte、char、short三种类型的变量做运算时，结果为int型。
• 此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量。

public class Grammar_OperationalRule {
	public static void main(String [] args) {
        byte b1 = 2;
        short s1 = 123;
        int i1 = 129;
        //byte b2 = b1 + i1;   //编译不通过
        //byte b3 = b1 + s1;   //编译不通过
        int i2 = b1 + i1 + s1;
        System.out.println(i2); //254

        float f = b1 + i1;
        System.out.println(f); //131.0

        double d1 = i1 + f;
        System.out.println(d1);  //260.0

        //--------------------------
        char c1 = 'a';
        short s2 = 10;
        int i3 = 10;
        
        int i4 = c1 + i3;
        System.out.println(i4); //107
        
        //char c2 = c1 + s2;   //编译不通过
    }

}

2、强制类型转换

强制类型转换：自动类型提升运算的逆运算

• 需要使用强转符： ()
• 注意点：强制类型转换，可能导致 精度损失

public class Grammar_Operational_Rule {
	    public static void main(String [] args) {
        double d1 = 12.9;

        //精度损失举例1
        int i1 = (int)d1;  //阶段操作
        System.out.println(i1); //12

        //精度损失举例2
        int i2 = 128;
        byte b = (byte)i2;
        System.out.println(b);  //-128

        //没有精度损失
        long long1 = 123L;
        short s2 = (short)long1;
        System.out.println(s2); //123

        //-----------------------------------
        //变量运算规则的两个特殊情况
        //编码情况1：
        long long2 = 123213;    //没有错【数值较小时不报错】
        //long l1 = 12345678900;  //编译失败【数值较大时会出错】
        System.out.println(long2);

        long long3 = 123456789000L;	//数据范围比较大时，需要加上 l 或 L
        System.out.println(long3);

        //float f1 = 12.3;  //编译失败【小数默认为double，需要强转为float】
        float f2 = (float) 12.3;
        System.out.println(f2);

        //编码情况2：
        //整型常量，默认类型为int型
        //浮点型常量：默认类型为double型

        byte b1 = 12;
        //byte b2 = b1 + 1;  //编译失败
        //float f3 = b1 + 12.3;   //编译失败
    }
}

二、Java中的六种运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

1、算术运算符

算术运算符（Arithmetic Operator）： + - + - * / % ++ – +（字符串连接）

运算符	运算	示例	结果
+	正号	+666	666
-	负号	-88	-88
+	加	6 + 9	15
-	减	88- 66	22
*	乘	6 * 6	36
/	除	8 / 6	1
%	取余 (取模)	8 % 6	2
++	自增（前置）：先运算后取值	a = 2; b = ++a;	a = 3; b = 3;
++	自增（后置）：先取值后运算	a = 2; b = a++;	a = 3; b = 2;
–	自减（前置）：先运算后取值	a = 2; b = --a;	a = 1; b = 1;
–	自减（后置）：先取值后运算	a = 2; b = a–;	a = 1; b = 2;
+	字符串连接	“he” + “llo”	“hello”

//注意：% 取余运算
//结论：结果的符号与被模数的符号相同
int m;   //被模数
int n;

m % n = 12 % 5 = 2;
m % n = 12 % -5 = 2;

m % n = -12 % 5 = -2;
m % n = 12 % -5 = -2;

short s1 = 10;
s1 = s1 + 1;  //错误：1为整型
s1 = (short)(s1 + 1);	//正确
s1++;	//自增1不会改变本身变量的数据类型

2、赋值运算符

符号：=

• 当 “=” 两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
• 支持连续赋值。

扩展赋值运算符：+= 、-= 、*= 、 /= 、 %=

int num = 10;
//开发中：如果希望变量实现 +n（n > 1）的操作，有2种方法
num = num + 2;
num += 2;	//推荐

//开发中：如果希望变量实现 +1 的操作，有3种方法
num = num + 1;
num += 1;
num++;		//推荐

short s1 = 10;
s1 = s1 + 2;	//编译失败
s1 += 2;		//不会改变变量本身的数据类型

3、比较运算符

比较运算符（关系运算符）：== != < > <= >= instanceof

比较运算符的结果都是boolean型，也就是要么是true，要么是false。

运算符	运算	示例	结果
==	相等于	6 == 8	false
!=	不等于	6 != 8	true
<	小于	6 < 8	true
>	大于	6 > 8	false
<=	小于等于	6 <= 8	true
>=	大于等于	6 >= 8	false
instanceof	检查是否是类的对象	“Hello” instanceof String	true

4、逻辑运算符

逻辑运算符：&(逻辑与) &&(短路与) |(逻辑或) ||(短路或) !(逻辑非) ^(逻辑异或)

//区别：& 与 &&
//相同点：& 与 && 的运算结构相同
//相同点：当符号左边是true时，二者都会执行符号右边的运算
//不同点：当符号左边是false时，&继续执行符号右边的运算，而&&不再执行符号右边的运算
public class Text {
    public static void main(String [] args){
        boolean b1 = false;
        int num1 = 10;
        if (b1 & (num1++ > 0)) {
            System.out.println("我们都一样");
        } else {
            System.out.println("我们都不一样：" + num1);  //num = 11}
        }

        boolean b2 = false;
        int num2 = 10;
        if (b2 && (num2++ > 0)){  //false
            System.out.println("我们都一样");
        } else{
            System.out.println("我们都不一样：" + num2);   //num = 10}
        }
    }
}

// 区别：| 与 ||
//相同点：| 与 || 的运算结构相同
//相同点：当符号左边是false时，二者都会执行符号右边的运算
//不同点：当符号左边是ture时，|继续执行符号右边的运算，而||不再执行符号右边的运算

5、位运算符

位运算符：是直接对整数的二进制进行的运算

// << ：在一定范围内，每向左移动1位，相当于 *2
// >> ：在一定范围内，每向右移动1位，相当于 /2

//面试题：最高效方式的计算 2*8     2<<3 或  8<<1
int i = 21;

System.out.println(i << 2);	// 21 * (2^2) = 84
System.out.println(i << 3);	// 21 * (2^3) = 168

int m = 12;
int n = 5;
m & n = 4;
m | n = 13;
m ^ n = 9;

6、三元运算符

三元运算符（条件运算符）： ? :

• 格式：

• 表达式1 和 表达式2 为同种类型
• 三元运算符 与 if-else的联系与区别：

• 三元运算符可简化if-else语句
• 三元运算符要求必须返回一个结果
• if后的代码块可有多个语句

//凡是可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符（原因：简洁、执行效率高）
//反之，不成立

max = (m>n) ? m : n;

//三元运算符可以使用嵌套
int n1 = 12;
int n2 = 30;
int n3 = -43;

max1 = (n1>n2) ? n1 : n2;
max2 = (max1 > n3) ? max1 : n3;

//不建议
max = (   ((n1>n2) ? n1 : n2) > n3)   ?   ((n1 > n2) ? n1 : n2)     :   n3   );

max = (m>n) ? "m大" : n;  //错误

//改进：
String max = (m > n) ? "m最大" : "n最大";
String maxStr = (m > n) ? "m最大" : (m == n) ? "m和n相等" : "n大";

---

😜 相 见 就 是 【 猿 分 】 🐒
.
👀 感谢您阅读完此文章 👀
.
❓ 希望能够对你有所帮助 🎯
.
❌ 如果文章中有错误的地方请指正 ✔️
.
💪 感谢支持，一起加油，共同进步