Java方法

设计原则 : 一个方法只完成一个功能 , 这样利于我们后期的扩展---原子性

main()方法要尽量保持整洁干净

Java方法类似于其他语言的函数

一个方法需要包含以下语法 :

• 修饰符 : 可选
• 返回值类型 : void或其他
• 方法名 : 驼峰命名
• 参数类型 : 可选
• 方法体 : 包含的具体的功能

    public static void main(String[] args) {
        int sum = add(1, 2); //实参
        System.out.println("sum = " + sum);
    }
    /*
    修饰符 返回值类型 方法名(参数类型 参数名){
        方法体

        return 返回值;
    }
     */
    public static int add(int a,int b){ //形参
        return a+b;
    }

**实参 : **实际调用传递的参数

**形参 : **用来定义的

调用方法 :

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

当方法返回一个值时 , 方法调用通常被当做一个值

如果方法返回值是void , 方法调用一定是一条语句

重载方法

名称必须相同 , 参数列表必须不相同 (个数不同 , 或类型不同, 或排列顺序不同) , 返回值类型不能是重载的判断条件

方法相同时 , JVM会自己判断

    public static int add(int a,int b,int c){
        return a+b+c;
    }
    public static int add(int a,int b){
        return a+b;
    }

命令行传参

java Test this is YYY

使用cmd时可以给main方法传递参数

可变参数

不定项参数 , 不规定传多少个参数 , 在方法声明中 , 在指定参数类型后加一个省略号(...)

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

    public static void main(String[] args) {
        Demo04 t = new Demo04();
        t.test(1,5,6,8,7);
    }
    public void test(int... i){
        System.out.println(i[0]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
    }

本质上就是数组

递归

就是A方法调用A方法 , 自己调用自己

递归结构的两个部分 :

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

递归体：什么时候需要调用自身方法。

递归并不是个优秀的算法，能不用递归就不用递归

Java数组

数组 : 相同类型数据的有序集合

要使用数组得先声明

        int[] nums;  //声明
        int num[];   //不推荐

        nums=new int[10]; //使用new创建数组 , 可以存放10个int类型的数字

        //赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;
        //不赋值会有默认值
        System.out.println(nums[0]);

Java内存分析

声明数组并不存在 , 只有创建了才存在 , 一旦创建了就不能改变

• 堆

存放new的对象和数组

• 栈

存放基本变量类型(会包含这个基本类型的具体数值)

引用对象的变量(会存放这个引用在堆里面的具体地址)

数组特点

1. 长度是固定的 , 一旦创建大小就不能改变
2. 其中的元素必须是相同类型
3. 可以是引用类型数组,也可以是基本类型数组
4. 数组变量属于引用类型
5. 数组本身就是对象 , Java中对象是在堆中的 , 因此数组对象本身就是在堆中的

数组使用

• for-each循环 : 一般用来打印结果

        //遍历
        int[] a={1,2,3,4,5,6,7};
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
        
        //计算和
        int sum=0;
        for (int i = 0; i < a.length; i++) {
            sum+=a[i];
        }
        System.out.println("sum = " + sum);

        System.out.println("========");
        //JDK1.5 , 没有下标
        for (int i : a){
            System.out.println(i);
        }

• 数组作为参数传入方法

多维数组

数组中嵌套数组

        int[][] a={{1,2,3},{4,5,6},{7,8,9}};

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

Arrays类

java.util.Arrays

• 输出数组

        int[] a = {45,78,56,12,35,8,15,98,25};

        System.out.println(Arrays.toString(a));

• 排序

sort

• 二分查找

binarySearch

• 填充

fill

冒泡排序

外层表示轮数 , 里层依次比较

1. 比较数组中两个相邻的元素

2. 每次比较都会产生一个最大或最小的数组

3. 下一轮则可以少一次排序

    public static int[] mySort(int[] a){
        int temp;
        //外层 , 判断要走多少次
        for (int i = 0; i < a.length-1; i++) {
            //内层 , 判断比较两个数 , 如果第一个数比第二个数大 , 交换位置
            for (int j = 0; j < a.length-1-i; j++) {
                if(a[j]>a[j+1]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        return a;
    }

稀疏数组

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

记录原始数组的有效的值生成一个新的数组

    public static void main(String[] args) {
        int[][] a=new int[11][11];
        a[1][2]=1;
        a[2][3]=2;
        System.out.println("原始的数组 : ");
        for (int[] i : a){
            for (int j : i){
                System.out.print(j+"\t");
            }
            System.out.println();
        }

        //获取有效值的个数
        int sum=0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println("有效的个数 : "+sum);
        System.out.println("转换为稀疏数组 : ");
        //创建一个稀疏数组的数组
        int[][] a2=new int[sum+1][3];
        a2[0][0]=a.length;
        a2[0][1]=a.length;
        a2[0][2]=sum;

        int count=0;    //计数器
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length; j++) {
                if(a[i][j]!=0){
                    count++;
                    a2[count][0]=i;
                    a2[count][1]=j;
                    a2[count][2]=a[i][j];
                }
            }
        }

        for (int i = 0; i < a2.length; i++) {
            for (int j = 0; j < a2.length; j++) {
                System.out.print(a2[i][j]+"\t");
            }
            System.out.println();
        }
        //还原稀疏数组
        //先读取稀疏数组的值
        int[][] a3=new int[a2[0][0]][a2[0][1]];
        //还原值
        for (int i = 1; i < a2.length; i++) {
            a3[a2[i][0]][a2[i][1]]=a2[i][2];
        }
        //打印
        System.out.println("还原的数组 : ");
        for (int[] i : a3){
            for (int j : i){
                System.out.print(j+"\t");
            }
            System.out.println();
        }
    }