01隐式转换

小转大
自动类型转换:
小的会自动变为大的.
byte,short,char类型在参与运算的时候,都会先变int,再参与运算.

  1. public class Demo1Conversion {
  2.     /*
  3.         隐式转换: 将数据类型中, 取值范围小的数据, 给取值范围大的类型赋值, 可以直接赋值
  4.     */
  5.     public static void main(String[] args) {
  6.         int a = 10;            // int 4个字节
  7.         double b = a;        // double 8个字节
  8.         System.out.println(b); //10.0
  9.     }
  10. }

02强制转换

大转小
格式:
目标类型 变量名 = (目标类型)待转数据;
注意:
该转换有可能损失精度(丢失数据)

  1. public class Demo2Conversion {
  2.     /*
  3.         强制转换: 把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量
  6.         简答理解: 大的给小的, 不能直接给, 需要强转
  8.         格式：目标数据类型 变量名 = (目标数据类型)值或者变量;
  9.     */
  10.     public static void main(String[] args) {
  11.         int a = 10;                // int 4个字节
  12.         byte b = (byte)a;        // byte 1个字节        错误: 不兼容的类型: 从int转换到byte可能会有损失精度
  13.         System.out.println(b);
  15.         double num1 = 12.9;
  16.         int num2 = (int)num1;
  17.         System.out.println(num2);
  18.     }
  20. }

03类型转换案例

  1. public class Demo3Conversion {
  2.     /*
  3.         请找出下列代码的错误, 指出原因并解决.
  4.     */
  5.     public static void main(String[] args) {
  6.         byte a = 3;
  7.         byte b = 4;
  8.         /*
  9.             前置知识点铺垫:
  12.                 隐式转换: 当小的数据类型和大的数据类型在一起运算的时候, 小的会先提升为大的之后, 再进行运算
  13.                             特殊关注: byte short char 在运算的时候, 都会直接提升为int, 然后再进行运算.
  15.             错误原因:
  16.                 byte c = a + b;
  18.                 这里的a和b是两个byte类型, 它们在运算之前会将自己提升为int类型, 然后再进行运算
  19.                 两个int相加, 结果还是int, 想要把一个int类型的结果, 赋值给byte类型的变量
  21.                         大的给小的, 不能直接给.
  23.                         非要给的话, 就需要强制类型转换.
  24.             解决方案:
  26.                 首先让a和b进行相加, 使用()提升算数优先级
  28.                 再对相加的结果整体进行强转.
  30.         */
  31.         byte c = (byte)(a + b);        // 错误: 不兼容的类型: 从int转换到byte可能会有损失
  32.         System.out.println(c);
  33.     }
  35. }
  1. /*
  2.         请找出下列代码的错误, 指出原因并解决.
  5.         担心的问题:
  7.             3 和 4 是两个常量, 整数常量默认的数据类型是int
  8.             这里两个int相加, 结果还是int, int给byte赋值.
  9.             emmm... 应该需要强转吧
  11.         Java存在常量优化机制:
  13.             byte d = 3 + 4;
  15.             这里的3和4是两个常量, Java存在常量优化机制, 会在编译的时候就会让3和4进行相加, 然后会自动判断7是否在byte的取值范围内
  17.                     不在范围内: 编译出错
  19.                     在范围内: 通过编译
  20.     */
  21.     public static void main(String[] args) {
  22.         byte d = 3 + 4;
  23.         System.out.println(d);
  25.         long num = 123456789123456789L;
  26.     }
  28. }

04算数运算符

  1. public class Demo1Operator {
  2.     /*
  3.         运算符:
  5.             对[常量]或[变量]进行操作的符号
  7.         算数运算符
  9.             + - * : 跟小学数学的运算方式一样
  11.             / : 整数相除,结果只能得到整数,如果想要得到带有小数的结果,必须加入小数(浮点类型)的运算
  13.             %(取模) : 取余数
  14.     */
  15.     public static void main(String[] args){
  16.         System.out.println(10 + 20);
  17.         System.out.println(10 - 20);
  18.         System.out.println(10 * 20);
  20.         System.out.println("-----------------------");
  22.         /*
  23.             / : 整数相除,结果只能得到整数,如果想要得到带有小数的结果,必须加入小数(浮点类型)的运算
  24.         */
  25.         System.out.println(10 / 2);        // 5
  26.         System.out.println(10 / 3);        // 3
  27.         System.out.println(10 / 3.0);        // 3.3333333333333335
  28.         System.out.println(10.0 / 3);        // 3.3333333333333335
  30.         System.out.println("-----------------------");
  32.         /*
  33.             %(取模) : 取余数
  34.         */
  36.         System.out.println(5 % 2);        // 5 / 2 = 商2, 余数为1
  37.     }
  38. }

05字符的+操作

image.png

06字符串的+操作

  1. public class Demo2Operator {
  2.     /*
  3.         字符串的 + 操作
  6.             当 + 操作中出现字符串时，这个 + 是[字符串连接符]，而不是算术运算。
  8.     */
  9.     public static void main(String[] args) {
  10.         // 字符串可以使用 +号, 跟[任意数据类型]拼接
  11.         System.out.println("itheima" + 666);
  12.         System.out.println("itheima" + true);
  14.         System.out.println(1 + 99 + "年黑马");
  15.         System.out.println("5+5="+5+5);                // 5+5=55
  16.         System.out.println("5+5="+(5+5));            // 5+5=10
  17.     }
  19. }

07案例_数值拆分

  1. import java.util.Scanner;
  3. public class Test {
  6.     /*
  7.         需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
  9.         运行结果:
  10.             请输入一个三位数:
  11.             123
  12.             整数123个位为:3
  13.             整数123十位为:2
  14.             整数123百位为:1
  16.         分析：
  17.             1：使用Scanner键盘录入一个三位数
  18.             2：个位的计算：数值 % 10
  19.             3：十位的计算：数值 / 10 % 10
  20.             4：百位的计算：数值 / 100
  21.             5：将个位, 十位, 百位拼接上正确的字符串, 打印即可
  23.     */
  24.     public static void main(String[] args) {
  25.         // 1：使用Scanner键盘录入一个三位数
  26.         Scanner sc = new Scanner(System.in);
  27.         System.out.println("请输入一个三位数");
  28.         int num = sc.nextInt();
  29.         // 2：个位的计算：数值 % 10
  30.         int ge = num % 10;                        // 123 % 10 = 3
  31.         // 3：十位的计算：数值 / 10 % 10
  32.         int shi = num / 10 % 10;                // 123 / 10 = 12        12 % 10 = 2
  33.         // 4：百位的计算：数值 / 100
  34.         int bai = num / 100;                    // 123 / 100 = 1
  35.         // 5：将个位, 十位, 百位拼接上正确的字符串, 打印即可
  36.         System.out.println("整数"+num+"个位为:" + ge);
  37.         System.out.println("整数"+num+"十位为:" + shi);
  38.         System.out.println("整数"+num+"百位为:" + bai);
  40.     }
  42. }

08自增自减运算符

  1. public class Demo3Operator {
  2.     /*
  3.         自增自减运算符 :
  6.             ++ : 变量自身+1
  7.             -- : 变量自身-1
  9.             ++ 和-- 既可以放在变量的后边，也可以放在变量的前边。
  11.         注意:
  13.             单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的
  14.     */
  15.     public static void main(String[] args){
  16.         int a = 10;
  17.         ++a;                        // a = a + 1;
  18.         System.out.println(a);        // 11
  20.         int b = 10;
  21.         --b;
  22.         System.out.println(b);        // 9
  23.     }
  25. }
  1. public class Demo4Operator {
  2.     /*
  3.         参与操作:
  6.             ++在前: 先对该变量做自增(++)或者自减(--)，然后再拿变量参与操作。
  8.             ++在后:    先将该变量原本的值，取出来参与操作，随后再进行自增(++)，自减(--)。
  9.     */
  10.     public static void main(String[] args){
  11.         // ++在前: 先对该变量做自增(++)或者自减(--)，然后再拿变量参与操作。
  12.         int a = 10;
  13.         int b = ++a;
  15.         System.out.println(a);        // 11
  16.         System.out.println(b);        // 11
  21.         // ++在后:    先将该变量原本的值，取出来参与操作，随后再进行自增(++)，自减(--)。
  22.         int aa = 10;
  23.                 //bb = 10
  24.         int bb = aa++;    // aa = 11
  26.         System.out.println(aa);    // 11
  27.         System.out.println(bb); // 10
  29.         int num = 123;
  30.         System.out.println(num++);    // 123
  31.         System.out.println(num);    // 124    
  33.         System.out.println(10++);    // a++;  a = a + 1;
  34.                                     // 10++; 10 = 10 + 1;
  35.     }
  37. }

09赋值运算符

image.png

  1. public class Demo1Operator {
  2.     /*
  4.         基本赋值运算符:
  6.             = : 将符号右侧的数据, 赋值给左边
  8.         扩展赋值运算符:
  10.             +=  -=  *=  /=  %=
  12.             += : 将符号左右两边的数据, 做加法运算, 结果赋值给左边
  14.     */
  15.     public static void main(String[] args) {
  16.         int a = 10;
  17.         // += : 将符号左右两边的数据, 做加法运算, 结果赋值给左边
  18.         a += 20;
  19.         System.out.println(a);
  20.     }
  21. }
  1. public class Demo2Operator {
  2.     /*
  3.         阅读下列代码, 查看是否存在问题, 如果有请指出并修正
  4.     */
  5.     public static void main(String[] args) {
  6.         short s = 1;
  7.         // s是short类型, 1默认是int类型
  8.         // short和int相加, short会先提升为int, 然后再进行运算
  9.         // 提升之后, 就是两int相加, 两个int相加, 结果还是int, 将int赋值给short
  10.         // 需要加入强转.
  11.         // s = s + 1;        //  错误: 不兼容的类型: 从int转换到short可能会有损失
  12.         s = (short)(s + 1);        
  13.         System.out.println(s);
  16.         short ss = 1;
  17.         ss += 1;        // ss = (short)(ss + 1);
  18.                         // 注意: 扩展赋值运算符底层会自带强转功能
  19.         System.out.println(ss);
  21.     }
  23. }

10关系运算符

image.png

  1. public class Demo1Operator {
  2.     /*
  3.         关系运算符(比较运算符) :
  5.             (>)    (>=) (<) (<=) (==) (!=)
  7.     */
  8.     public static void main(String[] args){
  9.         System.out.println(10 > 20);    // false
  10.         System.out.println(10 >= 20);    // false
  11.         System.out.println(10 < 20);    // true
  12.         System.out.println(10 <= 20);    // true
  13.         System.out.println(10 == 20);    // false
  14.         System.out.println(10 != 20);    // true
  15.     }
  16. }

11逻辑运算符

image.png
image.png

  1. public class Demo1Operator {
  2.     /*
  3.         逻辑运算符作用: 用于[整合]多个比较表达式的条件
  6.             1. 连接多个比较表达式
  7.             2. 连接true或false
  9.         最终得到的结果都是boolean类型的true或false.
  11.         应用场景:
  13.                 需求: 键盘录入学生成绩, 如果是90-100之间, 程序输出[优秀]
  15.                         判断条件(score >= 90 & score <= 100)
  17.                 需求: 键盘录入工人工号, 只要3号或者5号或者7号.
  19.                         判断条件(id  3 | id  5 | id == 7)
  21.     */
  22.     public static void main(String[] args){
  23.         int x = 10;
  24.                         // true & true
  25.                         // x > 5 并且 x < 15
  26.         System.out.println(x > 5 & x < 15);    // true
  27.     }
  29. }
  1. public class Demo2Operator {
  2.     /*
  3.         逻辑运算符分类 :
  6.             &(与) : 并且, 遇false则false, 只有符号左右两边同时为true, 结果才为true.
  8.             |(或) : 或者, 遇true则true, 只有符号左边两边同时为false, 结果才为false
  10.             !(非) : 取反
  12.             ^(异或) : 相同为false, 不同为true.
  14.     */
  15.     public static void main(String[] args){
  16.         // &(与) : 并且
  17.         System.out.println(true & true);        // true
  18.         System.out.println(false & false);        // false
  19.         System.out.println(true & false);        // false
  20.         System.out.println(false & true);        // false
  21.         System.out.println("------------------");
  22.         // |(或) : 或者
  23.         System.out.println(true | true);        // true
  24.         System.out.println(false | false);        // false
  25.         System.out.println(true | false);        // true
  26.         System.out.println(false | true);        // true
  27.         System.out.println("------------------");
  28.         // !(非) : 取反
  29.         System.out.println(!true);                // false
  30.         System.out.println(!!true);                // true
  31.         System.out.println("------------------");
  32.         // ^(异或) :
  33.         System.out.println(true ^ true);        // false
  34.         System.out.println(false ^ false);        // false
  35.         System.out.println(true ^ false);        // true
  36.         System.out.println(false ^ true);        // true
  37.     }
  39. }

12短路逻辑运算符

image.png

  1. public class Demo3Operator {
  2.     /*
  3.         & 和 && 的区别 :
  6.             & : 无论符号左边是true还是false, 右边都要继续执行
  8.             && : 具有短路效果, 符号左边为false的时候, 右边就不执行了.
  9.                     如果符号左边为true, 右边要继续执行.
  10.     */
  11.     public static void main(String[] args ){
  12.         int x = 3;
  13.         int y = 4;
  14.         // false & true
  15.         System.out.println(++x > 4 && y-- < 5);    // false
  16.         System.out.println("x=" + x);    // 4
  17.         System.out.println("y=" + y);    // 4
  18.     }
  20. }

13三元运算符

  1. public class Demo1Operator {
  2.     /*
  3.         三元运算符:
  6.             格式: 关系表达式 ? 表达式1 : 表达式2;
  8.         执行流程：
  9.                 首先计算关系表达式的值
  10.                 如果值为true，取表达式1的值
  11.                 如果值为false，取表达式2的值
  16.         需求: 求两个变量的最大值
  18.     */
  19.     public static void main(String[] args){
  20.         int a = 10;
  21.         int b = 20;
  22.         int min = a > b ? b : a;
  23.         System.out.println(min);
  24.     }
  26. }

14案例三个和尚

  1. public class Test {
  2.     /*
  4.           1. 定义三个变量用于保存和尚的身高
  5.             2. 用三元运算符 , 比较前两个变量，获取较大值。
  6.             3. 用三元运算符 , 让较大值和第三个变量比较，获取最大值。
  7.             4. 输出结果
  9.     */
  10.     public static void main(String[] args) {
  11.         // 1. 定义三个变量用于保存和尚的身高
  12.         int a = 150;
  13.         int b = 210;
  14.         int c = 165;
  16.         // 2. 用三元运算符 , 比较前两个变量，获取较大值。
  17.         int tempMax = a > b ? a : b;
  19.         // 3. 用三元运算符 , 让较大值和第三个变量比较，获取最大值。
  20.         int max = tempMax > c ? tempMax : c;
  22.         // 4. 输出结果
  23.         System.out.println(max);
  25.         int result = a > b ? a : b > c ? a > b ? a : b : c;
  27.         System.out.println(result);
  28.     }
  30. }

15流程控制语句-顺序结构

一些语句来控制程序的执行流程,分为顺序,分支(if,switch),循环(fow,while,do…while)
顺序结构语句是Java默认的执行流程,从上到下,从左到右

  1. public class Demo1 {
  2.     public static void main(String[] args) {
  3.         System.out.println(1);
  4.         System.out.println(2);
  5.         System.out.println(3);
  6.         System.out.println(4);
  7.         System.out.println(5);
  8.     }
  9. }

16if语句格式1

  1. public class Demo1If {
  2.     /*
  3.         格式：
  4.             if (关系表达式) {
  5.                 语句体;    
  6.             }
  9.         执行流程：
  11.             首先计算关系表达式的值
  12.             如果关系表达式的值为true就执行语句体
  13.             如果关系表达式的值为false就不执行语句体
  14.             继续执行后面的语句内容
  16.         注意事项:
  18.             1. 如果if语句所控制的语句体, 是一条语句, 大括可以省略不写
  19.                 但是不建议!
  21.             2. if语句的小括后面, 不要写分号
  23.     */
  24.     public static void main(String[] args) {
  25.         System.out.println("开始");
  27.         // 如果年龄大于18岁, 就可以上网吧
  28.         int age = 17;
  30.         if(age >= 18){
  31.             // int a = 10;
  32.             System.out.println("可以上网吧");
  33.         }
  35.         System.out.println("结束");
  36.     }
  38. }

17if语句格式2

  1. public class Demo2If {
  2.     /*
  3.         格式：
  4.             if (关系表达式) {
  5.                 语句体1;    
  6.             } else {
  7.                 语句体2;    
  8.             }
  11.         执行流程：
  13.             首先计算关系表达式的值
  14.             如果关系表达式的值为true就执行语句体1
  15.             如果关系表达式的值为false就执行语句体2
  16.             继续执行后面的语句内容
  18.     */
  19.     public static void main(String[] args) {
  20.         // 程序判断一个数, 是奇数还是偶数
  21.         int num = 9;
  23.         if(num % 2 == 0){
  24.             System.out.println("偶数");
  25.         }else{
  26.             System.out.println("奇数");
  27.         }
  28.     }
  30. }

18if语句格式3

  1. public class Demo3If {
  2.     /*
  3.         格式：
  4.             if (判断条件1) {
  5.                 语句体1;    
  6.             } else if (判断条件2) {
  7.                 语句体2;    
  8.             } 
  9.             …
  10.             else {
  11.                 语句体n+1;
  12.             }
  15.         执行流程：
  16.             首先计算判断条件1的值
  17.             如果值为true就执行语句体1；如果值为false就计算判断条件2的值
  18.             如果值为true就执行语句体2；如果值为false就计算判断条件3的值
  19.             …
  20.             如果没有任何判断条件为true，就执行语句体n+1。
  22.         需求:
  23.             根据学生成绩, 程序给出对应评价
  25.             90~100
  26.                 优秀
  27.             80~89
  28.                 良好
  29.             70~79
  30.                 中等
  31.             60~69
  32.                 及格
  33.             0~59
  34.                 请努力加油!
  36.     */
  37.     public static void main(String[] args){
  38.         int score = -1;
  40.         if(score >= 90 && score <= 100){
  41.             System.out.println("优秀");
  42.         }else if (score >= 80 && score <= 89){
  43.             System.out.println("良好");
  44.         }else if (score >= 70 && score <= 79){
  45.             System.out.println("中等");
  46.         }else if (score >= 60 && score <= 69){
  47.             System.out.println("及格");
  48.         }else if (score >= 0 && score <= 59){
  49.             System.out.println("请努力加油");
  50.         }else{
  51.             System.out.println("成绩有误!");
  52.         }
  53.     }
  55. }

19案例_考勤奖励

  1. import java.util.Scanner;
  3. public class Test {
  4.     /*
  5.         需求：键盘录入学生考试成绩, 根据成绩程序给出不同的奖励。
  8.             95~100分 : 自行车一辆
  9.             90~94分  : 游乐场一次
  10.             80~89分     : 变形金刚一个
  11.             80分以下 : 挨顿揍, 这座城市又多了一个伤心的人~
  13.         步骤:
  14.                 1. 使用Scanner录入考试成绩
  15.                 2. 判断成绩是否在合法范围内 0~100
  16.                     非法的话, 给出错误提示
  17.                 3. 在合法的语句块中判断成绩范围符合哪一个奖励
  18.                     并给出对应的奖励.
  20.     */
  21.     public static void main(String[] args){
  22.         // 1. 使用Scanner录入考试成绩
  23.         Scanner sc = new Scanner(System.in);
  24.         System.out.println("请输入您的成绩:");
  25.         int score = sc.nextInt();
  26.         // 2. 判断成绩是否在合法范围内 0~100
  27.         if(score >=0 && score <= 100){
  28.             // 合法成绩
  29.             // 3. 在合法的语句块中判断成绩范围符合哪一个奖励
  30.             if(score >= 95 && score <= 100){
  31.                 System.out.println("自行车一辆");
  32.             }else if(score >= 90 && score <= 94){
  33.                 System.out.println("游乐场一次");
  34.             }else if(score >= 80 && score <= 89){
  35.                 System.out.println("变形金刚一个");
  36.             }else {
  37.                 System.out.println("挨顿揍, 这座城市又多了一个伤心的人~");
  38.             }
  39.         }else{
  40.             // 非法的话, 给出错误提示
  41.             System.out.println("您的成绩输入有误!");
  42.         }
  43.     }
  45. }