Java方法

方法

方法概述

在java中，方法就是用来完成解决某件事情或实现某个功能的办法。
方法实现的过程中，会包含很多条语句用于完成某些有意义的功能——通常是处理文本，控制输入或计算数值。
我们可以通过在程序代码中引用方法名称和所需的参数，实现在该程序中执行（或称调用）该方法。方法，一般都有一个返回值，用来作为事情的处理结果。
定义方法就是编写有特定功能的一段代码，在程序中使用同样功能的地方可以调用定义好的方法，实现代码的复用。

方法的语法格式

在Java中，声明一个方法的具体语法格式如下：

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．){
执行语句
………
return 返回值;
}

对于上面的语法格式中具体说明如下：

• 修饰符：方法的修饰符比较多，有对访问权限进行限定的，有静态修饰符static，还有最终修饰符final等，这些修饰符在后面的学习过程中会逐步介绍
• 返回值类型：用于限定方法返回值的数据类型
• 参数类型：用于限定调用方法时传入参数的数据类型
• 参数名：是一个变量，用于接收调用方法时传入的数据
• return关键字：用于结束方法以及返回方法指定类型的值
• 返回值：被return语句返回的值，该值会返回给调用者

需要特别注意的是，方法中的“参数类型 参数名1，参数类型 参数名2”被称作参数列表，它用于描述方法在被调用时需要接收的参数，如果方法不需要接收任何参数，则参数列表为空，即()内不写任何内容。方法的返回值必须为方法声明的返回值类型，如果方法中没有返回值，返回值类型要声明为void，此时，方法中return语句可以省略。

接下来通过一个案例来演示方法的定义与使用，如下图所示。MethodDemo01.java

public class MethodDemo01 {
	public static void main(String[] args) {
		int area = getArea(3, 5); // 调用 getArea方法
		System.out.println(" The area is " + area);
	}
}
// 下面定义了一个求矩形面积的方法，接收两个参数，其中x为高，y为宽
public static int getArea(int x, int y) {
	int temp = x * y; // 使用变量temp记住运算结果
	return temp; // 将变量temp的值返回
}
 //输出： The area is 15

在上述代码中，定义了一个getArea()方法用于求矩形的面积，参数x和y分别用于接收调用方法时传入的高和宽，return语句用于返回计算所得的面积。在main()方法中通过调用getArea()方法，获得矩形的面积，并将结果打印。

方法的分类

1. 根据参数的个数：有参方法、无参方法
   
2. 根据返回值的类型：
   有返回值：基本数据类型和引用数据类型
   无返回值的方法：void关键字

分别定义如下方法：

/*定义无返回值无参数方法，如打印3行，每行3个*号的矩形
定义有返回值无参数方法，如键盘录入得到一个整数
定义无返回值有参数方法，如打印指定M行，每行N个*号的矩形
定义有返回值有参数方法，如求三个数的平均值*/

//l 无返回值无参数方法，如打印3行，每行3个*号的矩形
public static void printRect(){
	for (int i=0; i<3; i++) {	//打印3行星
		for (int j=0; j<3; j++) {	//每行打印3颗星
			System.out.print("*");  // ***
		}	
	System.out.println();
	}
}

//l 有返回值无参数方法，如键盘录入得到一个整数
public static int getNumber(){
	Scanner sc = new Scanner(System.in);
	int number = sc.nextInt();
	return number;
}

//l 无返回值有参数方法，如打印指定M行，每行N个*号的矩形

public static void printRect2(int m, int n){
	for (int i=0; i<m; i++) {	//打印M行星
		for (int j=0; j<n; j++) {//每行中打印N颗星
			System.out.print("*");  
		}
	System.out.println();
	}
}

//l 有返回值有参数方法，如求三个数的平均值
public static double getAvg(double a, double b, double c) {
	double result = (a+b+c)/3;
	return result;
}

3. 方法的调用
   在方法的入口传一些值（参数），在方法的出口得到方法执行的结果（返回值）。
   1、静态和非静态之间的调用
   - 方法调用都可以先实例化类名后，再用类的实例名(对象).方法名进行调用。
   - 只有在同一类型的方法且在同一类中，才能直接调用方法名。
   - 类名.方法名进行调用只能使用在调用静态方法中。
   2、方法调用的分类：
   (1)按照参数：
   无参方法的调用
   
   有参方法的调用: 给方法的入口一些值(实参)，供参,实参和形参的数量,类型,顺序必须匹配,实参可以是常量也可以是有值的变量.

  //有参无返回值代码实现： 
public class FunctionDemo {
     public static void show(int x,int y ) {
            System.out.println(x+y);
     }
     public static void main(String[] args) {
               show(2,3);
      }
}

(2)按照返回值
无返回值方法与有返回值方法的调用
有参有返回值代码实现：可以声明同类型变量接受方法的返回值，也可以不声明变量接收方法的返回值

public class FunctionDemo {
      public static int show(int x,int y ) {
              return x+y;
      }
      public static void main(String[] args) {
               int a = show(2,3);
               show(2,3);
       }
}

(3)方法注意问题：

• 形参必须注明数据类型，实参直接写，不需要类型声明
• return只能返回一次
• 遇到return语句，方法结束执行，后续语句不执行；
• 方法的返回值，必须与方法中的返回值类型相匹配;
• 方法定义不能写在main中；
• 方法是不能嵌套的；

方法的参数传递机制

方法的参数分为两种：形参和实参。形参代表方法定义上的，用于接收实际参数的参数。实参代表实际参与运算的参数。
Java中方法的参数传递都是通过值传递实现的，所谓值传递，就是将实际参数值的副本传入方法内，而参数本身不会受到任何影响。例子如下

//a,b交换值的例子，但是这个只是值传递，a和b的值不会变
public class fun {
    public static void main(String[] args) {
        int a = 3,b = 4;
        fun1(a,b);                               //实参
        System.out.println(a+"+++++"+b);  
    }
        //类中的方法都用public static为前缀
        public static void fun1(int a,int b){    //形参
        int temp;
        temp = a;
        a = b;
        b = temp;
        System.out.println(a+"========"+b);
    }
}

//输出结果为:
4========3
3+++++4

参数传递图解与结论

形参个数可变的方法

形参个数可变表示允许为方法指定数量不确定的形参。如果在方法定义时，在最后一个形参的类型后加三个点(…)，则表明该形参可以接受多个参数值，多个参数值被当成数组传入。例子如下：

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

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

public class fun {
    public static void main(String[] args) {
        fun1(4,"abc","dsa","bfd");
    }
    public static void fun1(int a,String... books){ //这里面的String... books相当于String[] books
        for(String book:books){
            System.out.println(book);
        }
        System.out.println(a);
    }
}

但是形参个数可变的这个方法要求，个数可变的形参只能处于形参列表的最后位置，即一个方法中最多只能有一个个数可变的形参。

方法的重载

在Java方法的执行过程中，重载的概念是相当重要的。Java允许同一个类中定义多个同名的方法，只要形参列表不同即可。如果同一个类中包含了两个或两个以上的方法名相同，但是形参列表不同(与返回值类型无关)，我们则成为方法重载。
所谓的重载就是要求两同一不同：同一个类中方法名相同，参数列表不同。对于方法其他部分(返回值类型，修饰符等)与重载没有任何关系。
参数列表不同包括：A:参数个数不同。B:参数类型不同。C:参数的顺序不同(算重载,但是在开发中不用)

方法重载的规则：

• 方法的名称相同
• 方法的参数必须不同：参数个数不同或者参数的类型不同,参数的类型顺序不同。
• 方法的返回值可以相同，也可以不同
  下面例子中演示了类中方法的重载：

public class fun {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        String c = "abc";
        fun1(a);
        fun1(a,b);
        fun1(a,c);
    }
    public static void fun1(int a){
        System.out.println(a);
    }
    public static void fun1(int a,int b){
        System.out.println(a+"==="+b);
    }
    public static void fun1(int a,String b){
        System.out.println(a+"==="+b);
    }
}

//最终结果
1
1===2
1===abc

重写

在java中有很多的继承，继承下来的有变量、方法。在有一些子类要实现的方法中，方法名、传的参数、返回值跟父类中的方法一样，但具体实现又跟父类的不一样，这时候我们就需要重写父类的方法，就比如我们有一个类叫做Animals，Animals类中有一个叫做Call,然后我们继承Animals又生成了Cat类和Dog类，Cat和Dog也分别有自己特别的叫声，程序如下：

class Animals {
    public void call() {
        System.out.println("啊啊啊啊啊啊啊");
    }
}

public class Cat extends Animals {
    @Override
    public void call() {
        System.out.println("喵喵喵喵喵");
    }
}

public class Dog extends Animals {
    @Override
    public void call() {
        System.out.println("汪汪汪汪汪汪");
    }
    public static void main(String[] args) {
        Animals animals = new Animals();
        animals.call();

        Cat cat = new Cat();
        cat.call();

        Dog dog = new Dog();
        dog.call();
    }

}

总结

• 重写是外壳不变，核心变。也就是说方法名不变，参数不变，具体实现可以改变。一般是在父类中声明方法，在子类中重写。
• 重载是方法名不变，但参数一定要变。而且重载的方法一般都写在一个类中。用一张图来表示区别如下：