Java SE学习笔记（二）

前言

在上一章中学习了循环以及输入输出的使用
循环输入
在本章中会学习方法的使用

一、方法

方法就是C语言中的函数
类中有函数和方法
方法其实是一种功能

public static String autumnTrousers(String name){   //这里String name 就是形式参数
        System.out.println(name+"穿秋裤");
        return "ok!";  //return代表方法的结束
    }
    public static void main(String[] args) {
        String a=autumnTrousers("小明");   //方法的调用，若不进行调用，则无效。
        System.out.println(a);
        String a1=autumnTrousers("张三");//   这里"张三"就是实际参数
        System.out.println(a1);
    }

方法写一次，可以进行多次使用。
注意点：
1.程序执行的开始是main函数，若只编写方法未进行调用，则不生效。
2.接收调用方法的类型，必须要与方法的返回值相同。
例：autumnTrousers（上面方法）的返回值是String，那么接收时变量的类型就是String。
3.方法的形式参数可以有很多。
4.方法的调用需要在栈（虚拟机栈）上开辟内存。（重点）
#：栈：先进后出。
程序的开始先要调用main方法，这时会在内存上开辟一块空间，这块空间叫做栈帧，在main函数调用时又需要调用autumnTrousers方法，这时又会为这个方法开辟栈帧进行运算，运算结束后会从栈上消失，main函数也是如此。

二、形参与实参的区别

交换两个值

    public static void syster(int a,int b){
        int sum=a;
        a=b;
        b=sum;
    }
    public static void main(String[] args) {    //形参，与实参不同
        int a=10;
        int b=20;
        System.out.println("交换前："+a +" "+b);    //使用函数后不会交换，因在形参上改变，不会影响实参
        syster(a,b);
        System.out.println("交换后："+a +" "+b);
    }

在上述代码中，只交换了形参的值，没有交换实参，所以不能达到想要的效果。
传参：实参给形参传值。

三、方法使用

1.n的阶乘

strout方法做到了n的阶乘计算功能
strnet方法做到了n的阶乘的相加

public static  int strout(int j){    //求n的阶乘
        int fac=1;
        for(int i=1;i<=j;i++){
            fac*=i;
        }
        return fac;
    }
    public static  int strnet(){    //求n的阶乘的和
        int sum=5;
        int acb=0;
        for(int j=1;j<=sum;j++){
            acb+=strout(j);
        }
        return acb;
    }
    public static void main2(String[] args) {
        int i=strnet();
        System.out.println(i);
    }

2.两个整数相加

    public static int pubstr(int num ,int sum){
        return num+sum;
    }
    public static void main(String[] args) {     //求两个整数相加
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入第一个值：");
        int num=scanner.nextInt();
        System.out.println("请输入第二个值：");
        int sum=scanner.nextInt();
        int abc=pubstr(num,sum);    //方法的调用    接收的数据类型，要和方法的返回值相同
        System.out.println(abc);
    }

四、方法的重载（overload）

求两个数相加

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;
    }
    public static double add(double a,double b){
        return a+b;
    }
    public static void main5(String[] args) {
        int a=10,b=20,c=30;
        double a1=10.5,b1=20.5;
        int ret=add(a,b);
        System.out.println(ret);
        double ret1=add(a1,b1);
        System.out.println(ret1);
        int ret2=add(a,b,c);
        System.out.println(ret2);
    }

上面三个函数的add方法构成了方法的重载
重载满足的三个要求：针对同一个类
1.方法名相同
2.参数列表不同（个数或类型）
3.返回值不做要求

五、可变参数编程

使用情况较少（比较相同与数组）

    public static void func(int... array){
        for(int a:array){
            System.out.print(a+" ");
        }
        System.out.println();
    }
    public static void main6(String[] args) {    //可变参数编程   使用不多
        func(1);
        func(1,2);
        func(1,2,3);
        func(1,2,3,4);
        func(1,2,3,4,5);
    }

在方法的形参中使用 int…的方式可以起到array参数可变。

六、递归

递归：通俗的理解：大问题化小问题来解决
两个条件：
1.自身调用自身
2.要有一个趋近与自己的终止条件

public static void fun(int i){   
        if(i==0){
            return;    //终止条件
        }
        fun(i-1);    //趋近与终止条件
    }
    public static void main(String[] args) {    //初识递归
        fun(10);     //自身调用自身
    }