1. 课前回顾:
  2.    1.Java的环境:
  3.      jvm:运行Java程序的,运行的是编译生成的.class文件
  4.      跨平台性:一个应用程序,可以在不同的操作系统上运行,需要安装不同版本的jvm
  5.      jre:运行Java程序的,包含了jvm
  6.      jdk:开发工具包,包含了jvm以及开发工具包
  7.    2.环境变量
  8.      JAVA_HOME
  9.    3.注释:对代码进行解释说明
  10.          单行:   //
  11.          多行:   /**/
  12.          文档:   /**内容*/
  13.    4.关键字:java提前定义好的,具有特殊含义的小写单词,在高级记事本中颜色特殊
  14.    5.开发三步骤:
  15.      编写:
  16.        public class 类名{
  17.            public static void main(String[] args){
  18.                System.out.println("内容");
  19.            }
  20.        }
  21.      编译:
  22.        javac 文件名.java
  23.      运行:
  24.        java 文件名
  25.    6.常量
  26.      整数常量  小数常量 字符常量(单引号中必须有且只能有一个内容)  字符串常量  布尔常量 空常量
  27.    7.变量:
  28.      int i = 10;
  29.      作用:一次存储一个数据
  30.      数据类型:
  31.        基本类型:
  32.          整型: byte short int long
  33.          浮点型:float double
  34.          字符型:char
  35.          布尔型:boolean
  36.        引用类型:
  37.           数组 类 接口 注解 枚举
  39. 今日重点:
  40.    1.要知道变量的注意事项
  41.    2.知道什么时候发生自动类型转换(不用我们手动去做)
  42.    3.知道怎么强制类型转换(需要我们手动处理)
  43.    4.会使用所有的运算符

第一章.变量

数据类型 关键字 内存占用 取值范围
字节型 byte 1个字节 -128 至 127 定义byte变量时超出范围,废了
短整型 short 2个字节 -32768 至 32767
整型 int（默认） 4个字节 -231 至 231-1 正负21个亿
长整型 long 8个字节 -263 至 263-1 19位数字
单精度浮点数 float 4个字节 1.4013E-45 至 3.4028E+38
双精度浮点数 double（默认） 8个字节 4.9E-324 至 1.7977E+308
字符型 char 2个字节 0 至 216-1
布尔类型 boolean 1个字节 true，false

1.变量的介绍以及使用

  1. //  转义字符
  2. /*
  3.   \  代表的是转义字符
  4. */
  6. public class Demo01Var{
  7.     public static void main(String[] args){
  8.         /*
  9.           \n  代表的是换行
  10.         */
  11.         char c1 = '\n';
  12.         System.out.print("哈哈哈");
  13.         System.out.print(c1);
  14.         System.out.print("哈哈哈");
  15.         System.out.print(c1);
  17.         /*
  18.           \t  制表符  相当于tab键
  19.         */
  20.         System.out.println("hah"+'\t'+"haha");
  22.         /*
  23.            在java中表示路径怎么表示?
  24.            E:\Idea\io
  26.            在java中两个反斜杠代表一个反斜杠
  28.            \\
  29.         */
  30.         String path = "E:\\Idea\\io";
  31.         System.out.println(path);
  33.         char c2 = '\'';
  34.         System.out.println(c2);
  35.     }
  36. }

2.变量使用时的注意事项

  1. 1.变量不初始化(第一次赋值)不能直接使用
  2. 2.在同一个作用域(一个大括号就是一个作用域)中,不能定义重名的变量
  3. 3.不同的作用域之间的变量不要随便互相访问
  4.   小作用域中能访问大作用域中提前定义好的的变量
  5.   大作用域中不能直接访问小作用域中的变量
  1. public class Demo02VarNotice{
  2.     public static void main(String[] args){
  3.         int i;
  4.         i = 10;
  5.         System.out.println(i);
  7.         //int i = 20;//错误  在同一个作用域中不能定义重名的变量
  8.         System.out.println(i);
  11.         int j = 100;
  12.         {
  13.           System.out.println(j);    
  15.           int x = 10000;
  16.         }
  17.         //System.out.println(x);    
  18.     }
  19. }

3.练习

  1. 需求:变量去描述一个人
  2.     人:  姓名  年龄  性别  身高  体重
  1. public class Demo03Person{
  2.     public static void main(String[] args){
  3.         //姓名
  4.         String name = "和珅";
  5.         //年龄
  6.         int age = 30;
  7.         //性别
  8.         char sex = '男';
  9.         //身高
  10.         int height = 175;
  11.         //体重
  12.         double weight = 140.0;
  14.         System.out.println(name);
  15.         System.out.println(age);
  16.         System.out.println(sex);
  17.         System.out.println(height);
  18.         System.out.println(weight);
  19.     }
  20. }

第二章.标识符

  1. 1.概述:我们自己给类,方法,变量取得名字
  2. 2.硬性规定(必须遵守)
  3.   - 标识符可以包含`英文字母26个`、`0-9数字` 、`$（美元符号）`和`_（下划线）`。int a1_b = 10;
  4.   - 标识符不能以数字开头。int a1 = 10  int 1a = 100(错误)
  5.   - 标识符不能是关键字。int staic = 10(错误)  int staticpublic = 100
  7. 3.软性建议(建议遵守规则):
  8.   给类取名:每一个单词首字母都大写(大驼峰式) public class DemoTest
  9.   给方法取名字:  从第二个单词开始往后(包括第二个单词)首字母大写(小驼峰式)  
  10.   给变量取名字:  从第二个单词开始往后(包括第二个单词)首字母大写(小驼峰式)
  11.   取名字的时候最好要:见名知意

第三章.数据类型转换

  1. 1.什么时候会发生数据类型转换:
  2.   等号左右两边数据类型不一样
  3. 2.按照取值范围大小来排序(从小到大排序)
  4.   byte short char->int->long->float->double

1.自动类型转换

  1. 1.表示形式:
  2.   取值范围大的数据类型 变量名 = 取值范围小的数据类型
  3. 2.怎么转:
  4.   将小的类型自动转成大的类型
  1. public class Demo04DataType{
  2.     public static void main(String[] args){
  3.         /*
  4.           等号左边是long型的
  5.           等号右边是int型的
  7.           相当于将取值范围小的类型赋值给取值范围大的类型
  8.           会发生自动类型转换
  9.         */
  10.         long num1 = 100;
  13.         /*
  14.           等号左边是double型
  15.           等号右边是int型
  17.           相当于将int型的数据赋值给了double型的变量
  18.           将取值范围小的类型赋值给取值范围大的类型
  19.           发生了自动类型转换
  20.         */
  22.         double num2 = 1000;
  23.         System.out.println(num2);
  25.         /*
  26.           小类型和大类型做运算
  27.           小类型也会自动转成大类型->会自动提升
  28.         */
  29.         double num3 = 10+2.5;
  30.         System.out.println(num3);
  31.     }
  32. }

2.强制类型转换

  1. 1.什么时候需要强转
  2.   取值范围小的数据类型 变量名 = 取值范围大的数据类型->报错
  3. 2.怎么强转?
  4.    取值范围小的数据类型 变量名 =(取值范围小的数据类型) 取值范围大的数据类型
  1. public class Demo05DataType{
  2.     public static void main(String[] args){
  3.         /*
  4.           等号右边为long型
  5.           等号左边为int型
  6.           相当于将取值范围大的类型赋值给取值范围小的类型,需要强转
  7.         */
  8.       int num1 = (int)100L;
  9.       System.out.println(num1);
  11.       /*
  13.        等号右边是double型
  14.        等号左边是float型
  15.        相当于将取值范围大的类型赋值给取值范围小的类型,需要强转
  16.       */
  18.       float num2 = 2.5F;
  19.       System.out.println(num2);
  20.     }
  21. }

3.强转的注意事项

  1. 1.不要随机(故意)写成强转的形式(除非不得已),有可能会出现精度损失以及数据溢出现象
  2. 2.byte,short如果等号右边是常量,没有超出取值范围,不会报错(jvm已经针对此种情况做了优化,jvm自动强转了)
  3.   byte,short如果等号右边有变量参与,会自动提升为int型,需要手动强转
  5. 3.char
  6.   如果等号右边是常量,不用强转(jvm自动转了)
  7.   如果等号右边有变量参与,也会自动提升为int型,需要强转
  9.   char类型一旦提升为int,会自动去码表中查询这个字符对应的int值->ASCII码表
  11.   char类型的数据只要是参与运算,都会被提升为int型做运算
  13.   如果ASCII码表中没有字符对应的int值,会去Unicode的码表中查询字符对应的int值->万国码
  1. public class Demo06DataTypeNotice{
  2.     public static void main(String[] args){
  3.         /*
  4.           等号右边是double型
  5.           等号左边是int型
  6.           相当于将取值范围大的类型赋值给取值范围小的类型,报错了,需要强转
  7.         */
  8.         int i = (int)2.9;
  9.         System.out.println(i);
  11.         /*
  12.           数据溢出
  14.           int型占内存4个字节  
  15.           1个字节占多少个2进制位   8个
  17.           int型能表示的二进制位最多是32位二进制
  19.           100亿转成二进制:36位二进制
  21.           将36位二进制的数硬给最多能存32位二进制的int型,多出来4位,将100亿对应二进制
  22.           的前4位干掉,剩下的二进制对应的十进制就是1410065408
  23.         */
  24.         int num = (int)10000000000L;
  25.         System.out.println(num);//1410065408
  26.     }
  27. }
  1. public class Demo07DataTypeNotice{
  2.     public static void main(String[] args){
  3.         byte b = 10;
  5.         /*
  6.           byte型的sum等号右边有变量参数,此时自动提升为int型,需要手动强转
  8.           byte  = byte + int
  9.           byte = int+int
  10.         */
  11.         byte sum = (byte)(b+1);
  12.         System.out.println(sum);
  14.         System.out.println("==========华丽的分割线==========");
  16.         char c = 'a';
  18.         /*
  19.           char result = c+1
  21.           变量c代表的'a'自动提升为int型  'a'--> 97
  23.           char result = c+1 = 97+1=98
  25.           (char)98--> b
  27.         */
  28.         char result = (char)(c+1);
  29.         System.out.println(result);
  32.         char result01 = 98;
  33.         System.out.println(result01);
  36.         int result02 = 'a';
  38.         System.out.println(result02);
  40.         int result03 = '中';
  41.         System.out.println(result03);//20013
  42.     }
  43. }

第四章.运算符

1.算数运算符

  1. +
  2. -
  3. *
  4. /  -> 取的是整数部分(商)  ->如果是两个整数相除,取商,如果被除数和除数有一个为小数,结果就是小数
  5. %(模)  ->  取的是余数部分
  1. public class Demo08SuanShu{
  2.     public static void main(String[] args){
  3.         int i = 10;
  4.         int j = 20;
  6.         //推荐使用
  7.         int sum = i+j;
  8.         System.out.println(sum);
  10.         //不推荐
  11.         System.out.println(i+j);
  12.         //为了方便先直接放到输出语句中
  13.         System.out.println(i-j);
  14.         System.out.println(i*j);
  17.         int x = 10;
  18.         int y = 3;
  19.         int result01 = x/y;
  20.         System.out.println(result01);
  22.         int result02 = x%y;
  23.         System.out.println(result02);
  27.     }
  28. }
  1. +:
  2. 数和数之间用+  此+代表就是运算符号,加法
  4. 如果和字符串之间用+,代表的是字符串连接符号,直接往后拼接,不运算(任何类型遇到字符串都会变成字符串)
  1. public class Demo09SuanShu{
  2.     public static void main(String[] args){
  3.         int i = 10;
  4.         int j = 20;
  6.         System.out.println(i+""+j);//1020
  7.         System.out.println(i+j+"");//30
  8.         System.out.println(""+j+i);//2010
  9.         System.out.println(""+(j+i));//30
  12.         String s = (i+""+j);
  13.         System.out.println(s);//1020
  16.         int x = 100;
  17.         int y = 200;
  18.         int sum = x+y;
  20.         System.out.println("x与y相加之和为:"+sum);
  21.     }
  22. }

2.自增自减运算符(也算算数运算符的一种)

  1. 1.自增  ++
  2.   自减  --
  3. 2.注意:
  4.   a.++ -- 必须和变量一起使用  i++ ++i
  5.   b.++ -- 都是变化1
  6. 3.使用:
  7.   单独使用:++ -- 自身单独成为一句
  8.           符号在前还是在后,都是直接运算
  9.   混合使用:和赋值语句以及输出语句混合使用
  10.           符号在前:  先运算,再使用运算后的值
  11.           符号在后:  先用原来的值,用完之后再运算
  12. 4.注意:
  13.   开发时我们用的只有单独使用
  14.   平时不要瞎玩儿
  1. public class Demo10ZiZengZiJian{
  2.     public static void main(String[] args){
  3.         int i = 10;
  4.         //i++;
  5.         ++i;
  6.         System.out.println(i);
  8.         System.out.println("=======");
  10.         int j = 10;
  11.         //int result = ++j;
  12.         int result = j++;
  13.         System.out.println(result);
  14.         System.out.println(j);
  16.         System.out.println("=======");
  18.         int c = 100;
  19.         c = c++;
  20.         System.out.println(c);
  22.         System.out.println("=======");
  24.         int x = 10;
  25.         int y = 20;
  26.         /*
  27.           -9+19
  28.         */
  29.         int result02 = x++ - --y + y++;
  30.         System.out.println(result02);//10
  32.     }
  33. }
  1. 练习:
  2. 求出三位数中的每一位的数据
  4. 比如: 364  分别拿出3  6  4
  1. public class Demo11Test{
  2.     public static void main(String[] args){
  3.         int number = 364;
  4.         int bai = number/100;
  5.         int shi = number/10%10;
  6.         int ge = number%10;
  8.         System.out.println("百位为:"+bai);
  9.         System.out.println("十位为:"+shi);
  10.         System.out.println("个位为:"+ge);
  11.     }
  12. }

3.赋值运算符

  1. 基本赋值运算符:
  2. =:赋值符号,将等号右边的赋值给等号左边的变量
  4. 复合赋值运算符
  5. +=
  6.   int i = 10;
  7.   i+=1;  --> i = i+1
  8.   i+=2;  --> i = i+2
  9. -=
  10. *=
  11. /=  : 如果两个整数相除,取整数部分  除数和被除数有一个为小数,那么结果就是小数
  12. %=  : 取余数部分
  14. 注意:复合赋值运算符中,如果是byte short的话,不会出现错误,不用手动强转,(jvm自动强转)
  1. public class Demo12FuZhi{
  2.     public static void main(String[] args){
  3.         int i = 10;
  4.         i+=2;//i = i+2
  5.         System.out.println(i);
  8.         byte b = 1;
  9.         b+=1;//b = b+1
  10.         //b = b+1;
  11.         System.out.println(b);
  12.     }
  13. }

4.关系运算符(比较运算符)

  1. 1.关系运算符结果都是boolean型  都是用于做判断条件使用
  2. ==  : 判断符号前后的数据是否相等,如果相等结果为true,否则为false
  3. >   : 判断符号前面的是否大于符号后面的数据,如果大于返回true,否则返回false
  4. <   : 判断符号前面的是否小于符号后面的数据,如果小于返回true,否则返回false
  5. >=  : 判断符号前面的数据是否大于或者等于符号后面的数据,如果大于或者等于返回true,否则返回false
  6. <=  : 判断符号前面的数据是否小于或者等于符号后面的数据,如果小于或者等于返回true,否则返回false
  7. !=  : 判断符号前面的数据是否不等于符号后面的数据,如果不等于返回true,否则返回false
  1. public class Demo13Compare{
  2.     public static void main(String[] args){
  3.         int i = 10;
  4.         int j = 20;
  5.         int k = 10;
  6.         //==  : 判断符号前后的数据是否相等,如果相等结果为true,否则为false
  7.         boolean result01 = (i==j);
  8.         System.out.println(result01);
  9.         //>   : 判断符号前面的是否大于符号后面的数据,如果大于返回true,否则返回false
  10.         boolean result02 = (i>k);
  11.         System.out.println(result02);
  12.         //<   : 判断符号前面的是否小于符号后面的数据,如果小于返回true,否则返回false
  13.         System.out.println(i<j);
  14.         //>=  : 判断符号前面的数据是否大于或者等于符号后面的数据,如果大于或者等于返回true,否则返回false
  15.         System.out.println(i>=k);
  16.         //<=  : 判断符号前面的数据是否小于或者等于符号后面的数据,如果小于或者等于返回true,否则返回false
  17.         System.out.println(i<=j);
  18.         // !=  : 判断符号前面的数据是否不等于符号后面的数据,如果不等于返回true,否则返回false
  19.         System.out.println(i!=k);
  20.     }
  21. }

5.逻辑运算符

  1. 1.结果:都是boolean型  
  2. 2.作用:连接关系运算符的, 或者连接多个结果为boolean型结果的表达式
  3. &(与,并且):有假则假,如果符号前后有一个结果为false,结果就是false
  4. |(或):有真则真,如果符号前后有一个结果为true,结果就是true
  5. ^(异或):符号前后结果一样,返回false   符号前后结果不一样,返回true
  6.        true^true--> false
  7.        false^false  ->false
  8.        true^false  -> true
  9.        false^true  -> true
  10. !(非,取反):真亦假  假亦真
  11.        非true就是false    非false 就是true
  13. &&(双与):有假则假,如果符号前后有一个结果为false,结果就是false
  14. ||(双或):有真则真,如果符号前后有一个结果为true,结果就是true
  1. public class Demo14LuoJi{
  2.     public static void main(String[] args){
  3.         int i = 10;
  4.         int j = 20;
  5.         int k = 10;
  6.         // &(与,并且):有假则假,如果符号前后有一个结果为false,结果就是false
  7.         boolean result01 = (i>j)&(j<k);
  8.         System.out.println(result01);//false
  10.         // |(或):有真则真,如果符号前后有一个结果为true,结果就是true
  11.         boolean result02 = (i<j)|(j<k);
  12.         System.out.println(result02);//true
  13.         /*
  14.         ^(异或):符号前后结果一样,返回false   符号前后结果不一样,返回true
  15.                true^true--> false
  16.                false^false  ->false
  17.                true^false  -> true
  18.                false^true  -> true
  19.         */
  20.         boolean result03 = (i>j)^(j<k);//false ^ false
  21.         System.out.println(result03);//false
  22.         /*
  23.         !(非,取反):真亦假  假亦真
  24.                非true就是false    非false 就是true
  25.         */
  27.         boolean result04 = !(i==k);
  28.         System.out.println(result04);
  30.         /*
  31.           定义一个变量,表示分数,判断这个分数是否在1-100之间
  33.           数学写法:1<=score<=100
  34.           java写法:score>=1 & score<=100
  36.         */
  38.         int score = -1;
  39.         boolean result05 = (score>=1) & (score<=100);
  40.         System.out.println(result05);
  41.     }
  42. }

&& 和 & 以及|| 和|区别

&:如果符号前后是boolean表达式,是逻辑运算符

  1. 如果符号前后是数字,是位运算符
  3. 如果符号前面为false,jvm还会判断符号后面的表达式

&&:就是一个纯的逻辑运算符

  1.    有假则假,如果符号前面的为false,符号后面不看了(短路效果)

|:如果符号前后是boolean表达式,是逻辑运算符

  1. 如果符号前后是数字,是位运算符
  3. 如果符号前面为true,jvm还会判断符号后面的表达式

||:就是一个纯的逻辑运算符

  1.   有真则真,如果符号前面为true,jvm后面不看了(短路效果)

注意:开发时如果用到逻辑运算符的话,我们首先选用&& ||

6.三元运算符

  1. 1.格式:
  2.   boolean表达式?表达式1:表达式2
  3. 2.执行流程:
  4.   a.先走boolean表达式,判断
  5.   b.如果是true,执行?后面的表达式1
  6.   c.否则,执行:后面的表达式2

6.1练习1

  1. 需求:小明考完试了,判断小明的分数是否及格?
  2. 分析:
  3.   1.定义一个分数,随意赋值
  4.   2.判断如果分数>=60,返回及格
  5.   3.否则,返回不及格
  1. public class Demo15SanYuan{
  2.     public static void main(String[] args){
  3.         //定义一个变量,表示分数
  4.         int score = 59;
  5.         String result01 = (score>=60)?"及格":"不及格";
  6.         System.out.println(result01);
  7.     }
  8. }

6.2练习2

  1. 需求:
  2. 一座寺庙里住着两个和尚，已知他们的身高分别为150cm、210cm，请用程序实现获取这两个和尚的最高身高。
  1.         //定义两个变量分别表示两个和尚的身高
  2.         int heShang1 = 150;
  3.         int heShang2 = 210;
  5.         int result02 = (heShang1>heShang2)?heShang1:heShang2;
  6.         System.out.println(result02+"CM");

6.3 练习3

  1. 需求:
  2. 一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、170cm，请用程序实现获取这三个和尚的最高身高。
  4. 步骤:
  5.   先用前两个和尚身高进行比较,获取较大的值
  6.   然后再和第三个和尚比较,再拿较大的值
  1. public class Demo15SanYuan{
  2.     public static void main(String[] args){
  4.         //定义三个变量分别表示三个和尚的身高
  5.         int heShang1 = 150;
  6.         int heShang2 = 210;
  7.         int heShang3 = 170;
  9.         int temp = (heShang1>heShang2)?heShang1:heShang2;
  11.         int result02 = (temp>heShang3)?temp:heShang3;
  13.         System.out.println(result02+"CM");
  14.     }
  15. }

第五章.进制的转换(了解)

十进制 二进制 八进制 十六进制
0 0 0 0
1 1 1 1
2 10 2 2
3 11 3 3
4 100 4 4
5 101 5 5
6 110 6 6
7 111 7 7
8 1000 10 8
9 1001 11 9
10 1010 12 a或A
11 1011 13 b或B
12 1100 14 c或C
13 1101 15 d或D
14 1110 16 e或E
15 1111 17 f或F
16 10000 20 10

3.1 十进制转成二进制

  1. 辗转相除法(除以2取余数)

day02.[变量_数据类型转换_运算符] - 图1

3.2 二进制转成十进制

  1. 8421规则

day02.[变量_数据类型转换_运算符] - 图2

3.3 二进制转成八进制

  1. 将二进制分开(3位为一组)

day02.[变量_数据类型转换_运算符] - 图3

3.4 二进制转成十六进制

  1. 二进制分为4个为一组

day02.[变量_数据类型转换_运算符] - 图4

第六章.位运算符(了解)

day02.[变量_数据类型转换_运算符] - 图5

  1. 1代表true   0代表false
  3. 我们要知道计算机在存储数据的时候都是存储的数据的补码,而计算的也是数据的补码
  5. 1.正数二进制最高位为0;负数二进制最高位是1
  6. 2.正数的原码,反码,补码一致
  7.   如:5的源码,反码,补码为:
  8.      0000 0000 0000 0000 0000 0000 0000 0101->二进制最高位是0,因为是正数
  9. 3.负数的话原码,反码,补码就不一样了
  10.   反码是原码的基础上最高位不变,其他的0和1互变
  11.   补码是在反码的基础上+1
  13.   如:-9
  14.      原码:1000 0000 0000 0000 0000 0000 0000 1001
  15.      反码:1111 1111 1111 1111 1111 1111 1111 0110
  16.      补码:1111 1111 1111 1111 1111 1111 1111 0111

（1）左移：<<

  1. **运算规则**：左移几位就相当于乘以2的几次方
  3. **注意：**当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位
  1. 2<<2    等于8
  2. 相当于:2*(2的2次方)

day02.[变量_数据类型转换_运算符] - 图6

  1. -2<<2   等于-8
  3. 相当于:-2*(2的2次方)

day02.[变量_数据类型转换_运算符] - 图7

（2）右移：>>

快速运算：类似于除以2的n次，如果不能整除，向下取整

  1. 9>>2  等于 2
  3. 相当于:9除以(2的2次方)

day02.[变量_数据类型转换_运算符] - 图8

  1. -9>>2  等于-3
  3. 相当于:-9除以(2的2次方)

day02.[变量_数据类型转换_运算符] - 图9

（3）无符号右移：>>>

运算规则：往右移动后，左边空出来的位直接补0，不管最高位是0还是1空出来的都拿0补

正数：和右移一样

  1. 9>>>2  等于 2
  3. 相当于:9除以(2的2次方)

负数：右边移出去几位，左边补几个0，结果变为正数

  1. -9>>>2
  3. 结果为:1073741821

笔试题:8>>>32位->相当于没有移动还是8

  1.          8>>>34位->相当于移动2位

（4）按位与：&

小技巧:将0看成为false 将1看成true

运算规则：对应位都是1才为1,相当于符号左右两边都为true,结果才为true

  1.     1 & 1 结果为1
  3.     1 & 0 结果为0
  5.     0 & 1 结果为0
  7.     0 & 0 结果为0
  1. 比如:  5&3   结果为1

day02.[变量_数据类型转换_运算符] - 图10

（5）按位或：|

运算规则：对应位只要有1即为1,相当于符号前后只要有一个为true,结果就是true

  1.     1 | 1 结果为1
  3.     1 | 0 结果为1
  5.     0 | 1 结果为1
  7.     0 | 0 结果为0
  1. 比如: 5|3  结果为:7

day02.[变量_数据类型转换_运算符] - 图11

（6）按位异或：^

  1. 运算规则：对应位一样的为0,不一样的为1
  3.     1 ^ 1 结果为0 false
  5.     1 ^ 0 结果为1  true
  7.     0 ^ 1 结果为1   true
  9.     0 ^ 0 结果为0  false
  1. 比如: 5^3   结果为6

day02.[变量_数据类型转换_运算符] - 图12

（7）按位取反

运算规则：~0就是1

  1.                ~1就是0
  1. ~10     ->  结果为-11

day02.[变量_数据类型转换_运算符] - 图13

第七章.运算符的优先级(了解)

day02.[变量_数据类型转换_运算符] - 图14

  1. 提示说明：
  2. （1）表达式不要太复杂
  3. （2）先算的使用(),记住,如果想让那个表达式先运行,就加小括号就可以了
  4. i<(n*m)