Day05

方法

方法返回类型void代表返回值空

格式：修饰符 返回类型 方法名（参数类型 参数名）{

方法体

返回值}

实参：实际调用传递给她的参数。

形参：用来定义。

方法调用：

  调用方法  对象名.方法名（实参）

方法重载

重载规则：

1.方法名称相同

2.参数列表不同

3.仅仅返回值类型不同不可以叫重载

public class Demo01 {
    public static void main(String[] args) {
        //实参：实际调用传递给他的参数
        int sum =add(1,2);
        System.out.println(sum);
    }
    //形式参数用来定义作用
    public  static  int add(int a,int b){
        return a+b;
    }
    //方法重载
    public  static double add(double a, double b){
        return a+b;
    }
}

命令行传参

//实现运行时再传递给她消息可以使用命令行传参
//main方法传递参数，要找好包路径
public class Demo03 {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "]:" + args[i]);

        }
    }
}

可变参数：

1.Java支持传递同类型可变参数给一个方法

2.在方法声明中指定参数类型加个。。。

3.一个方法中只能有一个可变参数，她必须是方法的最后一个参数。

//可变参数
//选出最大值
public class Demo04 {
    public static void main(String[] args) {
       printMax(34,56,65);
       printMax(new double[]{1,2,3});
    }
    public  static void printMax(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("max is"+result);
    }
}

递归

递归包括：

1递归头：什么时候不调用自身。

2递归体：什么时候需要调用自己。

public class Demo05 {
    //阶乘
    //递归思想
    public static void main(String[] args) {
  System.out.println(f(5));
    }
    public  static  int f(int n){
        if (n == 1){
            return 1;
        }else  {
            return n*f(n-1);
        }
    }
}

数组

数组是相同类型的有序集合。

数组的创建，声明和初始化

俩个声明：int [] num; //定义1 （首选 ）
int nums []; //定义2

声明加创建：int [] num = new int[n]

初始化：

public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化:  创建+赋值
        int [] a = {1,2,3,4,5,6,7,8,9};
        //动态初始化   包含默认初始化
 //        int [] b = new int[10];
//        b[0] = 10;
//        System.out.println(b[0]);
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }


    }
}

静态初始化；动态初始化；

数组四个特点

1.数组也是对象，数组元素相当于对象的成员变量。

2.长度大小确定不可变。

3.数组是相同类型有序集合。

public class ArrayDemo03 {
    public static void main(String[] args) {
        int [] s = {1,2,3,4,5};
                /*
打印所有数组元素
        for (int i = 0; i < array.length; i++) {
            System.out.println(s[i]);

        }
        System.out.println("---------");
        int sum = 0;
        for (int i = 0; i < args.length; i++) {
            sum +=s[i];

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

        }
        System.out.println("max="+max);
没有下标

        for (int i : s) {
            System.out.println(s[i-1]);
        }
*/

        printArray(s);

       int[] reverse = reverse(s);
       printArray(reverse);//反转之后用上面方法遍历输出
    }
    //遍历了数组
    public  static void printArray(int [] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]+"");

        }
    }
    //反转数组   返回了一个数组
    public static int[] reverse(int[] array){
        int[] result = new int[array.length];
        for (int i = 0,j = result.length-1; i < array.length; i++,j--) {
            result[j] = array[i];
        }
        return result;
    }



}

二维数组

//遍历二维数组
public class Demo05 {
    public static void main(String[] args) {
        /*[3][2]
        /3, 7  array[0]
         5, 6  array[1]
         3, 8  array[2]
         */
        int [][] array={{3,7},{5,6},{3,8}};
        printArray(array);
    }

    public  static void printArray(int [][] arrays){
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                 System.out.println(arrays[i][j]);
            }

        }
    }
}

冒泡排序：

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

import java.util.Arrays;

public class Demo07 {
    public static void main(String[] args) {
        int [] a = {1,56,9566,564,88};
      System.out.println(Arrays.toString(sort(a)));
    }
    //冒泡排序
    //1.比较数组中，俩个相邻的元素如果第一个比第二个大就交换位置
    //2.每一次比较都会产生一个最大或最小
    //3.下一轮可以减少一次排序
    //依次循环
    public  static int[] sort(int [] array){
        for (int i = 0; i < array.length-1; i++) {


            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j+1]<array[j]){
                    int s = 0;
                    s = array[j+1];
                    array[j+1] = array[j];
                    array[j] = s;
                }
            }
        }return array;
    }
    //

}

学习看狂神Java