Java se学习笔记-基础-基于尚硅谷宋红康教程

java se基础

基本语法

关键字和标识符

1. 关键字[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WGbXTu4y-1597572422033)(https://i.loli.net/2020/08/16/LEO3WFeJb98D5f2.png)]

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SGz1VaRB-1597572422036)(https://i.loli.net/2020/08/16/YNrlqiPhsAGkOun.png)]

2. 保留字：现Java版本尚未使用，但以后版本可能会作为关键字使用。
   具体哪些保留字：goto 、const
   注意：自己命名标识符时要避免使用这些保留字

3. 标识符定义规范

变量的使用

• 数据类型
  1. 整型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
     1. byte范围：-128 ~ 127
     2. 声明long型变量，必须以"l"或"L"结尾
     3. 通常，定义整型变量时，使用int型。
     4. 整型的常量，默认类型是：int型
  2. 浮点型：float(4字节) \ double(8字节)
     1. 浮点型，表示带小数点的数值
     2. float表示数值的范围比long还大
     3. 定义float类型变量时，变量要以"f"或"F"结尾
     4. 通常，定义浮点型变量时，使用double型
     5. 浮点型的常量，默认类型为：double
  3. 字符型：char(1字符=2字节)
     1. 定义char型变量，通常使用一对''，内部只能写一个字符
     2. 表示方式：1.声明一个字符2.转义字符3.直接使用Unicode 值来表示字符型常量
  4. 布尔型：boolean
     1. 只能取两个值之一：true 、 false
     2. 常常在条件判断、循环结构中使用
  5. 按声明的位置分类（了解）
• 变量使用注意点
  1. 变量必须先声明，后使用
  2. 变量都定义在其作用域内。在作用域内，它是有效的。出了作用域，就失效了
  3. 同一个作用域内，不可以声明两个同名的变量
• 自动类型转换(只涉及7种基本数据类型）
  1. byte 、char 、short --> int --> long --> float --> double
  2. 当byte、char、short三种类型的变量做运算时，结果只为int型
  3. 结论:当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
  4. 说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
• 强制类型转换(只涉及7种基本数据类型）：自动类型提升运算的逆运算。
  1. 需要使用强转符：()
  2. 强制类型转换，可能导致精度损失。
• String与8种基本数据类型间的运算
  1. .String属于引用数据类型
  2. 声明String类型变量时，使用一对""
  3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
  4. 运算的结果仍然是String类型

运算符

1. 算术运算符： + - + - * / % (前)++ (后)++ (前)-- (后)-- +

   说明:

   1. (前)++ :先自增1，后运算
   2. (后)++ :先运算，后自增1
   3. (前)-- :先自减1，后运算
   4. (后)-- :先运算，后自减1
   5. 连接符：+：只能使用在String与其他数据类型变量之间使用。

2. 赋值运算符：= += -= *= /= %=

   说明:

   1. 运算的结果不会改变变量本身的数据类型

3. 比较运算符（关系运算符）: == != > < >= <= instanceof

   说明:

   1. 比较运算符的结果是boolean类型
   2. < >= <= :只能使用在数值类型的数据之间。
   3. == 和 !=: 不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间。

4. 逻辑运算符：& && | || ! ^

   说明:

   1. 相同点1：& 与 && 的运算结果相同
   2. 相同点2：当符号左边是true时，二者都会执行符号右边的运算
   3. 不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
   4. | ||同理
   5. 即,是否继续执行右边运算的区别
   6. 开发中推荐使用短路运算符&& ||

5. 位运算符：<< >> >>> & | ^ ~

   说明:

   1. 位运算符操作的都是整型的数据
   2. << :在一定范围内，每向左移1位，相当于 * 2
   3. >> :在一定范围内，每向右移1位，相当于 / 2
   4. 在二进制层面进行数据操作

6. 三元运算符：(条件表达式)? 表达式1 : 表达式2

   说明:

   1. 三元运算符可以嵌套使用
   2. 表达式1 和表达式2要求是一致的。
   3. 必须接收一个返回结果

流程控制

• 分支结构

  1. if-else if - else

     if (a>6) //关系表达式，当 a>6 时表达式值为真，执行if体
         Statement(s);
     if (a||b) //逻辑表达式，只要a、b中有一个为真，结果为真，执行if体
         Statement(s);
     if (3-6) //算术表达式，只要该表达式的值非0，结果为真，执行if体
         Statement(s);
     /*关系、逻辑混合表达式，只要age>=60或age<=10其中一项为真，结果为真，执行if体*/
     if (age>=60 ||age<=10)
         Statement(s);
     

     if (条件表达式1)
         语句1;
     else if (条件表达式2)、
         语句2;
     ...
     else if (条件表达式n)
         语句n;
     else
         语句n+1;
     

  2. switch-case

     //匹配 就是全等。
     
     语法：
        switch(表达式){
              
          case 值1:
            表达式的值和 值1匹配上了，需要执行的代码;
            break;
          case 值2:
            表达式的值和 值2匹配上了，需要执行的代码;
            break;
          case 值3:
            表达式的值和 值3匹配上了，需要执行的代码;
          	break;
          default:
            如果表达式的值和以上的case后面的值都没有匹配上，那么就执行这里的代码。
            break;
        }
     
     //不写break会穿透到下一个break
     

     注意switch()表达式里面只能匹配常量

• 循环结构

  1. for

     for(条件表达式1;条件表达式2;条件表达式3){
              
         
     	语句块;
         
     }
     

  2. while

     while(循环条件){
              
     
     　　语句块;
     
     }
     

     注意:语句块要有使得循环条件不成立的语句,否则回陷入死循环

  3. do-while

     do{
              
     
     	语句块;
     	
     }while(循环条件)
     

     注意:语句块要有使得循环条件不成立的语句,否则回陷入死循环

  4. 关键字 break / continue

     1. break:结束当前循环
     2. continue:跳过当前循环

数组

• 一维数组

  1. 声明和初始化

     		int num;//声明
     		num = 10;//初始化
     		int id = 1001;//声明 + 初始化
     		
     		int[] ids;//声明
     		//1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
     		ids = new int[]{
              1001,1002,1003,1004};
     		//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
     		String[] names = new String[5];
     
     	int[] arr4 = {
              1,2,3,4,5};//类型推断
     

  2. 一维数组元素的引用：通过角标的方式调用。

     //数组的角标（或索引从0开始的，到数组的长度-1结束。
     		names[0] = "王铭";
     		names[1] = "王赫";
     

  3. 数组的属性：length

     数组的长度,如int[] num == new int[2]

     int[] num == new int[2]
     System.out.println(num.length);//2
     
     //此时打印出2
     

  4. 遍历一维数组元素

     for(int i = 0;i < names.length;i++){
              
     	System.out.println(names[i]);
     }
     

  5. 一维数组元素的默认初始化值

     1. 数组元素是整型：0
     2. 数组元素是浮点型：0.0
     3. 数组元素是char型：0或’\u0000’，而非’0’
     4. 数组元素是boolean型：false
     5. 数组元素是引用数据类型：null

  6. 一维数组的内存解析[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NV2yeuuA-1597572422047)(https://i.loli.net/2020/08/16/Mwa5rdbtncL3VSe.png)]

• 二维数组

  数组属于引用数据类型,数组的元素也可以是引用数据类型,一个一维数组A的元素如果还是一个一维数组类型的，则，此数组A称为二维数组。即,二维数组的本质其实是一维数组的元素依然是一维数组

  1. 二维数组的声明与初始化

     	int[] arr = new int[]{
              1,2,3};//一维数组
     		//静态初始化
     		int[][] arr1 = new int[][]{
              {
              1,2,3},{
              4,5},{
              6,7,8}};
     		//动态初始化1
     		String[][] arr2 = new String[3][2];
     		//动态初始化2
     		String[][] arr3 = new String[3][];
     	//也是正确的写法：
     		int[] arr4[] = new int[][]{
              {
              1,2,3},{
              4,5,9,10},{
              6,7,8}};
     		int[] arr5[] = {
              {
              1,2,3},{
              4,5},{
              6,7,8}};//类型推断
     

  2. 遍历二维数组元素

     for(int i = 0;i < arr4.length;i++){
              
     			
     			for(int j = 0;j < arr4[i].length;j++){
              
     				System.out.print(arr4[i][j] + "  ");
     			}
     			System.out.println();
     	}
     

  3. 二维数组默认初始化值

     规定：二维数组分为外层数组的元素，内层数组的元素

     1. 针对于初始化方式一:

        比如：int[][]arr = new int[4][3]；

        1. 外层元素的初始化值为：地址值
        2. 内层元素的初始化值为：与一维数组初始化情况相同

     2. 针对于初始化方式二:

        比如:int[][] arr = new int[4][];

        1. 外层元素的初始化值为：null

        2. 内层元素的初始化值为：不能调用，否则报错。

  4. 二维数组内存解析

• 数组的常见算法

  1. 数组的赋值,复制,反转

     • 赋值

       //array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体
       
       int[] array1,array2;
       array1 = new int[]{
                  1,2,3,4};
       array2 = array1;
       

       [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-00EcNc0b-1597572422052)(https://i.loli.net/2020/08/16/PBicnmdOLpefzUs.png)]

     • 复制

       //通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。
       
       int[] array1,array2;
       array1 = new int[]{
                  1,2,3,4};
       array2 = new int[array1.length];
       for(int i = 0;i < array2.length;i++){
                  
       	array2[i] = array1[i];
       }
       

       [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X5qVVBhn-1597572422055)(https://i.loli.net/2020/08/16/h5t6JmkIVrHudRY.png)]

     • 反转

       //方法一：
       	for(int i = 0;i < arr.length / 2;i++){
                  
       		String temp = arr[i];
       		arr[i] = arr[arr.length - i -1];
       		arr[arr.length - i -1] = temp;
       	}
       		
       //方法二：
       	for(int i = 0,j = arr.length - 1;i < j;i++,j--){
                  
       		String temp = arr[i];
       		arr[i] = arr[j];
       		arr[j] = temp;
       	}
       

  2. 数组中指定元素的查找：搜索、检索

     1. 线性查找：
        实现思路：通过遍历的方式，一个一个的数据进行比较、查找。
        适用性：具有普遍适用性。
     2. 二分法查找：
        实现思路：每次比较中间值，折半的方式检索。
        适用性：（前提：数组必须有序）

  3. 数组的排序算法[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cJeGvII1-1597572422057)(https://i.loli.net/2020/08/16/Fjbv5Z2oK83Taqm.png)]

     1. 衡量排序算法的优劣：时间复杂度、空间复杂度、稳定性

     2. 排序的分类：内部排序 与 外部排序（需要借助于磁盘）

     3. 不同排序算法的时间复杂度[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ue59n3E3-1597572422058)(https://i.loli.net/2020/08/16/WcCiRFQftq9Tna3.png)]

     4. 冒泡排序

        		int[] arr = new int[]{
                   43,32,76,-98,0,64,33,-21,32,99};
        		
        		//冒泡排序
        		for(int i = 0;i < arr.length - 1;i++){
                   
        			for(int j = 0;j < arr.length - 1 - i;j++){
                   
        				if(arr[j] > arr[j + 1]){
                   
        					int temp = arr[j];
        					arr[j] = arr[j + 1];
        					arr[j + 1] = temp;
        				}	
        			}
        		}	
        

     5. 快速排序

        
        public class QuickSort {
                   
            public static void quickSort(int[] arr,int low,int high){
                   
                int i,j,temp,t;
                if(low>high){
                   
                    return;
                }
                i=low;
                j=high;
                //temp就是基准位
                temp = arr[low];
         
                while (i<j) {
                   
                    //先看右边，依次往左递减
                    while (temp<=arr[j]&&i<j) {
                   
                        j--;
                    }
                    //再看左边，依次往右递增
                    while (temp>=arr[i]&&i<j) {
                   
                        i++;
                    }
                    //如果满足条件则交换
                    if (i<j) {
                   
                        t = arr[j];
                        arr[j] = arr[i];
                        arr[i] = t;
                    }
         
                }
                //最后将基准为与i和j相等位置的数字交换
                 arr[low] = arr[i];
                 arr[i] = temp;
                //递归调用左半数组
                quickSort(arr, low, j-1);
                //递归调用右半数组
                quickSort(arr, j+1, high);
            }
         
         
            public static void main(String[] args){
                   
                int[] arr = {
                   10,7,2,4,7,62,3,4,2,1,8,9,19};
                quickSort(arr, 0, arr.length-1);
                for (int i = 0; i < arr.length; i++) {
                   
                    System.out.println(arr[i]);
                }
            }
        }
        
        

  4. Arrays常见的工具类

     //1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
     int[] arr1 = new int[]{
              1,2,3,4};
     int[] arr2 = new int[]{
              1,3,2,4};
     boolean isEquals = Arrays.equals(arr1, arr2);
     System.out.println(isEquals);
     		
     //2.String toString(int[] a):输出数组信息。
     System.out.println(Arrays.toString(arr1));
     		
     			
     //3.void fill(int[] a,int val):将指定值填充到数组之中。
     Arrays.fill(arr1,10);
     System.out.println(Arrays.toString(arr1));
     		
     
     //4.void sort(int[] a):对数组进行排序。
     Arrays.sort(arr2);
     System.out.println(Arrays.toString(arr2));
     		
     //5.int binarySearch(int[] a,int key)
     int[] arr3 = new int[]{
              -98,-34,2,34,54,66,79,105,210,333};
     int index = Arrays.binarySearch(arr3, 210);
     if(index >= 0){
              
     	System.out.println(index);
     }else{
              
     	System.out.println("未找到");
     }
     

  5. 数组常见异常

     1. 数组角标越界异常：ArrayIndexOutOfBoundsException

        int[] arr = new int[]{
                   1,2,3,4,5};
        		
        //		for(int i = 0;i <= arr.length;i++){
                   
        //			System.out.println(arr[i]);
        //		}
        		
        //		System.out.println(arr[-2]);
        		
        //		System.out.println("hello");
        

     2. 空指针异常：NullPointerException

        		//情况一：
        //		int[] arr1 = new int[]{1,2,3};
        //		arr1 = null;
        //		System.out.println(arr1[0]);
        		
        		//情况二：
        //		int[][] arr2 = new int[4][];
        //		System.out.println(arr2[0][0]);
        		
        		//情况三：
        //		String[] arr3 = new String[]{"AA","BB","CC"};
        //		arr3[0] = null;
        //		System.out.println(arr3[0].toString());
        

out.println(“hello”);
```

 2. 空指针异常：NullPointerException

    ```java
    		//情况一：
    //		int[] arr1 = new int[]{1,2,3};
    //		arr1 = null;
    //		System.out.println(arr1[0]);
    		
    		//情况二：
    //		int[][] arr2 = new int[4][];
    //		System.out.println(arr2[0][0]);
    		
    		//情况三：
    //		String[] arr3 = new String[]{"AA","BB","CC"};
    //		arr3[0] = null;
    //		System.out.println(arr3[0].toString());
    ```