第六天javaSE基础

Java EE基础班课程（第五天）

学习目标：

• 掌握debug使用
• 了解进制的划分和转换
• 了解二维数组

1.debug使用

  1.打断点
  2.debug运行
  3.一步一步的调试程序，查看数据在代码中运行转化
  4.如果有错误，改好后，继续调试，直到代码完全正确

2.IDEA中debug的使用

Step over (F8)作用:下一步，但是只在本方法中执行，如果被调用方法中有断点，就执行到断点处
Step into (F7)作用:下一步，在本方法中执行代码，如果遇到本方法调用其他方法，就进入被调用的方法
Force step into (Alt+Shift+F7):下一步，在本方法中执行，只要遇到方法的调用，就进入被调用的方法
Step out (Shft+F8):从被调用的方法中出来
Resume program：继续执行代码到下一个断点，如果没有断点就把程序执行到结束
View BreakPoints:断点管理，可以删除一个断点，也可以批量删除，也可以先让当前不用的断点失效
Mute BreakPoints:屏蔽所有断点，让所有断点失效

3.进制

3.1进制的划分

  二进制
  八进制
  十进制
  十六进制 

3.2二进制

介绍：二进制数据是用0和1两个数码来表示。例如：0101000
进位规则是“逢二进一”，借位规则是“借一当二”。

 书写格式：数值前面以0b开头，b大小写都可以。

3.3八进制

八进制介绍：采用0，1，2，3，4，5，6，7八个数字，逢八进1 
  进位规则是“逢八进一”，借位规则是“借一当八”。
书写格式：数值前面以0开头。

3.4十进制

运算规则：逢十进一，借一当十
 Java中，数值默认都是10进制，不需要加任何修饰。
  八进制介绍：采用0，1，2，3，4，5，6，7, 8 ,9 十个数字，逢十进1 

3.5十六进制

用数字0到9和字母A到F（或a~f）表示，其中:A~F表示10~15，这些称作十六进制。
【0】【1】【2】【3】【4】【5】【6】【7】【8】【9】【a】【b】【c】【d】【e】【f】
 运算规则：逢十六进一，借一当十六
书写规则：数值前面以0x开头，x大小写都可以。

3.6注意：以上内容是jdk7版本之后才被支持。

4.进制转换

4.1二进制转十进制

公式：系数 * 基数的权次幂 相加
  
  	系数：每一【位】上的数
	基数：几进制，就是几
	权：从数值的右侧，以0开始，逐个+1增加

4.2十六进制到十进制的转换

公式：系数 * 基数的权次幂 相加
  
  	系数：每一【位】上的数
	基数：几进制，就是几
	权：从数值的右侧，以0开始，逐个+1增加

4.3八进制转十进制

公式：系数 * 基数的权次幂 相加
  
  	系数：每一【位】上的数
	基数：几进制，就是几
	权：从数值的右侧，以0开始，逐个+1增加

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

公式：系数 * 基数的权次幂 相加
系数：每一【位】上的数
基数：几进制，就是几
权：从数值的右侧，以0开始，逐个+1增加

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

公式：除基取余
	使用源数据，不断的除以基数（几进制，基数就是几）得到余数，直到商为0，再将余数倒着拼起来即可。

4.6快速进制转换法

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

4.7 二进制快速互转八进制

八进制：将三个二进制位看为一组，再进行转换
原因：八进制逢八进一，三个二进制位最多可以表示111，也就是数值7，如果出现第四位，就超范围了

规则：
  	如果有个八进制数转二进制 ，就使用三位二进制来替换八进制的一位
  	如果有个二进制数转八进制，就使用一位八进制来替换三位二进制

4.8二进制快速互转十六进制

十六进制：将四个二进制位看为一组，再进行转换
原因：十六进制逢十六进一，四个二进制位最多可以表示1111，也就是数值15，如果出现第五位，就超范围了

5.原码反码和补码

正数的原反补都是相同的
负数的【反码】，是根据【原码】取反(0变1，1变0)得到的 (符号位不变)
负数的【补码】，是根据【反码】的末尾+1，得到的

6.位运算 & | ! ~ ^

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

符号	计算方式
&	遇到0（false）则0（false），两边同时为1（true），结果才是1（true）
|	遇到1（true）则1（true），两边都是0（false），结果才是0（false）
^	相同为false，不同为true
~	取反，二进制位全部取反，0变1，1变0，包括符号位
<<	有符号左移运算，左边符号位丢弃，右边补齐0
>>	有符号右移运算，根据符号位，补齐左边
‘’>>>	无符号右移，无论最符号位是0还是1，都补0

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(5&3);
        System.out.println(5|3);
        System.out.println(~5);
        System.out.println(5^3);

        System.out.println(5<<1);// 5*2^1
        System.out.println(5<<2);// 5*2^2 = 20
        System.out.println(5<<3);
        System.out.println(5<<4);

        System.out.println(5>>1); // 5/2^1
        System.out.println(5>>2); // 5/2^2
        System.out.println(5>>3); // 5/2^3

        System.out.println(5>>>1);
        System.out.println(-5>>>1);
    }
}

6.1异或小练习 一个数，被另外一个数，异或两次，该数本身不变。

需求：已知两个整数变量a = 10，b = 20，使用程序实现这两个变量的数据交换
最终输出a = 20，b = 10;
public class Dmeo02 {
    public static void main(String[] args) {
        
        int a = 10;
        int b = 20;
        int temp = a;
        a = b;
        b= temp;
        System.out.println(a);
        System.out.println(b);
    }
}

//不使用第三方变量实现两个数据的交换 一个数，被另外一个数，异或两次，该数本身不变。
  public class Dmeo02 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        // 一个数，被另外一个数，异或两次，该数本身不变。
        int c = a^b^b;
        System.out.println(c);

        int d = b^a^a;
        System.out.println(d);

        a = a^b;   // a^b = 10^20
        b = a^b;  // a^b^b = 10^20^20 = 10
        a = a^b;  // a^b^b = 10^20^10 = 20
        System.out.println(a);
        System.out.println(b);
    }
}

7.二维数组

7.1二维数组定义格式:

格式1：数据类型 [ ] [ ] 变量名;
范例：int [ ] [ ] arr;

格式2：数据类型 变量名[ ] [ ];
格式3：数据类型[ ] 变量名[ ];
范例：int arr[ ] [ ];
范例：int[ ] arr[ ];

7.2二维数组的动态初始化

格式：数据类型 [ ] [ ] 变量名 = new 数据类型[ m ] [ n ];
  m表示这个二维数组，可以存放多少个一维数组
  n表示每一个一维数组，可以存放多少个元素

范例：int [ ] [ ] arr = new int [ 2 ][ 3 ];

遍历：使用嵌套for循环
  外层for循环可以获取每一个一维数组，内层for循环可以遍历每一个获取的一维数组中的元素

/*
    7.2二维数组动态初始化以及遍历
 */
public class Demo01 {
    public static void main(String[] args) {
        int[] arr = new int[5];
        int i = arr[0];
        System.out.println(i);

        int[] [] brr = new int[3][5];
        //{{0,0,0,0,0},{0,0,0,0,0},{0,0,0,0,0}}
        //brr[0][0]
       int x  = brr[0][2];
        System.out.println(x);
        System.out.println(brr[0]);
        System.out.println(brr[1]);
        System.out.println(brr[2]);

        for (int j = 0; j < brr.length; j++) {
//            System.out.println(brr[j]);
            int[] crr = brr[j];
            for (int z = 0; z < crr.length; z++) {
                System.out.println(crr[z]);
            }
        }

    }
}

7.3二维数组的赋值

格式：
  	数组名[索引1][索引2] = 新值;
	索引1：是指二维数组中每一个一维数组的在二维数组中的位置
     索引2：每个一维数组中索引
举栗子：
public class Demo01 {
    public static void main(String[] args) {
    
        int[] [] brr = new int[3][5];
        //对二维数组brr的第二个一维数组中的第二个元素赋值
        brr[1][1] = 10;
        //遍历数组
        for (int j = 0; j < brr.length; j++) {
//            System.out.println(brr[j]);
            int[] crr = brr[j];
            for (int z = 0; z < crr.length; z++) {
                System.out.println(crr[z]);
            }
        }

    }
}

7.4二维数组的静态初始化

格式：数据类型 [ ] [ ] 变量名 = new 数据类型[ ] [ ] {  {元素1,元素2},  {元素1, 元素2} };
范例：int [ ] [ ] arr = new int [ ][ ] { {11,22} , {33,44} };

简化格式：数据类型 [ ] [ ] 变量名 = {  {元素1,元素2},  {元素1, 元素2} };  //推荐使用
范例：int [ ] [ ] arr = { {11,22} , {33,44} };

7.5二维数组遍历

/*
    已知一个二维数组 arr = {  {11 , 22 , 33} , {33 , 44 , 55} };  遍历该数组，取出所有元素并打印
 */
public class Demo02 {
    public static void main(String[] args) {
        int[][] arr = {  {11 , 22 , 33} , {33 , 44 , 55} };
        //1.使用for循环拿到每一个一维数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
            //遍历一维数组，获取一维数组中每一个元素
//            int[] brr = arr[i];
//            for (int j = 0; j < brr.length; j++) {
//                System.out.println(brr[j]);
//            }
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
    }
}

7.6公司年销售额求和

/*
    某公司季度和月份统计的数据如下：单位(万元)
	第一季度：22,66,44
	第二季度：77,33,88
	第三季度：25,45,65
	第四季度：11,66,99
 */
public class Demo03 {
    public static void main(String[] args) {
        int[] spring = {22, 66, 44};
        int[] summer = {77, 33, 88};
        int[] autumn = {25, 45, 65};
        int[] winter = {11, 66, 99};

        int[][] year = {spring, summer, autumn, winter};

        int[][] totalSale = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99}};

        //定义求和变量
        int sum = 0;
        //遍历二维数组，拿到每一个一维数组
        /*for (int i = 0; i < year.length; i++) {
            //遍历每一个以为数组
            int[] season = year[i];
            for (int j = 0; j < season.length; j++) {
                sum+=season[j];
            }
        }*/
        for (int i = 0; i < year.length; i++) {
            //遍历每一个以为数组
            for (int j = 0; j < year[i].length; j++) {
                sum+=year[i][j];
            }
        }
        System.out.println("年销售额："+sum+"万元");
    }
}

7.7公司年销售额中月销售额最高是多少

public class Demo06 {
    public static void main(String[] args) {
        int[][]  totalSale = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
        int sum = 0;
        int Max = totalSale[0][0];
        for (int i = 0; i < totalSale.length; i++) {
            for (int j = 0; j < totalSale[i].length; j++) {
                sum += totalSale[i][j];
                if (totalSale[i][j]>Max){
                    Max = totalSale[i][j];
                }
            }
        }
        System.out.println("今年的总收入为"+sum+"万");
        System.out.println("今年的最高销售额为:"+Max+"万");
    }
}