Java Lecture 2：数据类型转换、运算符以及流程控制

目录

一、基本数据类型转换

二、运算符

数学运算符

自增自减运算符（重要）

关系运算符 

逻辑运算符

一道简单的逻辑判断题

扫描器 Scanner （重要）

赋值运算符

三元(三目)运算符

字符串拼接符

三、流程控制

顺序结构

分支结构

单路分支

双路分支

多路分支

if else if

Switch case

循环结构

While 循环

do while循环

for循环(最常用)

---

一、基本数据类型转换

类型转换有两种: 自动类型转换 、强制类型转换

1.自动类型转换(隐式转换)：将小类型赋值给大类型的过程

从小到大（按字节空间排序）：byte --->short ----> int ----->long ---->float ----->double

其他类型基本不用，所以这里不强调

2.强制类型转换(显示转换):将大类型转载(赋值)给小类型的过程

强转有风险,使用需谨慎,有可能强转后的类型装载不了强转之前的数据.

（就是可能因为数据太大了，前面的小类型无法装载，就会报错）

需要强转的时候的例子：  a = 100L; int b = (int)a;

所以要确保数据不会溢出才转. 

代码实例：
 

/自动类型转换
        int a = 100;//没有发生类型转换！
        long b = a;//发生自动类型转换
        double c = b;//发生自动类型转换
​
​
        //强制类型转换
        long d = 2147483647L;//long类型的数据
        int e = (int)d;//使用强制转换的语法:在需要强制转换的变量前面加上小括号,小括号里写要转换的类型即可
        System.out.println(e);
​
        double f = 3.1415926;
        int g = (int)f;//将小数类型强转为整数类型时,  会截断删除小数点后的内容.
        System.out.println(g);//3

规则: 

1. 整数直接量是可以直接赋值给byte ,short , char类型的！但是不能超过当前类型范围
   （例子：char t = 97 这里的97是ASCII码，输出t会是输出它对应的字母。）
2. byte,short,char 如果进行运算时,系统会自动将其结果转换为int类型!
   （比如：byte a = 10; byte b = 20; 那 byte c = a + b就会报错，因为此时的c默认为int，所以要得出c的话就需要int c = a + b，或者强转为byte）
3. 小类型与大类型在参与运算时,系统会自动将其结果转换为大类型.

4. 默认的整数直接量是 10进制 直接量，由数字：0123456789组成（例：100）

5. 使用0x开头的直接量是16进制直接量，由数字及字母：0123456789abcdef组成
   （例：0xef123b)

   使用0开头的直接量是 8进制 直接量，由数字：01234567组成(例：0123）

   使用0b开头的直接量是 2进制 直接量，由数字：01组成（例：0b00101）

char d = 'a';//97
char e = 'a';//97
System.out.println(d + e);//194  两个char相加结果为int
System.out.println((char)(d + e));//将int的码转换为字符显示

byte b1 = 100;
byte b2 = (byte)(b1+20);
int b2 = b1 +20; //byte(小类型) + int (大类型) 运算结果就是大类型.

二、运算符

数学运算符

        +,-,*,/,%

%是取余，取模，算出余数

注意：取余操作时，若左边小于右边，则取余结果仍然为左边的数据。

比如：

System.out.println(1 % 3);//1
System.out.println(2 % 3);//2
System.out.println(3 % 3);//0

自增自减运算符（重要）

自增：在变量自身基础上增加1 自增符号(++)

自减：在变量自身基础上减少1 自减符号( -- )

注意符号要紧挨着。

1.单独运算时(只有当前变量被运算),符号在前在后都一样,都会完成自增或者自减。

int a = 5;
a++
System.out.println(a);//6
++a
System.out.println(a);//7

2.参与运算时(赋值也算运算),符号在前在后不一样.

        2.1符号如果在后,就会先参与其它运算,然后再去进行自增或自减。

        2.2符号如果在前,就会先进行自增或自减,再去参与其它运算。       

看下面这两个例子就懂了：

      int a = 5;
      int b = 5;
      int c = a++;
      int d = ++b;
      System.out.println(a);//6
      System.out.println(b);//6
      System.out.println(c);//5
      System.out.println(d);//6

 /**
         * 面试题：
         * */
        int a = 1;
        //符号在后,所以先将变量的内容赋值给临时变量进行存储。
        //接着再进行变量的自增
        //最后再将临时变量赋值给a
        a = a++; //(1)temp = a; (2) a = a+1; (3)  a = temp;
        System.out.println(a);//输出1
​
        int b = 1;
        //符号在前,(1)先将变量进行自增
        //(2)再将变量的内容赋值给临时变量进行存储。
        //(3)最后再将临时变量赋值给b
        b = ++b;//(1)b = b+1; (2) temp = b; (3) b = temp;
        System.out.println(b);//输出2

关系运算符 

大于( > ) ，小于( < ) ，大于等于( >= ) ，小于等于( <= ) 等于号( == ) ，不等于号( != )

关系运算符的运算结果一定是boolean类型的结果。（和python一样，没什么好说的）

主要看代码的写法：

int a = 50;  int b = 40;
boolean r = a > b;              
​
int c = 50; int d =50;
boolean r1 = c >= d;
    
int e = 100; int f = 99;
f++;
boolean r2 = e == f;
System.out.prinln(r2);//true
​
​
System.out.prinln(100 != 100); // false
---------------------------------------
        int a = 50;
        int b = 40;
        boolean r = a > b;
        System.out.println(r);
        System.out.println(a <= b);//false
        System.out.println(10 < 10);// false
        System.out.println(10 != 10);//false
        System.out.println(5 == 4);//false

逻辑运算符

逻辑运算符是结果一定是boolean类型

Java中逻辑运算符分为3种:

与(&&)、或(||)、非(!)

例子（必看）：

        int a = 5;
        int b = 10;
        int c = 5;
        boolean r = a > b && b > c;// false && true
        System.out.println(r);//false
​        System.out.println(a > b || b > c);//false
​        System.out.println(a == ++c && c > 5);//false
        //注意 这个时候c在此时已经自增过了。
        System.out.println(c == ++a && b == 10);//所以这个是对的，true
        //所以代码要结合一起去看，自增和自减之后，无论是不是赋予了变量，
        //还是在自增或自减里面发生了改变，都一定会改变目前变量的值，面试题常考。

一道简单的逻辑判断题

判断年份是否为闰年?

        //闰年的判断条件：
        /**
         *      条件1 ： 年份能被4整除  并且 年份不能被100整除
         *          或者
         *      条件2：  年份能被400整除
         * */
        Scanner s = new Scanner(System.in);//创建了一个扫描器
        System.out.println("请输入要判断闰年的年份，回车即可");
        int year = s.nextInt();//使用扫描器接收控制台中int类型的数据 并存给了year
//        boolean r1 = year % 4 == 0 && year % 100 != 0; //条件1
//        boolean r2 = year % 400 == 0;//条件2
//        boolean result = r1 || r2;//条件1 或(||) 条件2
//        System.out.println(result);
​
        //推荐写法：                   条件1                    或       条件2
        boolean result2 = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
        System.out.println(result2);

扫描器 Scanner （重要）

作用：可以通过Scanner在控制台中输入数据并接收,方便后续的代码逻辑操作。

Scanner在写入时,不需要拼全,显示后直接回车即可!

创建时：Scanner 变量名 = new Scanner(System.in);
（例如：Scanner s = new Scanner(System.in) 

使用时：数据类型 变量名 = 扫描器的变量名.next数据类型（例：int year = s.nextInt()）

赋值运算符

赋值号: =

扩展赋值号: += , -= , *= , /= , %=

直接看例子即可：

//扩展赋值号的使用:使用扩展赋值号对自身变量进行运算,并将结果影响自身的操作.
        int a = 10;
        a += 10;  //等价于:  a = a + 10;
        System.out.println(a);//20
​
        a -= 10; //等价于:  a = a - 10;
        System.out.println(a);//10
​
        a *= 2;  //等价于:  a = a * 2;
        System.out.println(a);//20
​
        a /= 5; //等价于:  a = a / 5;
        System.out.println(a);//4
​
        a %= 2; //等价于:  a = a % 2;
        System.out时.println(a);//0
​
         //面试题:
        byte b = 5;
        b = b + 5; 会显示编译错误:因为小类型+大类型 结果为大类型
        b += 5;//但是注意！在使用扩展赋值时,系统会自动帮我们做强转为小类型  
               //比如这里相当于b =  (byte)(b + 5);并且不会报错

三元(三目)运算符

语法: boolean ? 值1 : 值2 ;

判断的逻辑 ? 若为true 返回值1: 若为false返回值2

看例子就懂了：

        int a = 10;
        int b = 20;
        //使用三元表达式时,用什么类型来接受主要看值1和值2的类型
        //所以一般值1和值2类型要求统一.

        //  判断的逻辑  ? 若为true 返回值1 : 若为false返回值2
        int max = a > b ? a : b;
        System.out.println(max);
​
        int c = 10;
        boolean r = c % 2 == 0 ? true : false;
        System.out.println(r);
​
        String s = c%2 == 0 ? "是偶数":"是奇数";
​
        System.out.println(s);

字符串拼接符

字符是char类型,用单引号进行存储,只能存储一个字符（如 char temp = 'A')

字符串是String类型,用双引号来进行存储,可以存储一串字符.（如 String name = "你好")

7.1 使用+号时,若两边都是数值类型,则会进行运算操作.

7.2 使用+号时,若里面只要有一方为字符串类型,则把所有进行拼接操作,变成一个整体的字符串.

和python基本一致

例子：（重点看代码的实现，去复现）

        int c = 10;
        boolean r = c % 2 == 0 ? true : false;
        System.out.println(r);
        String s = c % 2 == 0 ? "是偶数" : "是奇数";
        System.out.println(c + "这个值是:" + s);
        int age = 30;
        String name = "李四";
        System.out.println("我叫:" + name + "我的年龄是:" + age);
​
        System.out.println(10 + 10 + "" + 30);//"2030"
        System.out.println("" + 10 + 10 + 30);//“101030”（7.2的例子）
        System.out.println(10 + 10 + 30 + "");//"50"
        //注意！这里是从左加到右，所以从前往后开始计算且拼接

流程控制

Java中流程控制分为3种,任何复杂的业务逻辑,都可以通过这三种方式来实现.

1.顺序结构:代码逐语句执行,顺序执行,每句代码都执行.

2.分支结构:有条件的执行某个语句,并非每句都执行.

3.循环结构:有条件的重复执行某个语句,并非每句都执行.

顺序结构

分支结构

单路分支

 /** 语法结构：
         *       条件
         *  if(boolean){
         *      //条件成立则执行的代码块
         *  }
         *  执行过程：
         *          判断if小括号中的条件是否成立。
         *          若成立,则执行条件成立的代码块
         *          若不成立,代码跳过if的代码块...继续向下执行
         */

双路分支

       /**语法结构
         *      条件
         * if(boolean){
         *      满足条件所执行的代码块
         * } else{ 否则..
         *     不满足条件 所执行的代码块
         * }
         * 执行过程：
         *        先去判断if小括号里面的条件
         *        若成立则执行  满足条件所执行的代码块
         *        若不成立则执行 不满足条件 所执行的代码块

多路分支

if else if

 /**语法结构
         *  if(条件1){
         *       若条件1成立 则执行当前代码块
         *  } else if(条件2){
         *      若条件2成立 则执行当前代码块
         *  }else if(条件3){
         *           若条件3成立 则执行当前代码块
         *  }...

Switch case

适用性：对数值的数据进行判等时,使用switch case 效率要比if elseif 高一些。

而且Java7版本以后支持可以使用String。（使用s.nextLine()接受字符串）

break (和python一样）

面试题：Swicth case 结构中 ，接收的num支持的类型有：

byte、short、int、char、String、枚举值，记得long不行

//语法结构
        int num = s.nextInt();
        //这里要带括号，并且num只是一个数字
        switch(num){
            case 1://这里的1是什么数字都行，但是记得后面没有括号，
                   //并且case后面是数字

            case 2:
               
            case 3:
                
            default:
                System.out.println("对不起");

例子：
        Scanner s = new Scanner(System.in);
        System.out.println("中文请按1,英文请按2 ,人工服务请按0");
        int num = s.nextInt();
        switch (num){
            case 1://如果输入的num = 1
                System.out.println("中文服务开始");
                break;//退出当前switch代码块
            case 2://如果输入的num = 2
                System.out.println("英文服务开始");
                break;//退出当前switch代码块
            case 0://如果输入的num = 0
                System.out.println("人工服务请稍后...");
                break;//退出当前switch代码块
            default://默认 执行到这里代表上述的case 都没匹配上,默认执行的语句,相当于else
                System.out.println("指令输入有误");
        }
        System.out.println("代码继续向后执行");
    }

循环结构

Java中循环分为3种：1.while 2.do while 3.for(最常用) 

循环三要素：1.循环变量的初始化 2.基于循环变量的条件 3.循环变量的改变

例子：
跑三圈
初始圈数                        圈数为0    
够三圈吗?    不够     跑一圈      圈数为1
够三圈吗?    不够     跑一圈      圈数为2
够三圈吗?    不够     跑一圈      圈数为3
够三圈吗?    够了     不跑了 
    
   三要素：
            1.int count = 0; //循环变量的初始值
            2. count < 3 ; //基于循环变量的条件
            3. count++;//循环变量的改变
​

While 循环

有可能一次都不执行

 /** while循环的语法结构
         *  1.循环变量初始化
         *  while(2.条件){
         *      条件成立则执行的代码块
         *      3.循环变量的自增
         *  }
         * */

do while循环

先做一次循环的代码块,再去判断条件,至少执行一次循环的代码块。

do while 语法演示：
         *   1.
         *   do{
         *       循环的代码块
         *   }while(条件);

经典例子：猜大小

Math.random(); 是java提供一个工具,是用来生成随机数的功能。生成的随机数是0~1但是取不到1的小数。

//随机数的使用：
        double r = Math.random();//返回0~1的随机小数 取不到1
//        System.out.println(r);
//        double r1 = Math.random()*100;
//        System.out.println(r1);
        int r2 = (int)(Math.random()*100);//将随机的小数数据 强转为整数并使用r2变量进行接收
       // System.out.println(r2);
        //区间随机数的公式：  (int)(随机数 *(最大值-最小值)+最小值)
        //   90 - 100 区间的随机整数
        int r3 = (int)(Math.random() * (100 - 90) +90);
        System.out.println(r3);

        /*  猜大小：
         *   通过程序产生0~100区间的随机数,然后提示用户输入 猜0~100区间的数字,用户若猜对则提示猜对了,
         *   若猜错了,则提示猜错了。
         *   2.0 : 用户若猜错了,继续让用户猜,条件：用户猜不对！就要一直猜
         *   3.0  ： 若猜错,提示 猜大了还是猜小了。
         * */
        int r = (int) (Math.random() * 100);//系统产生的数据0-100 取不到100的随机
        Scanner s = new Scanner(System.in);//创建一个扫描器
        int user;
        do {
            //变量能在当前类的哪里使用,从上数离它最近的开始花括号 { 和对应的结束花括号的位置。
            System.out.println("请猜0-99之间的数据" + r);
            user = s.nextInt();//通过控制台接收用户输入的int的数据 存给 user这个变量
            if (user == r) {//如果用户输入的数据 和 系统产生的数据一样
                System.out.println("666，猜对了");
            } else if (user > r) {//如果用户猜的数据大于系统产生的数据
                System.out.println("555,猜大了");
            } else {//否则用户一定是猜小了
                System.out.println("555,猜小了");
            }
        } while (user != r);//用户猜不对就要一直循环！

面试题：while 和do..while的区别

相同点：当不明确循环次数时，已知循环条件,可以选择while或 do..while

不同点：

while ：先去判断条件,再去执行循环代码块,有可能一次都不执行代码块。

do..while:先做一次循环体,再判断条件,至少执行一次代码块。

for循环(最常用)

当已知循环次数时,使用for循环。

continue:跳过当次循环 ,直接执行第for循环语法进行下一次的循环!

遇到continue后面的循环代码内容则不再执行了,继续下次循环。

break; 退出当前循环，相当于代码若遇到 break 直接退出循环了！

遇到break后直接退出循环,即使循环代码块的代码还没执行完,也直接退出不会再执行！

语法结构：

  for(int i = 0; i < 3; i++){
         *      循环代码块(循环体)
         *  }

for中声明的变量比较特殊,且只能在for中可用。其它地方视为看不到。

for(int i = 0;...){
    
}
for(int i = 0;...){     //与上面的for循环中的i不冲突！
    
}