小白学习第5天

Java方法

Java方法是一段用来完成特定功能的代码片段

• 方法是解决一类问题的步骤的有序组合
• 方法是包含于类或者对象中
• 方法在程序中被创建，在其他地方被引用

方法包含

一个方法头和一个方法体：

修饰符

返回值类型

方法名

参数类型

形式参数：在方法被调用时用于接收外界输入的数据，int a，这里的a就是个形势参数

实际参数：调用方法时实际传给方法的数据，比如让a=3

方法体

修饰符 返回值类型 方法名（参数类型 参数名）{
    ···
    方法体
    ···
        return 返回值；
}
=======================================
    public static void main(String[] args)

return 0用来终止方法

方法的重载

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

方法重载的规则

方法名称必须相同

参数列表必须不同（个数不同、或类型不同、参数排列顺序不同）

方法的返回类型可以相同也可以不相同

仅仅返回类型不同不足以成为方法的重载

命令行传参

先让程序运行，再给程序传递参数，在cmd中要使用完整的路径，从src开始，java Rhodes.Ceobe.method

可变参数

在方法声明中，在指定参数类型后加一个省略号

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

递归

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

计算器

只能依次输入 数据 运算符 数据，一开始想的是直接输入 数据 运算符 数据，回车得到结果，但是能力不行，只能借鉴别人的代码了

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入计算的第一个数字：");
        while (scanner.hasNextDouble()) {
            double a = scanner.nextDouble();
            System.out.println("请输入一个运算符：");
            String b = scanner.next();
            System.out.println("请输入计算的第二个数字：");
            double c = scanner.nextDouble();
//根据输入的运算符来用swith语句判断，所以c用字符串来定义
            switch (b) {
                case "+":
                    add(a, c);
                    break;
                case "-":
                    mius(a, c);
                    break;
                case "*":
                    multiply(a, c);
                    break;
                case "/":
                    except(a, c);
                    break;
            }
            System.out.println("继续计算请继续输入一个数字" + "\n" + "======================="
                    + "\n" + "退出请输入任意字母！！！");
        }
        scanner.close();
    }

    //编写四个方法，完成加减乘除的运算功能
    public static void add(double num1, double num2) {
        System.out.println(num1 + num2);

    }

    public static void mius(double num1, double num2) {
        System.out.println(num1 - num2);

    }

    public static void multiply(double num1, double num2) {
        System.out.println(num1 * num2);

    }

    public static void except(double num1, double num2) {
        if (num2 == 0) {
            System.out.println("分母不能为零！！！");
        } else {
            System.out.println(num1 / num2);
        }
    }

数组

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

        int[] nums;//声明一个数组
        nums=new int[10];//确定数组的空间
/*
等效于int[] nums=new int[10]
 */
        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;
        //计算所有元素的和
        int sum=0;
        for (int i = 0; i < nums.length; i++) //nums.length相当于获取了数组长度，既10
        {
sum=sum+nums[i];
        }
        System.out.println(sum);
    }

Java内存分析

堆

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

nums=new int[10];

栈

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

int[] nums;

三种初始化

静态初始化

//静态初始化
int a[]={1,2,3,4,5};

动态初始化

//动态初始化,包含默认初始化
int b[]=new int[3];
        b[0]=10;

默认初始化

如上述代码，没给b[1]的值，默认就是0

数组的四个特点

• 数组一旦被创建，它的大小就是不可改变的
• 其中元素必须是相同类型，不允许出现混合类型
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
• 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

数组的使用

For-Each循环

数组作方法入参

数组作返回值

    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        int[] reverse=reverse(arr);
        print(reverse);
    }//反转数组
    public static int[] reverse(int[] a){
        int[] result=new int[a.length];
     for (int i = 0,j= a.length-1; i <a.length; i++,j--) {
        result[j]=a[i];
        }
        return result;
    }
    //打印数组
    public  static void print(int[] a){
        for (int i = 0; i < a.length ; i++) {
            System.out.print(a[i]+" ");
        }
    }