01debug介绍与操作流程

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

01debug查看循环求偶数和

image.png

02debug查看方法参数传递

image.png

03进制的介绍与书写格式

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

04任意进制到十进制的转换

05进制转换-十进制到任意进制的转换

06快速进制转换法

07原码反码补码

08位运算-基本位运算符

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

09位运算-位移运算符

  1. package com.itheima.demo;
  3. public class Demo3 {
  4.     /*
  5.        位移运算符:
  7.                << 有符号左移运算，二进制位向左移动, 左边符号位丢弃, 右边补齐0
  8.                         运算规律: 向左移动几位, 就是乘以2的几次幂
  10.                                 12 << 2
  12.                                 (0)0000000 00000000 00000000 000011000  // 12的二进制
  14.        -----------------------------------------------------------------------------
  15.                >> 有符号右移运算，二进制位向右移动, 使用符号位进行补位
  16.                         运算规律: 向右移动几位, 就是除以2的几次幂
  18.                                 000000000 00000000 00000000 0000001(1)  // 3的二进制
  20.        -----------------------------------------------------------------------------
  22.                 >>> 无符号右移运算符,  无论符号位是0还是1，都补0
  24.                                 010000000 00000000 00000000 00000110  // -6的二进制
  26.      */
  27.     public static void main(String[] args) {
  28.         System.out.println(12 << 1);  // 24
  29.         System.out.println(12 << 2);  // 48
  31.     }
  33. }

10数据交换

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

11数组反转

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

12二维数组概述

13二维数组动态初始化

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

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

15二维数组静态初始化

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

16二维数组遍历

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

17二维数组求和

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