1.java的方法类似于其他语言的函数，用来完成特定功能的代码片段。

定义方法的语法：
修饰符：可选。告诉编译器如何调用这个方法，定义了该方法的访问类型。
返回值类型：如果方法有返回值，该方法需要定义方法的返回值的类型。如果没有返回值，类型为关键字void。
方法名：方法的实际名字。
参数类型：可选。方法被调用时，传递值给参数
　　　　实参：调用方法时实际传给方法的数据。(方法被调用时的参数)
　　　　形式参数：方法被调用时，用于接收外界输入的数据。（方法定义时的参数）
方法体：定义方法的功能。

2.方法重载：方法名协同，参数不同（参数类型，参数个数，参数顺序任一个不同）。

3.命令行传参：有时候需要运行程序时再传信息。此时可以传递命令行参数给main（）函数实现。

使用命令行编译java。在文件所在目录用cmd打开命令行工具。执行 javac StudyWeek1.java


使用命令行执行class文件。利用命令转到src目录下，执行java com.company.StudyWeek1 Parm1 Parm2
（执行文件必须在src目录下，并且加上包名（不加包名会报错），如果有参数需要在文件后加上参数，没有可不加）

4.可变参数。类型... 变量

方法声明中，在指定参数类型后加一个省略号。一个方法只能指定一个可变参数，它必须是方法的最后一个参数。

5.递归：A方法调用A方法（自己调用自己）深度小的话可用，深度大了最好别用，影响性能。

递归包含两部分：
递归头：什么时候不调用自身方法。没有头将会死循环。
递归体：什么时候需要调用自身方法。

/**
 * 阶乘 5！=5*4*3*2*1
 * 主要是学习递归思想
 * @param n
 */
private static int jieCheng(int n){
    if(n==1){
        return 1;
    }else{
        return n*jieCheng(n-1);
    }
}

6.数组:相同类型数据的有序集合（相同类型的多个数据按照先后顺序排列组合）

每个数据成为数组元素，每个元素通过下标来访问。
静态定义数组：int[] array={1,2,3,4,5}
动态定义数组：
声明数组：①dataType[] array;//类型加中括号，首选
②dataType array[];//变量加中括号（早期为了过度c和c++）
new操作创建数组：dataType[] array = new dataType[size];//分配size大小的空间
获取数组长度：array.length

private  static void arrayAdd(){
    //定义数组
    int[] array = new int[10];
    int result =0;
    //给数组元素赋值，不赋值默认为0（因为是int）
    array[0]=0;
    array[1]=1;
    array[2]=2;
    array[3]=3;
    array[4]=4;
    for (int arr:array){
        result=result+arr;
    }
    System.out.println("result="+result);
}

java内存分为：
堆：存放new的对象和数组，可以被所有的线程共享，不会存放别的对象引用
栈：存放①基本变量类型（包含这个基本类型的具体数值），②引用对象的变量（存放这个引用在堆里面的具体地址）
方法区：可以被所有线程共享,包含所有class和static变量

数组的特点：①长度确定，一旦被创建，大小不可改变②元素类型必须相同
③数组元素可以是任何数据类型，包括基本类型和引用类型。
④数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于对象的成员变量。
数组本身就是对象，java中对象是在堆中的，所以数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中。

7.多维数组：数组的数组。如二维数组就是一个特殊的一维数组，其每一个元素就是一个一维数组。

二维数组：int a[][]=new int[2][5](两行五列数组）

8.Array类:数组的工具类java.util.Arrays

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调研，而不用对象进行调用。
常用方法：更多方法可以查看jdk帮助文档
fill→数组赋值
sort→按升序排序
equals→比较数组中元素是否相等
Arrays.toString()→将一维数组转为string
Arrays.deepToString()→将多维数组转为string
binarySearch→对排好序的数组进行二分查找法操作。

//Arrays工具类运用
int[][] a = new int[2][5];
a[0][0]=1;
a[0][1]=12;
a[0][2]=3;
a[0][3]=41;
a[0][4]=5;
System.out.println(Arrays.toString(a[0]));
Arrays.sort(a[0]);//排序
System.out.println(Arrays.toString(a[0]));
Arrays.fill(a[1],2,5,2);//填充数据下标2-4为2
System.out.println(Arrays.toString(a[1]));

结果：
[1, 12, 3, 41, 5]
[1, 3, 5, 12, 41]
[0, 0, 2, 2, 2]

9.冒泡排序：重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

java中只需要两层循环，外层冒泡轮数，里层依次比较。

/**
 * 冒泡排序：
 * 1.比较数组中两个相邻元素，如果第一个数比第二个大，我们就交换位置
 * 2.每次比较都会产生一个最大或者最小数
 * 3.下一轮可减少一次排序
 * 4.依次循环，直到结束。
 */
private static int[] bubbleSort(int[] sortArray){
    int cnt=0;

    for (int i = 0; i < sortArray.length; i++) {
        boolean isend=false;//设置排序是否完成标志位，如果本轮次都没有交换，说明排序完成，退出排序
        for (int j = 0; j < sortArray.length-1-i; j++) {
            int temp =0;
            if(sortArray[j]>sortArray[j+1]){
                temp=sortArray[j+1];
                sortArray[j+1]=sortArray[j];
                sortArray[j]=temp;
                isend=true;
            }
            cnt=cnt+1;
        }
        if(!isend){
            break;
        }
    }
    System.out.println("cnt="+cnt);
    return sortArray;
}