1.Debug模式

1.1 什么是Debug模式

是供程序员使用的程序调试工具,它可以用于查看程序的执行流程,也可以用于追踪程序执行过程来调试程序。

1.2 Debug介绍与操作流程

  • 如何加断点
    • 选择要设置断点的代码行,在行号的区域后面单击鼠标左键即可
  • 如何运行加了断点的程序
    • 在代码区域右键Debug执行
  • 看哪里
    • 看Debugger窗口
    • 看Console窗口
  • 点哪里
    • 点Step Into (F7)这个箭头,也可以直接按F7
  • 如何删除断点
    • 选择要删除的断点,单击鼠标左键即可
    • 如果是多个断点,可以每一个再点击一次。也可以一次性全部删除

2. 进制的介绍与书写格式

2.1 进制的介绍与书写格式

代码 :

  1. public class Demo1 {
  2. /*
  3. 十进制:Java中,数值默认都是10进制,不需要加任何修饰。
  4. 二进制:数值前面以0b开头,b大小写都可以。
  5. 八进制:数值前面以0开头。
  6. 十六进制:数值前面以0x开头,x大小写都可以。
  7. 注意: 书写的时候, 虽然加入了进制的标识, 但打印在控制台展示的都是十进制数据.
  8. */
  9. public static void main(String[] args) {
  10. System.out.println(10);
  11. System.out.println("二进制数据0b10的十进制表示为:" + 0b10);
  12. System.out.println("八进制数据010的十进制表示为:" + 010);
  13. System.out.println("十六进制数据0x10的十进制表示为:" + 0x10);
  14. }
  15. }

2.2 任意进制到十进制的转换1590937009286.png

1590937024104.png

2.3 进制转换-十进制到任意进制转换

  1. **2.3.1 : 十进制到二进制的转换**
  2. 公式:除基取余使用源数据,不断的除以基数(几进制,基数就是几)得到余数,直到商为0,再将余数倒着拼起来即可。
  3. 需求:将十进制数字11,转换为2进制。
  4. 实现方式:源数据为11,使用11不断的除以基数,也就是2,直到商为0

1590936221838.png

  1. **2.3.2 : 十进制到十六进制的转换**
  2. 公式:除基取余使用源数据,不断的除以基数(几进制,基数就是几)得到余数,直到商为0,再将余数倒着拼起来即可。
  3. 需求:将十进制数字60,转换为16进制。
  4. 实现方式:源数据为60,使用60不断的除以基数,也就是16,直到商为0

1590936342865.png

  1. 结论:十进制到任意进制的转换
  2. 公式:除基取余使用源数据,不断的除以基数(几进制,基数就是几)得到余数,直到商为0,再将余数倒着 拼起来即可

2.4 快速进制转换法

  1. 8421码:
  2. 8421码又称BCD码,是BCD代码中最常用的一种BCD (Binary-Coded Decimal‎) 二进制码十进制数在这种编码方式中,每一位二进制值的1都是代表一个固定数值,把每一位的1代表的十进制数加起来得到的结果就是它所代表的十进制数。

1590936493344.png

1590936529957.png

1590936548060.png

2.5 原码反码补码

前言 : 计算机中的数据,都是以二进制补码的形式在运算,而补码则是通过反码和原码推算出来的

原码 :(可直观看出数据大小)

就是二进制定点表示法,即最高位为符号位,【0】表示正,【1】表示负,其余位表示数值的大小。

通过一个字节表示+7和-7,代码:byte b1 = 7; byte b2 = -7;一个字节等于8个比特位,也就是8个二进制位

0(符号位) 0000111

1(符号位) 0000111

反码 : 正数的反码与其原码相同;负数的反码是对其原码逐位取反,但符号位除外。

补码 : (数据以该状态进行运算)正数的补码与其原码相同;负数的补码是在其反码的末位加1。

1590936726746.png
1590936745245.png

2.6 位运算-基本位运算符

  1. package com.itheima.demo;
  2. public class Demo2 {
  3. /*
  4. 位运算:
  5. 位运算符指的是二进制位的运算,先将十进制数转成二进制后再进行运算。
  6. 在二进制位运算中,1表示true,0表示false。
  7. & 位与 : 遇false则false, 遇0则0
  8. 00000000 00000000 00000000 00000110 // 6的二进制
  9. & 00000000 00000000 00000000 00000010 // 2的二进制
  10. -----------------------------------------
  11. 00000000 00000000 00000000 00000010 // 结果: 2
  12. | 位或 : 遇true则true, 遇1则1
  13. ^ 位异或 : 相同为false, 不同为true
  14. ~ 取反 : 全部取反, 0变1, 1变0 (也包括符号位)
  15. 00000000 00000000 00000000 00000110 // 6的二进制补码
  16. ~ 11111111 11111111 11111111 11111001
  17. - 1 // -1求反码
  18. ------------------------------------
  19. 11111111 11111111 11111111 11111000 // 反码推原码
  20. 10000000 00000000 00000000 00000111 // -7
  21. */
  22. public static void main(String[] args) {
  23. System.out.println(6 & 2);
  24. System.out.println(~6);
  25. }
  26. }

2.7 位运算-位移运算符

位运算概述 : 位运算符指的是二进制位的运算,先将十进制数转成二进制后再进行运算。在二进制位运算中,1表示true,0表示false。

位运算符介绍 : 1590937235620.png

代码 :

  1. package com.itheima.demo;
  2. public class Demo3 {
  3. /*
  4. 位移运算符:
  5. << 有符号左移运算,二进制位向左移动, 左边符号位丢弃, 右边补齐0
  6. 运算规律: 向左移动几位, 就是乘以2的几次幂
  7. 12 << 2
  8. (0)0000000 00000000 00000000 000011000 // 12的二进制
  9. -----------------------------------------------------------------------------
  10. >> 有符号右移运算,二进制位向右移动, 使用符号位进行补位
  11. 运算规律: 向右移动几位, 就是除以2的几次幂
  12. 000000000 00000000 00000000 0000001(1) // 3的二进制
  13. -----------------------------------------------------------------------------
  14. >>> 无符号右移运算符, 无论符号位是0还是1,都补0
  15. 010000000 00000000 00000000 00000110 // -6的二进制
  16. */
  17. public static void main(String[] args) {
  18. System.out.println(12 << 1); // 24
  19. System.out.println(12 << 2); // 48
  20. }
  21. }
  1. package com.itheima.demo;
  2. public class Demo4 {
  3. /*
  4. ^ 运算符的特点
  5. 一个数, 被另外一个数, 异或两次, 该数本身不变
  6. */
  7. public static void main(String[] args) {
  8. System.out.println(10 ^ 5 ^ 10);
  9. }
  10. }

3.基础练习

3.1 数据交换

案例需求

  1. 已知两个整数变量a = 10b = 20,使用程序实现这两个变量的数据交换<br /> 最终输出a = 20b = 10;

代码实现

  1. package com.itheima.test;
  2. public class Test1 {
  3. /*
  4. 需求:已知两个整数变量a = 10,b = 20,使用程序实现这两个变量的数据交换
  5. 最终输出a = 20,b = 10;
  6. 思路:
  7. 1. 定义一个三方变量temp,将a原本记录的值,交给temp记录 (a的值,不会丢了)
  8. 2. 使用 a 变量记录 b 的值,(第一步交换完毕,b的值也丢不了了)
  9. 3. 使用 b 变量记录 temp的值,也就是a原本的值 (交换完毕)
  10. 4. 输出 a 和 b 变量即可
  11. */
  12. /*
  13. 动态初始化格式:
  14. 数据类型[][] 变量名 = new 数据类型[m][n];
  15. m表示这个二维数组,可以存放多少个一维数组
  16. n表示每一个一维数组,可以存放多少个元素
  17. */
  18. public static void main(String[] args) {
  19. int a = 10;
  20. int b = 20;
  21. // 将a原本记录的值,交给temp记录 (a的值,不会丢了)
  22. int temp = a;
  23. // 用 a 变量记录 b 的值,(第一步交换完毕,b的值也丢不了了)
  24. a = b;
  25. // 使用 b 变量记录 temp的值,也就是a原本的值 (交换完毕)
  26. b = temp;
  27. // 输出 a 和 b 变量即可
  28. System.out.println("a=" + a);
  29. System.out.println("b=" + b);
  30. }
  31. }

3.2 数组反转【应用】

案例需求 :

  1. 已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换,
  2. 交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素

实现步骤 :

  1. 1. 定义两个变量, startend来表示开始和结束的指针.
  1. 确定交换条件, start < end 允许交换
  2. 循环中编写交换逻辑代码
  3. 每一次交换完成, 改变两个指针所指向的索引 start++, end—
  4. 循环结束后, 遍历数组并打印, 查看反转后的数组

代码实现 :

  1. package com.itheima.test;
  2. public class Test2 {
  3. /*
  4. 需求:已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换,
  5. 交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素。
  6. 步骤:
  7. 1. 定义两个变量, start和end来表示开始和结束的指针.
  8. 2. 确定交换条件, start < end 允许交换
  9. 3. 循环中编写交换逻辑代码
  10. 4. 每一次交换完成, 改变两个指针所指向的索引 start++, end--
  11. 5. 循环结束后, 遍历数组并打印, 查看反转后的数组
  12. */
  13. public static void main(String[] args) {
  14. int[] arr = {19, 28, 37, 46, 50};
  15. // 1. 定义两个变量, start和end来表示开始和结束的指针.
  16. int start = 0;
  17. int end = arr.length -1;
  18. // 2. 确定交换条件, start < end 允许交换
  19. // 4. 每一次交换完成, 改变两个指针所指向的索引 start++, end--
  20. // for(int start = 0, end = arr.length -1; start < end; start++, end--)
  21. for( ; start < end; start++, end--){
  22. // 3. 循环中编写交换逻辑代码
  23. int temp = arr[start];
  24. arr[start] = arr[end];
  25. arr[end] = temp;
  26. }
  27. for (int i = 0; i < arr.length; i++) {
  28. System.out.println(arr[i]);
  29. }
  30. }
  31. }

3.3 二维数组概述

  1. **概述 :** 二维数组也是一种容器,不同于一维数组,该容器存储的都是一维数组容器

3.4 二维数组动态初始化

  1. 动态初始化格式:
  2. 数据类型[][] 变量名 = new 数据类型[m][n];
  3. m表示这个二维数组,可以存放多少个一维数组
  4. n表示每一个一维数组,可以存放多少个元素
  1. package com.itheima.demo;
  2. public class Demo1Array {
  3. /*
  4. 动态初始化格式:
  5. 数据类型[][] 变量名 = new 数据类型[m][n];
  6. m表示这个二维数组,可以存放多少个一维数组
  7. n表示每一个一维数组,可以存放多少个元素
  8. */
  9. public static void main(String[] args) {
  10. // 数据类型[][] 变量名 = new 数据类型[m][n];
  11. int[][] arr = new int[3][3];
  12. /*
  13. [[I@10f87f48
  14. @ : 分隔符
  15. 10f87f48 : 十六进制内存地址
  16. I : 数组中存储的数据类型
  17. [[ : 几个中括号就代表的是几维数组
  18. */
  19. System.out.println(arr);
  20. /*
  21. 二维数组存储一维数组的时候, 存储的是一维数组的内存地址
  22. */
  23. System.out.println(arr[0]);
  24. System.out.println(arr[1]);
  25. System.out.println(arr[2]);
  26. System.out.println(arr[0][0]);
  27. System.out.println(arr[1][1]);
  28. System.out.println(arr[2][2]);
  29. // 向二维数组中存储元素
  30. arr[0][0] = 11;
  31. arr[0][1] = 22;
  32. arr[0][2] = 33;
  33. arr[1][0] = 11;
  34. arr[1][1] = 22;
  35. arr[1][2] = 33;
  36. arr[2][0] = 11;
  37. arr[2][1] = 22;
  38. arr[2][2] = 33;
  39. // 从二维数组中取出元素并打印
  40. System.out.println(arr[0][0]);
  41. System.out.println(arr[0][1]);
  42. System.out.println(arr[0][2]);
  43. System.out.println(arr[1][0]);
  44. System.out.println(arr[1][1]);
  45. System.out.println(arr[1][2]);
  46. System.out.println(arr[2][0]);
  47. System.out.println(arr[2][1]);
  48. System.out.println(arr[2][2]);
  49. }
  50. }

3.5 二维数组访问元素的细节问题

问题 : 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ?

答 : 可以的

代码实现

  1. package com.itheima.demo;
  2. public class Demo2Array {
  3. /*
  4. 问题: 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ?
  5. 答 : 可以的
  6. */
  7. public static void main(String[] args) {
  8. int[] arr1 = {11,22,33};
  9. int[] arr2 = {44,55,66};
  10. int[] arr3 = {77,88,99,100};
  11. int[][] arr = new int[3][3];
  12. arr[2][3] = 100;
  13. arr[0] = arr1;
  14. arr[1] = arr2;
  15. arr[2] = arr3;
  16. System.out.println(arr[1][2]);
  17. System.out.println(arr[2][3]);
  18. }
  19. }

3.6 二维数组静态初始化

  1. 完整格式 : 数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , {元素1, 元素2...}
  2. 简化格式 : 数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};

代码实现 :

  1. package com.itheima.demo;
  2. public class Demo3Array {
  3. /*
  4. 完整格式:数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , {元素1, 元素2...} ...};
  5. 简化格式: 数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};
  6. */
  7. public static void main(String[] args) {
  8. int[] arr1 = {11,22,33};
  9. int[] arr2 = {44,55,66};
  10. int[][] arr = {{11,22,33}, {44,55,66}};
  11. System.out.println(arr[0][2]);
  12. int[][] array = {arr1,arr2};
  13. System.out.println(array[0][2]);
  14. }
  15. }

3.7 二维数组遍历

需求 :

  1. 已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}};
  2. 遍历该数组,取出所有元素并打印

步骤 :

  1. 1. 遍历二维数组,取出里面每一个一维数组
  2. 2. 在遍历的过程中,对每一个一维数组继续完成遍历,获取内部存储的每一个元素

代码实现 :

  1. package com.itheima.test;
  2. public class Test1 {
  3. /*
  4. 需求:
  5. 已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}};
  6. 遍历该数组,取出所有元素并打印
  7. 步骤:
  8. 1. 遍历二维数组,取出里面每一个一维数组
  9. 2. 在遍历的过程中,对每一个一维数组继续完成遍历,获取内部存储的每一个元素
  10. */
  11. public static void main(String[] args) {
  12. int[][] arr = {{11, 22, 33}, {33, 44, 55}};
  13. // 1. 遍历二维数组,取出里面每一个一维数组
  14. for (int i = 0; i < arr.length; i++) {
  15. //System.out.println(arr[i]);
  16. // 2. 在遍历的过程中,对每一个一维数组继续完成遍历,获取内部存储的每一个元素
  17. //int[] temp = arr[i];
  18. for (int j = 0; j < arr[i].length; j++) {
  19. System.out.println(arr[i][j]);
  20. }
  21. }
  22. }
  23. }

3.8 二维数组求和

需求 :

  1. 某公司季度和月份统计的数据如下:单位(万元)
  2. 第一季度:22,66,44
  3. 第二季度:77,33,88
  4. 第三季度:25,45,65
  5. 第四季度:11,66,99

步骤 :

  1. 定义求和变量,准备记录最终累加结果
  2. 使用二维数组来存储数据,每个季度是一个一维数组,再将4个一维数组装起来
  3. 遍历二维数组,获取所有元素,累加求和
  4. 输出最终结果

代码实现 :

  1. package com.itheima.test;
  2. public class Test2 {
  3. /*
  4. 需求:
  5. 某公司季度和月份统计的数据如下:单位(万元)
  6. 第一季度:22,66,44
  7. 第二季度:77,33,88
  8. 第三季度:25,45,65
  9. 第四季度:11,66,99
  10. 步骤:
  11. 1. 定义求和变量,准备记录最终累加结果
  12. 2. 使用二维数组来存储数据,每个季度是一个一维数组,再将4个一维数组装起来
  13. 3. 遍历二维数组,获取所有元素,累加求和
  14. 4. 输出最终结果
  15. */
  16. public static void main(String[] args) {
  17. // 1. 定义求和变量,准备记录最终累加结果
  18. int sum = 0;
  19. // 2. 使用二维数组来存储数据,每个季度是一个一维数组,再将4个一维数组装起来
  20. int[][] arr = { {22,66,44} , {77,33,88} , {25,45,65} , {11,66,99}};
  21. // 3. 遍历二维数组,获取所有元素,累加求和
  22. for (int i = 0; i < arr.length; i++) {
  23. for(int j = 0; j < arr[i].length; j++){
  24. sum += arr[i][j];
  25. }
  26. }
  27. // 4. 输出最终结果
  28. System.out.println(sum);
  29. }
  30. }