java基础——方法

1.概念：

• 实现特定功能的⼀段代码，可反复使⽤。

2.定义无参方法

public static void 方法名() {
    //方法体，就是逻辑代码
}

• 定义的位置，要和main定义在同一级

• 可以通过 方法名() 调用此方法，目的就是执行方法体中的代码

• 好处：代码提高的复用性

package com.qfedu;
​
public class Demo01 {
​
    public static void main(String[] args) {
        //打印六行******
        printstar();
        
        System.out.println("----------------------------");
        
        /*
         * 在main方法中，使用  方法名()  调用此方法
         * 
         * 调用此方法：就是执行该方法中定义的代码
         */
        printstar();
        
    }
​
    //方法  对一些逻辑代码的整合/重构
    public static void printstar() {
        
        System.out.println("******");
        System.out.println("******");
        System.out.println("******");
        System.out.println("******");
        System.out.println("******");
        System.out.println("******");
        
    }
    
    //编写方法打印5行，一行十个-，调用此方法
    public static void main(String[] args) {
        //打印五行----------
        printSign(5);
    }
    
    //方法  对一些逻辑代码的整合/重构
    public static void printSign(int n) {
        for(int i=0;i<=n;i++) {
            System.out.println("----------");
        }
}

3.定义有参方法

• 把方法中可能会变化的值，定义成一个变量

• 变量需定义在方法的小括号中，叫做型参

• 在调用时，必须为括号中的变量赋值，赋的值叫做实参

public static void 方法名(数据类型 参数1, 数据类型 参数2, 数据类型 参数3,....) {
    //方法体，就是逻辑代码
}

package com.qfedu;
​
public class Demo02 {
    
    public static void main(String[] args) {
        printstar(5);
        
        printTriangle(7,"@");
    }
​
    
    
    /*
     * 定义有参数的方法
     * 1. 要把参数(变量)，定义在方法的小括号,起个名字叫形参
     * 2. 如果调用这个方法，必须要形参赋值，给形参赋的值，咱们叫实参
     */
    public static void printstar(int n) {
        for(int i=1; i<=n; i++) {
            System.out.println("******");
        }
    }
    
    /*
     *      1. 一个方法中可以定义多个形参，形参和形参之间使用逗号分隔
     *      2. 当调用方法时，需要为每个形参赋值，形参和实参的顺序一定要一致
     */
    public static void printTriangle(int n, String sign) {
        for(int i=1; i<=n; i++) {
            
            for(int j=1; j<=i; j++) {
                System.out.print(sign);
            }
            System.out.println();
            
        }
    }
    
    /*
     * 定义一个方法，方法有三个参数
     * 第一个参数，打印多少行
     * 第二个参数，每行打印多个个图形
     * 第三个参数，打印什么图形
     * 
     * 
     * 打印五行
     */
    public static void printSign4(int rows, int cols, String sign) {
        for(int i=1; i<=rows; i++) {
            for(int j=1; j<=cols; j++) {
                System.out.print(sign);
            }
            System.out.println();
        }
    }
}

4.有返回值得方法

public static 返回数据类型 方法名(数据类型 参数1, 数据类型 参数2, 数据类型 参数3,....) {
    //方法体，就是逻辑代码
    return 值;
}

• void 修改成一种数据类型(你想要得到的是什么数据，那么就定义成该种数据的类型)

• 该方法必须使用return 返回该数据类型的一个具体值

• 在调用此方法时，必须使用该数据类型的变量 接受这个值

• 如果一个方法中，已经执行了return关键字，那么程序就不再往下执行了

    /*
     * 定义一个方法,方法有两参数，获取两个参数的和
     */
    public static int sum(int n, int n2) {
        int sum = n+n2;
        return sum;
    }

package com.qfedu;
​
public class Demo03 {
    
    public static void main(String[] args) {
        int sum = sum(1, 3);
        System.out.println(sum);
    }
    
    /*
     * 定义一个方法,方法有两参数，获取两个参数的和
     * 
     * 定义有返回值的方法
     * 1. void 修改成一种数据类型(你想要得到的是什么数据，那么就定义成该种数据的类型)
     * 2. 该方法必须使用return 返回该数据类型的一个具体值
     * 3. 在调用此方法时，必须使用该数据类型的变量 接受这个值
     * 4. 如果一个方法中，已经执行了return关键字，那么程序就不再往下执行了
     */
    public static int sum(int n, int n2) {
        int sum = n+n2;
        return sum;
    }
    
    /*
     * 定义一个方法，参数为两个整数，返回最大的值
     */
    public static int max(int n, int n2) {
        //int max=n>n2?n:n2;
        //return max;
        if(n > n2) {
            return n;
        } 
        
        return n2;
    }
    
}

5.方法名命名规范

• 方法名是由数字，字母，下划线，美元符组成（不推荐使用汉字）

  • 不能以数字开头

• 首字母小写

• 见闻知意

  • 使用英语翻译（一定不要使用汉语拼音）

• 驼峰法

  • 除了第一个单词的首字母小写，后面每个单词的首字母都大写

• 不能使用java关键字

6.实例代码

//定义方法，有一个参数n,返回1+2+3+4......n
class Text{
    public static void main(String[] args) {
        
        System.out.println(sum(10));
    }
    
    public static int sum(int n ) {
        int sum=0;
        for(int i=1;i<=n;i++) {
            sum+=i;
        }
        return sum;
    }
}
​
​
//定义方法，有一个参数n，返回n!  (1*2*3**....n)
class Text2{
    public static void main(String[] args) {
        
        System.out.println(sum(10));
    }
    
    public static double sum(int n ) {
        double sum=1;
        for(int i=1;i<=n;i++) {
            sum*=i;
        }
        return sum;
    }
}

7.递归

递归方法就是自己调用自己，然后有一个程序的出口

​
//用递归的方法    定义方法，有一个参数n，返回n!  (1*2*3**....n)
class Text3{
    public static void main(String[] args) {
        
        System.out.println(factorial(10));
    }
​
    /*
     * factorial(n) = factorial(n-1)*n
     * 
     * factorial(100) = factorial(99)*100
     * factorial(99) = factorial(98)*99
     * ...
     * factorial(3) = factorial(2)*3
     * factorial(2) = factorial(1)*2
     * 
     * factorial(1) = 1
     * 
     * factorial(100)= 1*2*3*....*98*99*100
     */
​
    public static double factorial(int n ) {
        if(n==1) {
            return 1;
        }
        return factorial(n-1)*n;
    }
}
//用递归的方法    定义方法，有一个参数n，返回1+2+3+4+5+6....+n
class Text3_1{
    public static void main(String[] args) {
        
        int sum = sum(100);
        System.out.println(sum);
​
    }
    /*
     * sum(100) = sum(99)+100
     * sum(99) = sum(98)+99
     * ...
     * sum(3) = sum(2)+3
     * sum(2) = sum(1)+2
     * 
     * sum(1) = 1
     * 
     * 
     * sum(100)=sum(99)+100
     */
    public static int sum(int n) {
        if (n ==1) {
            return 1;
        }
        
        return sum(n-1)+n;
    }
​
}
​

8.斐波那契数列

package com.qfedu;
​
public class Demo07 {
​
    /*
     * 斐波那契数列
     *  0 1 1 2 3 5 8 13 21 34 55
     * 
     * m是个方法，返回第n个数的值   n是个参数，代表第几个值
     *  m(n) = m(n-1)+m(n-2)     n>=3
     *  1                        n=2
     *  0                        n=1
     */
    public static int fibonacci(int n) {
        if(n ==1) {
            return 0;
        } else if(n ==2) {
            return 1;
        }
        
        return fibonacci(n-1)+fibonacci(n-2);
    }
    
}