JavaSE基础(15) Java方法（函数）

概念

概念：也叫函数，其实就是具有一定特殊功能的一段代码，将需要在多个位置重复使用的一组代码，定义在方法内部。

意义：1.避免了重复的代码。2.增强了程序的扩展性。

定义方法

用法：

step1：方法的定义(声明)

public static void main(String[] args) {}

语法格式：

[修饰符1,修饰符2...] 返回值/void 方法名(参数列表){
    .....
    return
}

示例：

//求1-10的和
public static void getSum(){
    //方法体
    int sum =0;
    for(int i=1;i<=10;i++){
        sum +=i;
    }
    System.out.println("sum:"+sum);
}

修饰符：public，static

返回值：一个方法执行之后，返回给调用处的结果。可能有，也可能没有。

有：在方法定义的时候，写清楚方法要返回的数据的类型。

没有：void，表示这个方法执行结束之后，没有返回值给调用处。

方法名：也是一种标识符。首字母小写，驼峰式命名。

()：方法的标志。括号里：参数列表

{}：方法体

参数列表：方法在运算过程中的未知数据，调用者调用方法时传递

return ：将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束

调用方法

step2：方法的调用(如果一个方法只有定义，那么方法中代码并没有被执行，只有被调用了才会执行方法中的代码)

通过方法的名字进行调用。

static的方法：静态方法
    类名.方法名()，本类中类名可以省略。
非static的方法：非静态方法
    创建该类的对象，通过对象调用方法。
    类名 对象名 = new 类名();
    对象.方法名();

示例：

//调用一个方法,如果是类的方法，可以用类名直接调用
//倘若是在本类中，那么类名可以省略
//1,static方法的调用
getSum();//方法的调用
//2，非static方法的调用
/*
创建该类的对象，通过对象调用方法。
类名 对象名 = new 类名(); 
对象.方法名();
*/
Demo1 demo1 = new Demo1();
demo1.test();//非static方法的调用

方法返回值

如果一个方法调用之后，需要返回给调用处结果，那么表示这个方法有返回值，在方法中需要使用return语句把结果返回给调用处。

//方法定义
public static 返回值类型 方法名(){
    //.....
    return 结果;
}
//方法的调用处
变量 = 方法名(); //变量 = 结果

如果一个方法，没有返回值，那么写void即可。

return语句：

        A：把方法中的返回值，返回给方法的调用处。

        B：同时结束了这个方法的执行。

//求1-10的和，并且把方法中计算的结果，返回给调用处，放大10倍再打印
public static void getSum(){
    int sum = 0;
    for (int i = 1; i <=10; i++) {
        sum  += i;
    }
    System.out.println("1-10之间的和：" + sum);
    //System.out.println("sum:"+sum);
    //方法调用处拿到的值和return相关，和方法体无关，
    return sum;
}

注意点：

1.如果一个方法声明了有返回值(非void)，那么方法中一定要使用return语句返回结果。

2.定义方法的时候，声明的返回值类型，一定得和return后实际上返回的数值类型一致。

3.如果一个方法声明了有返回值，如果方法中有分支语句或者循环语句，那么要保证无论执行哪个分支，都要有return可以被执行到。

4.如果一个方法声明没有返回值(void)，那么方法中也可以使用return语句，用于强制结束方法的执行。

/**
  * return要注意的点
  */
public class Demo2_return_2 {
    public static int test1(){
        // return "hehe";
        byte i = 20;
        double d = 2.3;
        return (int)d;//byte----->int，发生了隐式类型转换
    }
    public static int test2(){
        int age =10;
        if(age>10){
            return 0;
        }else{
            
        }
         return age;
    }
    public static int test3(){
        for(int i=1;i<=10;i++){
            // if(i==1){
            // return 0;//强制结束方法，，就是说方法后面的代码都不再执行了
            // }
            System.out.println(i);
        }
        System.out.println("hello,world");
        return 0;
    }
    public static void test4(){
        int age = 12;
        if(age>0){
            return;//用于结束方法的执行，即使在没有返回值的时候，也可以用return
        }
        System.out.println("wowowo,hello,");
    }
    public static void main(String[] args) {
        test3();
    }
}

方法相互调用

public class Demo2_2 {
    public static void test1(){
        System.out.println("test1.......");
    }

    public static void test2(){
        test1();
        System.out.println("test2......");
    }

    public static void test3(){
        test2();
        System.out.println("test3.....");
        // Demo2_2 demo22 = new Demo2_2();
        // demo22.test4();
    }

    public void test4(){
        Demo2_2.test3();//本类中就直接调用，如果是其他类就，用上类名
        System.out.println("test4()......");
    }

    public static void main(String[] args) {
        test3();
    }
}

方法参数

一个方法中，有些数据的数值不确定，我们定义为参数，由调用处调用方法的时候，传入具体的数据。

        形式参数：形参

        定义方式，声明的参数，用于接收调用处传来的数据。

        实际参数：实参

        调用方法的收，实际赋值给形参的数据。

/**
  * 方法的参数
  */
public class Demo {
    public static int getSum(int n){
        int sum = 0;
        for(int i=1;i<=n;i++){
            sum +=i;
        }
        return sum;
    }
    public static int getSum2(int a,int b){
        return a+b;
    }
    // public static int getSum2(){
        // int sum = 0;
        // for(int i=1;i<=20;i++){
        //
        // sum +=i;
        //
        // }
        //
        // return sum;
    // }

    public static void main(String[] args) {
        //求1-10的和；
        int result1 = getSum(10);
        //求1-20的和；
        //int result2 = getSum2();
        int result2 = getSum(20);
        //求1-100的和；
        //求两个数的和
        int result3 = getSum2(1,2);
    }
}

实参一定严格匹配形参：一一对应，包括顺序，个数，类型。

方法分类

        有返回值：

                有参数有返回值：public static 返回值类型 方法名(形参列表){}

                无参数有返回值：public static 返回值类型 方法名(){}

        无返回值：

                有参数无返回值：public static void 方法名(形参列表){}

                无参数无返回值：public static void 方法名(){}

方法重载

概念：一个方法的多种形式。

同一个类中

方法名相同

参数列表必须不同(顺序，个数，类型)

        与static，返回值，其他的修饰符。。。这些无关

示例：

public class Demo_overload {
    public static void test1(){}
    
    public static void test2(){}
    
    public void test3(){}

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

    public static double getSum(double a,double b){
        return a+b;
    }
    public void getSum(int c){
    
    }
    public static void main(String[] args) {    
        int result = getSum(1,2);
        double result2 = getSum(2.3,4);
    }
}

递归

方法中调用方法本身，就叫做递归方法。

递归方法一定有出口的，逐层的向出口靠近。

示例：

public class Demo_recursion {

    // 无返回值的递归方法
    public static void test1(int n){
        System.out.println("test1()......");
        if(n==1){
            return;//方法的出口
        }
        test1(n-1);//递归，自己调用自己,递归一定要有出口
        //test1(4)
        //test1(3)
        //test1(2)
        //test1(1)
    }

    //有返回值的递归方法
    public static int getSum(int n){
//        int sum = 0;
//        for (int i = 0; i <= 5; i++) {
//            sum +=i;
//        }
//        return sum;
        if(n==1){
            return 1;
        }
        return getSum(n-1)+n;
    }

    public static void main(String[] args) {
        test1(5);
        //用递归的方式来求1-5之间的和
//        getSum(5)---->getSum(4)+5;
//        getSum(4)---->getSum(3)+4;
//
//        getSum(3)---->getSum(2)+3;
//        getSum(2)---->getSum(1)+2;
//        getSum(1)----->return 1;

        System.out.println("------------------------");
        int sum = getSum(5);
        System.out.println("sum:"+sum);
    }
}