Java~方法

方法

实参对形参的调用输出

package com.Hoge.method;

public class Dome01 {
    //main方法 public static 修饰符 void返回值
    public static void main(String[] args) {
        //实际参数
       int sum = add(1,2);
        System.out.println(sum);//下面计算完传值回来输出
        //test();

    }
    //加法
    //形式参数
    public  static int add(int a,int b){//上面传值下来计算

        return  a+b;
    }

    public  static  void test(){
        for (int i = 0; i <= 1000; i++) {
            if ((i%5)==0  ){
                System.out.print(i+"\t");//\t空格
            }
            if (i%(5*3)==0){
                System.out.println();
                //或者 System.out.println("\n");//\n换行
            }
        }
    }
}

方法的定义调用

package com.Hoge.method;

public class Dome02 {
    public static void main(String[] args) {
        int max = max(10,20);
        System.out.println(max);

    }

    public static int max(int num1, int num2) {
        int result = 0;
//比大小
        if (num1 == num2) {
            System.out.println("num1 == num2");
            return 0;//这里的return结束方法

        }
        if (num1 > num2) {
            result = num1;

        }else {
            result = num2;
        }
        return result;//这里的return是返回结果
    }
}

方法的重载

规则：

1. 方法名称必须相同

2. 参数列表不同（个数不同、类型不同、参数排列顺序不同等）

3. 方法的返回类型可以相同 ** 可以不相同**

    package com.Hoge.method;
   
   public class Dome02 {
       public static void main(String[] args) {
           double max = max(10,20,30);
           System.out.println(max);
   
       }
       //比大小
       public static int max(int num1, int num2,int num3) {
           int result = 0;
   
           if (num1 == num2) {
               System.out.println("num1 == num2");
               return 0;//这里的return结束方法
   
           }
           if (num1 > num2) {
               result = num1;
   
           }else {
               result = num2;
           }
           return result;//这里的return是返回结果
       }
        //比大小
       public static int max(int num1, int num2) {
           int result = 0;
   
           if (num1 == num2) {
               System.out.println("num1 == num2");
               return 0;//这里的return结束方法
   
           }
           if (num1 > num2) {
               result = num1;
   
           }else {
               result = num2;
           }
           return result;//这里的return是返回结果
       }
        //比大小
       public static double max(double num1, double num2) {
           double result = 0;
   
           if (num1 == num2) {
               System.out.println("num1 == num2");
               return 0;//这里的return结束方法
   
           }
           if (num1 > num2) {
               result = num1;
   
           }else {
               result = num2;
           }
           return result;//这里的return是返回结果
       }
   
   }
   
   

   命令行传递参数

   可以通过cmd 找到文件目录下的把值给到

   package com.Hoge.method;
   
   public class Dome03 {
       public static void main(String[] args) {
           //args.length 数组长度
           for (int i = 0; i < args.length; i++) {
               System.out.println("args["+i+"]:"+args[i]);
   
           }
   
   
   
       }
   }
   

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AomgAhB3-1631020552303)(C:\Users\Hoge.L\AppData\Roaming\Typora\typora-user-images\image-20210715151356124.png)]

可变参数

为了给很多 也为了方便 在指定参数类型后面加个省略号（……）

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

package com.Hoge.method;

public class Dome04 {
    public static void main(String[] args) {
        //调用可变参数的方法
        Dome04 dome04 = new Dome04();
        dome04.test(1,2,3,56,7);

    }
    public void test(double x,double... i){
        if (i.length ==0){
            System.out.println("没有对比");
            return;
        }
        double result = i[0];
        for (int j =1; j<i.length;j++){
            if (i[j]>result){
                result =i[j];

            }
            System.out.println("as"+result);
        }

    }

}

递归

递归结构分为两部分

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

数组声明

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

dataType[] arrayRefVar = new dataType[arraySize] 

在代码运用如下：

package com.Hoge.array;

public class Dome01 {
    //变量的类型 变量的名字 = 变量的值；
    //数组类型

    public static void main(String[] args) {
        int[] nums;//定义
        nums = new int[10];//这里面可以存放10个int类型的数字

        //给数组元素赋值
        nums[0] =1;//数组下表都是从0开始的
        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[2]);

        //计算所以数的和
        int sum =0;
        //获取数组长度： arrays.length
        for (int i = 0; i < nums.length ; i++) {
            sum = sum+nums[i];
            
        }
        System.out.println("总和为："+sum);



    }
}

三种初始化

new是在堆中的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yIhY9bJG-1631020552308)(C:\Users\Hoge.L\AppData\Roaming\Typora\typora-user-images\image-20210715175327635.png)]

ackage com.Hoge.array;

public class Dome02 {
    public static void main(String[] args) {
        //静态初始化：创建 + 数值
        int[] a = {};
        System.out.println(a[0]);

        //动态初始化：包含默认初始化
        int[] b = new int[10];
        b[3] = 10;
        b[1] =20;

        System.out.println(b[3]);
        System.out.println(b[0]);
    }
}

for循环

package com.Hoge.array;

public class Doem03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        //打印所有元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);

        }
        System.out.println("=============================================");
        //计算所以的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum += arrays[i];

        }
        System.out.println("sum"+sum);
        System.out.println("============================================");
        //查找最大元素
        int max =arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if(arrays[i]>max){
                max = arrays[i];
            }
        }
        System.out.println("max="+max);
    }
}

for-Each（加强版for循环）

package com.Hoge.array;

public class Dome04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //增强型的for循环 省去下标 打印好 但要操作其中的就没有下标选
        for (int array : arrays) {

        }
        //printArrays(arrays);//调用打印方法
        int[] reverse = reverse(arrays);//调用下面的反转
        printArrays(reverse);//调用printArrays输出reverse值


    }
    //反转数组
    public  static int[] reverse(int[] arrays){
        int[] result = new  int[arrays.length];//这一步是把上面的值先拿下里
        //反转的操作 把拿到的值头尾互换
        for (int i = 0,j = result.length-1; i < arrays.length ; i++,j--) {
            result[j] = arrays[i];

        }
        return result;
    }
    //打印一个数组
    public  static void printArrays(int[]arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+"");//println去掉ln
        }
    }




}

二维数组

package com.Hoge.array;

public class Dome05 {
    public static void main(String[] args) {
        //4,2 二维数组
        /**
         * 1,2 array[0]
         * 2,3 array[1]
         * 3,4 array[2]
         * 4,5 array[3]
         *
         *
         */
        int [][] arrray = {{1,2},{2,3},{3,4},{4,5}};
        for (int i = 0; i < arrray.length; i++) {
            for (int j = 0; j < arrray[i].length; j++) {
                System.out.println(arrray[i][j]);
            }
        }
    }
    //打印一个数组
//    public  static void printArrays(int[]arrays){
//        for (int i = 0; i < arrays.length; i++) {
//            System.out.print(arrays[i]+"");//println去掉ln
//        }
//    }
}

Arrray类使用

package com.Hoge.array;

import java.util.Arrays;

public class Dome06 {
    public static void main(String[] args) {
        int[] a = {1,2,34,43,43234,34,34,3,4};
        //打印数组元素Arrays.toString
        //System.out.println(Arrays.toString(a));
        Arrays.sort(a);//数组进行排序：升序
        System.out.println(Arrays.toString(a));


        Arrays.fill(a,2,4,0);//数组填充
        System.out.println(Arrays.toString(a));
    }
//如果自己手打也一样可以显示这种效果
    public static void printArray(int[] a) {
        for (int i = 0; i < a.length; i++) {
            if (i==0){
                System.out.println("[");
            }
            if (i==a.length-1){
                System.out.println("]");
            }else {
                System.out.println(a[i]+", ");
            }

        }

    }
}

冒泡排序

package com.Hoge.array;


import java.util.Arrays;

//比较两个相邻元素的大小，如果第一个比第二个数大，则两个数交换位置
//每一轮比较都能得出最大或者最小值
//下一轮就可以少循环一次
//依次循环 到结束为止
public class Dome07 {
    public static void main(String[] args) {
        //冒泡排序
        int[] a={12222,213,23,2,3,213,23,34,3,4,34,34,};
        int[] sort = sort(a);//调用会自己写的方法
        System.out.println(Arrays.toString(sort));//打印的方法类
    }
    public  static  int[] sort(int[] array){
        //临时变量（空杯子）
        int temp = 0;
        //外部循环
        for (int i = 0; i < array.length-1; i++) {

            boolean flag = false;//通过false标示位来减少没有意义的输出

            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;
    }
}