前言

  本文对Java中的基本内容方法进行定义介绍以及使用方法的介绍。

1 方法的定义和调用

方法的定义

1. 方法(method)就是一段用来完成特定功能的代码片段，是类和对象行为的抽象。
2. 面向过程中，函数（也就是方法）是最基本单位，整个程序由一个个函数调用组成。面向对象中，类是基本单位，方法是从属于类和对象的。

声明方式：

[修饰符1  修饰符2  …]  返回值类型    方法名(形式参数列表){
        Java语句；… … …
        [return 方法返回值]
}
1
2
3
4

说明：
（1） 修饰符: public/protected/private static
（2） 返回值类型 : 方法的返回值对应的数据类型
  数据类型： 可以没有没有就写void，也可以是基本数据类型（byte,short,int,long,float,double,char,boolean） 也可以是引用数据类型
（3） 方法名 :见名知意，首字母小写，其余遵循驼峰命名， eg: addNum ,一般尽量使用英文来命名
（4） 形式参数列表 : 方法定义的时候需要的形式参数 ： int num1, int num2 -->相当于告诉方法的调用者：需要传入几个参数，需要传入的参数的类型
实际参数：方法调用的时候传入的具体的参数： 10,20 -->根据形式参数的需要传入的
（5） 方法体：具体的业务逻辑代码
（6） return 方法返回值;
方法如果有返回值的话： return+方法返回值，将返回值返回到方法的调用处
方法没有返回值的话：return可以省略不写了，并且方法的返回值类型为：

方法的调用方式

对象名.方法名(实参列表)
1

代码实例: 写一个具有加法功能的方法

/**
 * 写一个具有加法功能的方法
 */
public class demo1 {
    //方法的定义：（写方法）
    public static int add(int num1,int num2){
        int sum = 0;
        sum += num1;
        sum += num2;
        return sum;//将返回值返回到方法的调用处
    }

    public static void main(String[] args){
        //30+90:
        int sum = add(30,90);
        System.out.println(sum);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

注意：

1. 方法和方法是并列的关系，所以我们定义的方法不能写到main方法中
2. 方法的作用：提高代码的复用性

面试题：请问下面代码中两个数是否交换成功？

public class Test{
        public static void main(String[] args){
                int a=10;
                int b=20;
                System.out.println("输出交换前的两个数："+a+"---"+b);
                changeNum(a,b);
                System.out.println("输出交换后的两个数："+a+"---"+b);
        }
        public static void changeNum(int num1,int num2){
                int t;
                t=num1;
                num1=num2;
                num2=t;
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

  结果是没有交换成功。原因如下：

2 方法的重载

定义

方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会根据不同的参数自动匹配对应的方法。（本质上重载的方法，实际是完全不同的方法，只是名称相同而已！）

构成方法重载的条件

形参类型、形参个数、形参顺序不同（注意：返回值和修饰符不同不会构成重载）

代码实例：下面a方法不构成重载

int  a(String str){  
} 
void a(String str){  
}
1
2
3
4

代码实例：加法的重载

/**
 * 重载
 */
public class demo2 {
    public static void main(String[] args){
        //10+20:
        int sum = add(10,20);
        System.out.println(sum);
        //20+40+80:
        System.out.println(add(20,40,80));
        //30+60+90+120:
        System.out.println(add(30,60,90,120));
        //9.8+4.7:
        //System.out.println(add(9.8,4.7));
        System.out.println(add(9.8,4.7));
    }
    //定义一个方法：两个数相加：两个int类型数据相加
    public static int add(int num1,int num2){
        return num1+num2;
    }
    //定义一个方法：三个数相加：
    public static int add(int num1,int num2,int num3){
        return num1+num2+num3;
    }
    //定义一个方法：四个数相加：
    public static int add(int num1,int num2,int num3,int num4){
        return num1+num2+num3+num4;
    }
    //定义一个方法：两个数相加：两个double类型的数据相加
    public static double add(double num1,double num2){
        return num1+num2;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

代码实例：如果参数数量一致，但是参数类型不同但是是同一类，那么调用的时候会使用类型优先级最高的方法

/**
 * 重载的优先级
 */
public class demo3 {
    public static void main(String[] args){
        add(5);//因为是5是整数，所以优先int
        //级别：byte,short,char-->int-->long-->float--->double
    }

    public static void add(double num1){
        System.out.println("------2");
    }
    public static void add(float num1){
        System.out.println("------3");
    }
    public static void add(long num1){
        System.out.println("------4");
    }
    /*
    public static void add(int num1){
            System.out.println("------1");
    }
    */
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

3 main方法

main方法的定义：程序的入口，在同一个类中，如果有多个方法，那么虚拟机就会识别main方法，从这个方法作为程序的入口。

语法格式 ：main方法格式严格要求：

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

小问题：形参为String[] 那么实参到底是什么？

在运行某个class字节码文件时可以在后面加上想要输入的参数，然后这个参数就可以通过main进入到方法里面

public class TestArray10{
    public static void main(String[] args){
                //System.out.println(args.length);//0
                //从这个结果证明，参数是String[],实参是  new String[0] 
                //默认情况下，虚拟机在调用main方法的时候就是传入了一个长度为0的数组
                System.out.println(args.length);
                for(String str:args){
                        System.out.println(str);
                }
        }
}
1
2
3
4
5
6
7
8
9
10
11

4 可变参数的方法定义

可变参数定义和语法

可变参数作用是指提供了一个方法，参数的个数是可变的，解决了部分方法的重载问题。语法结构如下：

 int...num
 double...num
 boolean...num
1
2
3

特点

1. 方法的内部对可变参数的处理跟数组是一样的
2. 可变参数和其他数据一起作为形参的时候，可变参数一定要放在最后
   代码实例：

/**
 * 可变参数的方法定义
 */
public class demo4 {
    public static void main(String[] args){
        // method01(10);
        // method01();
        // method01(20,30,40);
        method01(30,40,50,60,70);
    }
    public static void method01(int num2,int...num){
        System.out.println("-----1");
        for(int i:num){
            System.out.print(i+"\t");
        }
        System.out.println();
        System.out.println(num2);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20