java方法的定义及使用

方法

一、方法（函数）概述

函数是定义在类中的一段独立的代码块，用来实现某个功能。Java中，函数又被称为方法。

函数的主要作用是为了提高代码的复用性。

函数都是在栈内存中运行；运行的函数处在栈顶。

函数格式：修饰符 返回值类型 函数名 （ [ 参数类型1 参数名1,参数类型2 参数名2… ] ）{

               //   [    ]    里面表示可选项，即参数不是必须的

               执行语句...

               return  返回值；    //返回值的类型必须与返回值类型一致

                }

说明:

• 修饰符：可以是访问修饰符，也可以说是函数修饰符（abstract、final、 static、synchronized），还可以是两者的组合。
• 返回值类型：用于限定函数返回值的数据类型。
• 参数类型：用于限定调用函数时传递的数据类型。
• 参数名：是一个变量，用来接收调用方法时传递的数据。
• return：用来接收方法以及返回函数指定类型的值。
• 返回值：这个值会返回给函数的调用者。

示例：

        public class method {
            /*
             * 程序入口,主函数 .
             * 
             * @ 方法 <==> 函数,指的是同一个东西.
             */
            public static void main(String[] args) {
            // 通过函数名调用
            method01();

            method02(9, 3);
            System.out.println("5+6=" + add(5, 6));
            }

            /*
             * @ 函数的格式为：
             * 
             * @ 访问修饰符 返回值类型 函数名(参数类型1 参数名1,参数类型2 参数名2....){
             * 
             * @ 执行语句
             * 
             * @ return 返回值;//返回值的类型必须与返回值类型一致
             * 
             * @ }
             */
            /*
             * @ 声明一个静态函数method01() 无参数无返回值
             */
            static void method01() {
            System.out.println("这是method01方法,可以通过method01();调用.");
            // 这个return可以省略.每个函数都是以return结束,返回到函数调用处
            return;
            }

            /*
             * 有参数无返回值
             */
            static void method02(int num1, int num2) {
            method01();
            System.out.println("这是method02方法,第一个参数是" + num1 + "第二个参数是" + num2);
            }

            /*
             * 有返回值的返回值类型要和要返回的数据类型一致
             * 
             * @ 例如：计算两个整数的和,结果仍然是整型,返回值类型为int.返回值类型可以说基本数据类型，也可是自定义的数据类型
             */
            static int add(int num1, int num2) {
            int sum = 0; // 声明一个整形变量并初始化为0
            sum = num1 + num2;// 将num1和num2的和赋值给sum
            return sum;// 将sum的值返回到调用处
            }

        }

二、方法的调用

1、方法调用

• 方法只有在被调用后才生效

• 方法的调用方法：

  • 无参方法的调用
  • 有参方法的调用

• 使用方法时的注意问题

  • 形参必须注明数据类型

  • 实参直接写，不需要类型声明

  • return只能返回一次

  • 遇到return语句，方法结束执行，后续语句不执行

  • 方法的返回值，必须与方法声明中的返回值类型匹配

  • 方法定义，不能写在main()中

  • 方法是不能嵌套的

示例：

        package net.tencent.demo.test;

        public class Test方法的调用 {

            /**
             * 方法的调用分两种情况：
             * 
             * 1：static修饰的方法：  类名.方法名(实际参数)
             * 2. 非static修饰的方法：
             * ①先把方法所在的类实例化： Test方法的定义 t=new Test方法的定义();
             * ②然后调用：    t.isPrime2(17);//对象名.方法名(实际参数)
             * 
             * 3.没有返回值的方法：
             * 
             * 注意：方法调用完不要声明变量接收方法的返回值即可，因为没有返回值
             * 
             */

            public static void main(String[] args) {
                //1.判断213是不是质数

                 boolean result=Test方法的定义.isPrime(17);

                 System.out.println(result);

                 //2.求出23和34 的和
                 int tmp=Test方法的定义.sum(23, 34);
                 System.out.println(tmp);

                 //3.判断17是不是质数，要求调用非static修饰的isPrime方法
                 Test方法的定义 t=new Test方法的定义();
                 boolean result2=t.isPrime2(17);
                 System.out.println("17是质数吗："+result2);

                  //4.调用没有返回值的方法
                 Test方法的定义.printName("telangpu");
            }

        }

2、参数传递

参数传递，可以理解当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数，这样方法中的参数就拥有了这个指定的值，可以使用该值，在方法中运算了。这种传递方式，我们称为参数传递。

在这里，定义方法时，参数列表中的变量，我们称为形式参数

调用方法时，传入给方法的数值，我们称为实际参数

我们看下面的两段代码，来明确下参数传递的过程：

public class ArgumentsDemo01 { 
    public static void main(String[] args) { 
        int a=5; 
        int b=10; 
        change(a, b);//调用方法时，传入的数值称为实际参数 
        System.out.println("a=" + a); 
        System.out.println("b=" + b); }
    public static void change(int a, int b){//方法中指定的多个参数称为形式参数 
        a=200; 
        b=500; 
    } 
} 

再看另一段代码

        public class ArgumentsDemo02 { 
            public static void main(String[] args) { 
                int[] arr = { 1, 2, 3 }; 
                change(arr);// 调用方法时，传入的数值称为实际参数

                for (int i = 0; i < arr.length; i++) { 
                    System.out.println(arr[i]); 
                } 
            }

            public static void change(int[] arr) {//方法中指定的多个参数称为形式参数
                for (int i = 0; i < arr.length; i++) { 
                    arr[i] *= 2; 
                } 
            } 
        }

通过上面的两段程序可以得出如下结论：

• 当调用方法时，如果传入的数值为基本数据类型（包含String类型），形式参数的改变对实际参数不影响

• 当调用方法时，如果传入的数值为引用数据类型（String类型除外），形式参数的改变对实际参数有影响

三、方法的重载

• 方法的重载就是在同一个类中允许同时存在一个以上同名的方法
• 方法重载的规则
  • 方法名称相同
  • 方法的参数必须不同
    • 参数个数不同
    • 参数类型不同
    • 返回值类型可以相同，也可以不同

        package net.tencent.demo.test;

        public class Test方法的重载 {
            /*
             * 方法的重载就是在同一个类中允许同时存在一个以上同名的方法
             * 这种情况的出现是有条件的：
             * 
             * 1.方法名相同
             * 2.一个不同，方法的参数必须不同：参数个数不同  or 参数类型不同
             */
            public void add(int a)
            {

            }

            public void add(double b)
            {

            }

            public void add(float f)
            {

            }

            public void add(int a,int f)
            {

            }

            public int add(int c,int d,int e)
            {
                //Arrays.to
                return 0;
            }
        }

四、函数的递归

函数的递归是指在一个函数的内部调用自身的过程。

递归必须要有结束条件，不然就是陷入无限递归的状态，永远无法结束函数的调用。

示例：

        public class Di_gui_easy {

            public static void main(String[] args) {

            int sum = sum(50);// 利用递归求1~50的和
            System.out.println("1+2+3+4+....+47+38+49+50=" + sum);
            }

            // 利用递归求累加值
            private static int sum(int i) {

            if (i == 1) {
                return 1;
            }

            return i + sum(i - 1);
            }
        }