AVA学习----JavaSE---方法

方法

方法

方法的命名规则，第一个首字母小写，后面驼峰命名规则

设计方法的原则:方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性**,就是一一个方法只完成1个功能，这样利于我们后期的扩展**。

实参：实际传递给方法的参数

形参：方法括号中的参数

**static:**和类一起加载的。

方法的重载

定义：重载就是在一个类中，有相同的函数名称，但形参不同的函数。

方法重载的规则：

• 方法名称必须相同。
• 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等)。
• 方法的返回类型可以相同也可以不相同。
• 仅仅返回类型不同不足以成为方法的重载。

可变参数

• 在方法的声明中，在指定参数类型后加一个省略号(…)。
• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它声明之前声明。

public static void main(String[] args) {
        //调用可变参数方法
        printMax(1,23,23,25,23.8);
    }
    public static void  printMax(double... number){
        if (number.length>0){
            for (int i = 0; i <number.length; i++) {
                System.out.println(number[i]);
            }
        }
    }

递归

递归就是:A方法调用A方法!就是自己调用自己

递归结构包括两个部分:

• **递归头:**什么时候不调用自身方法。如果没有头，将陷入死循环
• **递归体:**什么时候需要调用自身方法。

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

能不用递归就不用递归，当基数大时消耗资源

数组

• 数组是相同类型数据的有序集合.
• 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
• 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标（从0开始）来访问它们.

    public static void main(String[] args) {
        //声明数组
        int[] nums;
        //创建
        nums=new int[5];//可以存放10个int类型的数据
        //赋值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        //输出
        for (int i = 0; i < nums.length; i++) {
            System.out.printf("nums[%s]:%s",i,nums[i]+"\n");
        }
    }

数组的默认初始化：

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

基本特点：

• 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

• 其元素必须是相同类型,不允许出现混合类型。

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

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

注意：

• 数组是相同数据类型(数据类型可以为任意类型)的有序集合
• 数组也是对象。数组元素相当于对象的成员变量
• 数组长度的确定的，不可变的。如果越界，则报:ArrayIndexOutofBounds

内存分析

**堆：**存放new的对象和数组，可以被所有的线程共享，不会存在别的对象引用

**栈：**存放基本变量类型（会包含这个基本类型的具体数值），引用对象的变量（会存放在这个引用在堆里面的及具体地址）

**方法区：**可以被所有的线程共享，包含了所有的擦class和static变量

冒泡排序

    public static void main(String[] args) {
        int[] nums={3,6,1,8,2,4,9};
        sort(nums);
        for (int num:nums) {
            System.out.println(num);
        }
    }

    //冒泡排序
    public static int[] sort(int[] arrsy) {
        for (int i = 0; i < arrsy.length - 1; i++) {
            for (int j = 0; j < arrsy.length - 1; j++) {
                if (arrsy[j+1]>arrsy[j]){
                    int temp=arrsy[j];
                    arrsy[j]=arrsy[j+1];
                    arrsy[j+1]= temp;
                }
            }
        }
        return arrsy;
    }

稀疏数组–数据结构

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

稀疏数组的处理方式：

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

    public static void main(String[] args) {
        //初级数组
        int[][] nums = new int[11][11];
        nums[1][2] = 1;
        nums[2][3] = 2;
        for (int[] ints : nums) {
            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 (nums[i][j] != 0) {
                    sum++;
                }
            }
        }
        int[][] arrays = new int[sum + 1][3];
        arrays[0][0] = 11;
        arrays[0][1] = 11;
        arrays[0][2] = sum;

        int count = 0;
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[i].length; j++) {
              if (nums[i][j]!=0){
                  count++;
                  arrays[count][0]=i;
                  arrays[count][1]=j;
                  arrays[count][2]=nums[i][j];
              }
            }
        }
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i][0]+"\t"+arrays[i][1]+"\t"+arrays[i][2]+"\t");
        }
        //还原数组
        int [][] nums1=new int[arrays[0][0]][arrays[0][1]];
        for (int i = 1; i < arrays.length; i++) {
            nums1[arrays[i][0]][arrays[i][1]]=arrays[i][2];
        }
        for (int[] ints : nums1) {
            for (int anint : ints) {
                System.out.print(anint + "\t");
            }
            System.out.println();
    }