Java2

包机制

为了更好的组织类，Java提供了包机制，用于区别类名的命名空间

包语句的语法格式为：

package pkg1[.pkg2[.pkg3]];
例如：
package com.company;

包属于标识符

一般利用公司域名倒置作为包名

为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包，使用“import”可完成此功能

import package1[.package2](classname|*);
例如：
import java.math.BigDecimal;

Java Doc生成文档

Java Doc命令是用来生成自己 API 文档的

参数信息：

• @author 作者名
• @version 版本号
• @since 指明需要最早使用的 jdk 版本
• @param 参数名
• @return 返回值情况
• @throws 异常抛出情况

Java数组

数组是相同类型数据的有序结合

数组的描述是相同类型的若干个数据，按照一定的先后次序排列而成

其中，每一个数据称为数组元素，每个数组元素可以通过一个下标来访问

数组声明创建

声明数据变量的语法：

dateType[] arrayRefVar;     //首选方法

JAVA语言使用new操作符来创建数组，语法：

dateType[] arrayRefVar = new dateType[arraySize];

数组的元素是通过索引来访问的数组索引从0开始

获取数组长度： arrays.length

数组的特点：

• 数组的长度是固定的，不可变的，不能越界

  数组下标越界报错 ArrayIndexOutOfBoundsException

• 其元素必须是相同类型

• 数组中的元素可以是任意类型，包括基本类型和引用类型

• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

Java内存

三种初始化

• 静态初始化：创建+赋值
• 动态初始化包含默认初始化
• 数组默认初始化

数组使用

• 普通for循环
• For—Each循环
• 数组作方法入参
• 数组作返回值

多维数组

多维数组可以看作顺序数组的在数组，其每个元素都是一个一维数组

二维数组

例如：
int a[][] = new int [2][5];

例如：杨辉三角

Arrays类

数组的工具类java.util.Arrays

功能：

• 给数组赋值：fill方法
• 对数组排序：sort方法，升序
• 比较数组：equals方法，比较数组中元素值是否相等
• 查找数组元素：binarySearch方法，对排序好的数组进行二分查找
• 输出数组信息：toString方法

常见异常

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

   public class Main {
   
       public static void main(String[] args) {
           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[-1]);
       }
   }
   

2. 空指针异常：NullPointerException

   public class Main {
   
       public static void main(String[] args) {
           //情况一
           int[] arr = new int[]{1, 2, 3};
           arr = null;
           System.out.println(arr[0]);
           //情况二
           int[][] arr1 = new int[4][0];
           System.out.println(arr1[2][2]);
           //情况三
           String[] arr2 = new String[]{"AA","BB","CC"};
           arr2[0] = null;
           System.out.println(arr2[0].toString());
       }
   }
   

冒泡排序

最出名的排序算法之一,复杂度为O(n2)

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {

        int[] a = {1,45,3,10,43,5,6,2,7};

        int[] sort = sort(a);  //调用完方法后，返回一个排序后的数组

        System.out.println(Arrays.toString(sort));
    }


    //冒泡排序
    //1.比较数组中两个相邻元素，如果第一个比第二个大，则交换位置
    //2.每次比较都会产生一个最大的数或者最小的数
    //3.下一轮可以减少一次排序
    //4.依次循环，直到结束


    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;

        //外层循环，判断需要走多少次
        for (int i = 0; i < array.length-1; i++){

            boolean flag = false;    //通过flag标识减少没有意义的比较，使其优化

            //内层循环，比价判断两个数，如果第一个比第二个大，则交换位置
            for (int j = 0; j < array.length-1-i; j++){
                if (array[j+1] < array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if (flag == false){
                break;
            }
        }
        return array;
    }
}

稀疏数组

当一个数组中大部分元素为0 时，或者为同一值的数组，可以用稀疏数组来保存该数组

稀疏数组的处理方式：

• 记录数组一共有几行几列，有多少不同值

• 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

  	行	列	值
  [0]总共
  [1]第一个有效值
  [2]第二个有效值

public class Main {

    public static void main(String[] args) {
        //1.创建一个二维数组11*11，  0：没有棋子  1：黑棋   2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始数组");

        for (int[] ints: array1){
            for (int anInt: ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //转化为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++){
            for (int j = 0; j < 11; j++){
                if (array1[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数：" + sum);

        //2.创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零的值放入稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++){
            for (int j = 0; j < array1[i].length; j++){
                if (array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        //输出稀疏数组

        System.out.println("稀疏数组：");
        for (int i = 0; i < array2.length; i++){
            System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2] + "\t");
        }

        System.out.println("=====================");
        System.out.println("还原");
        //1.读取稀疏数组的值
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++){
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //3.打印还原数组
        System.out.println("输出还原数组");
        for (int[] ints: array3){
            for (int anInt: ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

Java方法

Java方法是语句的结合：

• 方法是解决一类问题的步骤的有序组合
• 方法包含与类或对象中
• 方法在程序这被创建，其他地方被调用

设计方法的原则：一个方法只完成一个功能

定义及调用

定义

Java方法类似与其他语言的函数，是一段用来完成特定功能的代码片段

方法包含一个方法头和一个方法体，一个方法的所有部分：：

• 修饰符 可选的
• 返回值类型
• 方法名
• 参数类型
  • 形式参数 用来定义作用的
  • 实参 实际调用传给它的参数
• 方法体

修饰符 返回值类型 方法名 (参数类型 参数名){
    方法体
    return 返回值
}

调用

调用方法：对象名. 方法名(实参列表)

值传递（Java） 引用传递

return关键字的使用：

1. 使用范围：使用在方法体中
2. 作用：
   • 结束方法：
   • 针对有返回值类型的方法，使用“return 数据”方法
3. 注意点：return关键字后面不可以声明执行语句

重裁

重裁就是在一个类中，有相同的函数名称，但形参不同的函数

规则：

• 方法名称必须相同
• 参数列表必须不同（个数不同，类型不同或排列顺序不同）
• 方法的返回类型可以相同可以不同
• 仅仅返回类型不同不足以构成重裁

命令行传参

可变参数

Java 1.5开始，Java支持传递同类型的的可变参数给一个方法

在方法声明中，在指定参数类型后面加省略号(…)

一个方法中只能指定一个可变参数，它必须是方法中最后一个参数，任何普通的参数必须在它之前声明

可变个数形参（JDK5.0新增内容）：

具体使用：

1. 可变个数形参的格式，数据类型 … 变量名
2. 可调用可变个数形参的方法，传入的参数个数可以是0个，1个，3个。。。
3. 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重裁

递归

递归就是调用自身

递归结构包含两部分;

• 递归头：什么时候不调用自身方法
• 递归体：什么时候调用自身方法

例如：

public class Main {
    public static void main(String[] args) {
        System.out.println(f());
    }
    public static int f(int n){
        if (n==1){
            return  1;
        }else {
            return  n*f(n-1);
        }
    }
}