Day3 运算符以及数据类型之间的转换

运算符

Java 语言支持如下运算符：

算术运算符: +，-，*，/，%，++，–
赋值运算符 =
扩展赋值运算符:+=，-=，*=，/=
关系运算符: >，<，>=，<=，==，!=
逻辑运算符: &&，||，!
位运算符: &，|，^，~ ， >>，<<，>>> (了解！！！)
条件运算符 ？：
相关概念辨析
+ 运算符 操作符 Operator
5+6 表达式 expression
5 6 操作数 Operand
int m =5+6; 语句 Sentence

注意：
1：/ 除 6/4=1 6/4.0=1.5
2: %取模(求余) 6%4=2
3：+ 6+‘a’=103
6+“a“=6ª
4：++
a=2;b=++a+9;
a=2;b=a+++9;

二元运算符类型提升：
整数运算：
如果两个操作数有一个为Long, 则结果也为long
没有long时，结果为int。即使操作数全为shot,byte，结果也是int.
浮点运算：
如果两个操作数有一个为double, 则结果为double.
只有两个操作数都是float, 则结果才为float.

例子：
/* short s1=1; //1
s1=s1+1; //2 类型提升问题
s1+=1; //3
System.out.println(s1);
*/
里面第二句话是错的，因为s1是short类型，1是int类型，把int+short赋值给short，类型就提升了，会出现问题。

算术运算符

算术运算符
+
1、加法运算
2、正号
int a = +10;
3、连接 将字符串与其他进行连接

-
1、减法运算
2、负号
*
乘法运算
/
除法运算
%
求模运算（取余数）
自增
++
先增
int num =10;
++num;
后增
int num2 = 10;
num++;
单独使用，先增。后增。都是让自身+1，没有区别；
与其他运算一起进行的时候，
先增： 先让自身+1，再参与运算
后增： 先参与运算，在让自身加1
int num3 = num1++;//后增，先让num1参与运算，运算完之后，自身+1
int num2 = 10;
int num4 = ++num2;//先增，先让num2自身+1，加1之后在参与运算

自减
- -
先减：
后减：
单独使用，先减。后减。都是让自身-1，没有区别；
与其他运算一起进行的时候，
先减： 先让自身-1，再参与运算
后减： 先参与运算，在让自身-1

int num3 = num1–;//后减，num1先参与运算，运算完自身-1
int num4 = –num2;//先减，num2先减1，在用减1之后的值参与运算

例题：

求一个四位数各个位置上的具体数字，并打印
int num = 1234;
int a,b,c,d;
a = num/1000;
b = num%1000/100;
c = num % 100 / 10;
d = num % 10;
*/

import java.util.Scanner;
public class Test10{
    public static void main(String[]args){
        Scanner sc = new Scanner(System.in);
        //记录输入的四位数
        int num;
        //分别记录千位、百位、十位、个位上的具体数字
        int a,b,c,d;
        //提示输入四位数字
        System.out.println("请输入任意一个四位数");
        //输入一个整数
        num = sc.nextInt();
        //求具体的数值
        a = num / 1000;
        b = num % 1000 / 100;
        c = num % 100 / 10;
        d = num % 10;
        System.out.println(num+"的千位为:"+a+",百位为:"+b+",十位为:"+c+",个位为:"+d);
    }
}

赋值运算符

=
int a = 10;
a = 20;
System.out.println(a = 30);

组合赋值运算符

+=
int a = 10;
a += 20; 等价于 a = a + 20;
System.out.println(a);//30
-=
a -= 20; 等价于 a = a - 20;
*=
/=
%=
a %= 20; 等价于 a = a % 20;

常规的交换方法：

int c = b;
b = a;
a = c;

比较运算符

>
<
>=
<=
!=
==
1、操作数：(除了boolean，（有数值的）都可以进行比较<小数一般不直接进行比较>)
10 > 4; 10 > 4得到一个true结果
错误写法：
10 > 4 > 1;
10 < ‘A’;
10.0 < 2.0;
1 > true;

2、比较结果
boolean类型（true、false）

例题

需求：
从键盘输入任意3个整型数值，从小到大排序，并打印
比较表达式的结果如果为true，则执行大括号中的代码，如果为false，则不执行
if(比较表达式){
代码…
}
30 20 10
先比较1跟2
在比较1跟3
最后比较2跟3

import java.util.Scanner;
public class Test6{
    public static void main(String[]args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入a的值");
        int a = sc.nextInt();
        System.out.println("请输入b的值");
        int b = sc.nextInt();
        System.out.println("请输入c的值");
        int c = sc.nextInt();
        //用来交换存储的临时变量
        int temp = 0;
        //排序（比较、交换）比较数值1跟数值2
        if(a > b){
            //交换两个数值的位置
            temp = b;
            b = a;
            a = temp;
        }
        //比较数值1跟数值3
        if(a > c){
            //交换两个数值的位置
            temp = c;
            c = a;
            a = temp;
        }
        //比较数值2跟数值3
        if(b > c){
            //交换两个数值的位置
            temp = c;
            c = b;
            b = temp;
        }
        System.out.println("从小到大:"+a+","+b+","+c);
    }
}

逻辑运算符

操作数
布尔值（或者是结果为布尔值的表达式）才能进行逻辑运算
得到的结果
布尔值
&:逻辑与
都为true的时候，结果为true,其他情况都为false
|:逻辑或
操作数只要有一个为true，则整个表达式的结果为true
^:逻辑异或
相同为false，不同为true
———-
!:逻辑非
==========
&&：短路与
与逻辑与的功能相似，（短路）
表达式1 && 表达式2
如果表达式1的值为false，则表达式2不会被执行

||：短路或
与逻辑与的功能相似，（短路）
表达式1 || 表达式2
如果表达式1的值为true，则表达式2不会被执行

开发中尽量使用短路与 以及 短路或

&和&&的区别
“&”:无论任何情况，“&”两边的表达式都会参与计算。
“&&”: 当“&&”的左边为false，则将不会计算其右边的表达式。即左false则false
“|”和“||”的区别与“&”和“&&”的区别类似

&&：短路与
与逻辑与的功能相似，（短路）
表达式1 && 表达式2
如果表达式1的值为false，则表达式2不会被执行
如果表达式1的值为true,则继续执行表达式2.

||：短路或
与逻辑与的功能相似，（短路）
表达式1 || 表达式2
如果表达式1的值为true，则表达式2不会被执行
如果表示式2的值为false,则表达式2会被执行。
逻辑与和逻辑或采用短路的方式。从左到右计算，如果确定值则不会再计算下去。
逻辑与只要有一个为false, 则直接返回false.
逻辑或只要有一个为true, 则直接返回true;

System.out.println("********逻辑与********");
System.out.println(true & true);//true
System.out.println(true & false);//false
System.out.println(false & true);//false
System.out.println(false & false);//false


System.out.println("********逻辑或********");
System.out.println(true | true);//true
System.out.println(true | false);//true
System.out.println(false | true);//true
System.out.println(false | false);//false



System.out.println("********逻辑非********");
System.out.println(!true);//false
System.out.println(!false);//true 

System.out.println("********逻辑异或********");
System.out.println((10 > 3) ^ (3 < 0));//
System.out.println(true ^ true);//false
System.out.println(true ^ false);//true
System.out.println(false ^ true);//true
System.out.println(false ^ false);//false 


System.out.println("********短路与********");
System.out.println(true && true);//true
System.out.println(true && false);//false
System.out.println(false && true);//false
System.out.println(false && false);//false

int a = 10;
System.out.println((a < 5) && (++a > 0));//false
System.out.println("a = " + a);//10

int b = 10;
System.out.println((b < 5) & (++b > 0));//
System.out.println("b = " + b);// 

int a = 10;
System.out.println((a > 5) || (++a > 0));//
System.out.println("a = " + a);//10

int b = 10;
System.out.println((b > 5) | (++b > 0));//
System.out.println("b = " + b);//11

位运算符（了解）

&：按位与
|：按位或
^：按位异或
对同一个数字异或两次，得到它本身

~：按位取反
原码、反码、补码

<< ：左移
2 << a
2乘以2的a次幂
>> ：右移
8 >> a
8除以2的a次幂
>>> ：无符号右移
最高位：不考虑符号位，全补0

java中的乘幂处理：
int a = 3^2; //java中不能这么处理， ^是异或符号。
double b = Math.pow(3, 2);
Math类提供了很多科学和工程计算需要的方法和常数。

条件运算符(三目运算符：操作数三个)

表达式1(布尔表达式) ? 表达式2 : 表达式3;
语法格式
x ? y : z
唯一的三目运算符
执行过程
其中 x 为 boolean 类型表达式，先计算 x 的值，若为true，则整个三目运算的结果为表达式 y 的值，否则整个运算结果为表达式 z 的值。
经常用来代替简单的if-else判断！
找出num1与num2中较大值，存入max中
max = num1 > num2 ? num1 : num2;

运算符的优先级

括号>单元操作符>算术运算符>移位操作符>关系运算符>位运算符>逻辑运算符>三元操作符>赋值运算符

数据类型之间的转换

在赋值运算或算术运算时，要求数据类型相同，否则要进行类型转换

double
float
long
int
short(char)
byte

1、自动转换（从低->高）
1.等号两侧的转换
2.等号同侧的转换

2、强制转换（丢失精度）（从高->低）

3、特殊转换
byte.short.int.long
可以将整型常量直接赋值给byte, short, char等类型变量，而不需要进行强制类型转换，只要不超出其表数范围
short b = 12; //合法
short b = 1234567; //非法

最好不要比较小数的大小。因为会丢失精度。

原码补码反码

原码：原码就是符号位加上真值的绝对值, 即用第一位表示符号, 其余位表示值. 比如如果是8位二进制
[+1]原 = 0000 0001

[-1]原 = 1000 0001
反码的表示方法是:

正数的反码是其本身

负数的反码是在其原码的基础上, 符号位不变，其余各个位取反.

[+1] = [00000001]原 = [00000001]反

[-1] = [10000001]原 = [11111110]反
补码的表示方法是:

正数的补码就是其本身

负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)

[+1] = [00000001]原 = [00000001]反 = [00000001]补

[-1] = [10000001]原 = [11111110]反 = [11111111]补

例题：

1.利用”异或”运算的性质,对几个字符进行加密并输出密文,然后再解密。
加密算法是：密钥是字符’8’，
明文的每个字符和密钥进行异或运算，得到密文。
密钥和密文的每个字符再次进行异或运算，重新得到明文。

import java.util.Scanner;
public class Decode{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        char ch1='十';
        char ch2='点';
        char ch3='进';
        char ch4='攻';
        ch1=(char)(ch1^'8');
        ch2=(char)(ch2^'8');
        ch3=(char)(ch3^'8');
        ch4=(char)(ch4^'8');
        System.out.println(ch1+","+ch2+","+ch3+","+ch4);

        System.out.println("重新得到明文请继续:1、继续");
        int a=sc.nextInt();
        if(a==1){
        ch1=(char)(ch1^'8');
        ch2=(char)(ch2^'8');
        ch3=(char)(ch3^'8');
        ch4=(char)(ch4^'8');
            System.out.println((ch1+","+ch2+","+ch3+","+ch4));
        }else{
            System.out.println((ch1+","+ch2+","+ch3+","+ch4));
        }
}
}

2.从键盘录入三个整数，找出三个整数中的最大值，最小值？
导入头文件
1、定义变量(Scanner sc,int num1,int num2,int num3,int max)
2、输入对应变量的值
3、比较，找出最大值（比较几次？ 2次）
4、打印

import java.util.Scanner;
public class Test3{
    public static void main(String[]args){
        Scanner sc = new Scanner(System.in);
        int num1,num2,num3,max;
        System.out.println("请输入第一个数");
        num1 = sc.nextInt();
        System.out.println("请输入第二个数");
        num2 = sc.nextInt();
        System.out.println("请输入第三个数");
        num3 = sc.nextInt();
        //找出num1与num2中较大值，存入max中
        max =  num1 > num2 ? num1 : num2;
        //找出max与num3中较大值，重新存入max中
        max = max > num3 ? max : num3;

        System.out.println("三个数中的最大值为:"+max);
    }
}

3.某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。结果如图所示

import java.util.Scanner;
public class Encrypt{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个四位数；");
        int a=sc.nextInt();
        int c=(a/1000)+5;
        int d=(a/100%10)+5;
        int e=(a/10%100%10)+5;
        int f=(a%10)+5;
        c=c%10;
        d=d%10;
        e=e%10;
        f=f%10;
        int temp;
        temp=c;
        c=f;
        f=temp;
        temp=d;
        d=e;
        e=temp;
        System.out.println("加密后的数字为："+c+d+e+f);

    }
}

小结

1.运算符
算术运算符
难点 ++ – 注意+的三个作用
赋值运算符
= += -=…
sum+=6—->sum=sum+6
关系运算符
> < == 关系运算的结果是boolean类型

逻辑运算符
操作数和结果都是boolean型
&和&&的区别和联系（是否短路）

条件运算符
? : 唯一的三目运算符
int max = num1>num2?num1:num2;
位运算符 了解即可
运算符的优先级别:
1.不用刻意背诵，多做练习
2.单目>算术>关系>逻辑>条件>赋值
2.基本数据类型的类型转换
1.自动类型转换 double d=5;
2.强制类型转换 int n =(int)3.14;
3.字符集 Java采用Unicode字符集 常用字符集都兼容ASCII字符集