【从零开始的Java开发】1-2-4 Java方法

方法

所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。
方法声明

方法分类

• 无参无返回值方法
• 无参有返回值方法
• 带参无返回值方法
• 带参有返回值方法

无参无返回值的方法
想要这个：

***************************
Hello World!
***************************

写的方法：

package com.t1.method;

public class myMethod {
	public void printStar() {
		System.out.println("***************************");
	}

	public static void main(String[] args) {
		//创建一个myMethod类的对象myMethod1
		myMethod myMethod1=new myMethod();
		//调用这个myMethod1对象的printStar方法：
		//使用对象名.方法名()去调用这个方法
		myMethod1.printStar();
		System.out.println("Hello World!");
		myMethod1.printStar();

	}

}

无参带返回值的方法

package com.t1.method;

public class Rectangle {

	public int area() {
		int a = 10, b = 20;
		int area = a * b;
		return area;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Rectangle myRectangle = new Rectangle();
		System.out.println("长方形面积为：" + myRectangle.area());

	}

}

带参无返回值的方法
目的：定义一个求两个float类型数据最大值的方法，在方法中将最大值打印输出。

public void max(float a,float b){}

代码：

package com.t1.method;

public class MaxDemo {

	public void Max(float a, float b) {
		float max;//变量名其实可以和方法名同名
		if (a > b)
			max = a;
		else
			max = b;

		System.out.println("ab两个数的最大值为" + max);
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MaxDemo max1 = new MaxDemo();
		max1.Max(6.2f, 7.44f);
	}

}

带参有返回值的方法
目的：定义一个求n！的方法，然后再求1!+2!+3!+4!+5!;

public int fac(int n){}

代码：

package com.t1.method;

public class facDemo {

	public int fac(int x) {
		int ans = 1;
		for (int i = 1; i <= x; i++) {
			ans *= i;
		}
		return ans;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		facDemo facDemo1 = new facDemo();
		int ans = 0;
		for (int i = 1; i <= 5; i++) {
			ans += facDemo1.fac(i);
		}

		System.out.println(ans);
	}

}

数组作为方法参数

要求1：定义方法，打印输出数组元素的值。

public void printArray(int[] arr){}

代码：

package com.t1.method;

public class Arr {

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

	public static void main(String[] args) {
		int[] arr = { 10, 20, 30, 40, 50 };
		Arr arr1 = new Arr();
		arr1.printarr(arr);

	}
}

要求2：查找数组元素的值
方法参数：数组、要查找的值
返回值：boolean

代码：

package com.t1.method;

public class findValue {

	public boolean find(int n, int[] a) {
		for (int i = 0; i < a.length; i++) {
			if (a[i] == n)
				return true;
		}
		return false;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		findValue find1 = new findValue();
		int[] a = { 1, 2, 3, 4, 5, 6 };
		boolean flag = find1.find(1, a);
		if (flag == true)
			System.out.println("找到了");
		else
			System.out.println("没找到");
	}

}

方法重载

方法名相同，方法参数不同。

跟第一个相比，哪个是重载的方法？

答：
3、4、5都是重载的方法。因为方法名相同，参数列表不同。
第2个参数列表相同，第6个方法名不同。所以都不是重载的方法。

代码的练习：
定义三个方法，实现int、double、和数组类型和的问题。

代码：

package com.t1.method;

public class Add {

	public int add(int n, int m) {
		return n + m;
	}

	public double add(double m, double n) {
		return n + m;
	}

	public int add(int[] a) {
		int ans = 0;
		for (int i = 0; i < a.length; i++) {
			ans += a[i];
		}
		return ans;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Add add1 = new Add();
		System.out.println("int的和" + add1.add(1, 2));
		System.out.println("double的和" + add1.add(2.3, 4.4));
		int a[] = { 1, 2, 3, 4, 5, 6 };
		System.out.println("数组的和" + add1.add(a));
	}

}

基本数据类型的传值

package com.t1.method;

public class swapp {

	public void swap(int a, int b) {
		int temp = a;
		System.out.println("交换前a=" + a + " b=" + b);
		a = b;
		b = temp;
		System.out.println("交换后a=" + a + " b=" + b);
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int n = 1, m = 2;
		System.out.println("交换前n=" + n + " m=" + m);
		swapp swap1 = new swapp();
		swap1.swap(n, m);
		System.out.println("交换后n=" + n + " m=" + m);
	}

}

输出：

交换前n=1 m=2
交换前a=1 b=2
交换后a=2 b=1
交换后n=1 m=2

由此可知，交换的只是a，b，而不是n，m。
且n，m只是传值给了a，b，而不是它们自己的地址。

注意：只有在主方法中调用函数需要写对象名，在其他方法中不用写对象名
如：

package com.t1.method;

public class swapp {

	public void swap(int a, int b) {
		int temp = a;
		System.out.println("交换前a=" + a + " b=" + b);
		a = b;
		b = temp;
		System.out.println("交换后a=" + a + " b=" + b);
	}

	public void test() {
		int n = 1, m = 2;
		System.out.println("交换前n=" + n + " m=" + m);
		//这里没有通过对象调用方法，而是直接调用的
		swap(n, m);
		System.out.println("交换后n=" + n + " m=" + m);
	}

	public static void main(String[] args) {
		swapp swap1 = new swapp();
		//主方法中需要通过对象调用方法
		swap1.test();
	}

}

输出：跟之前是一样的。

交换前n=1 m=2
交换前a=1 b=2
交换后a=2 b=1
交换后n=1 m=2

如果在方法中对参数进行了更改，那么出了方法后，值不变：

数组的传值（引用数据类型）

package com.t1.method;

public class updateArr {

	public void printArr(int[] a) {
		for (int n : a) {
			System.out.print(n + " ");
		}
		System.out.println();
	}

	public void update(int[] a) {
		a[0] = 1;
		System.out.println("更改中：");
		printArr(a);
	}

	public static void main(String[] args) {
		int[] a = { 6, 6, 6, 6, 6 };
		System.out.println("更改前：");
		updateArr updateArr1 = new updateArr();
		updateArr1.printArr(a);
		updateArr1.update(a);
		System.out.println("更改后：");
		updateArr1.printArr(a);

	}
}

输出：

更改前：
6 6 6 6 6 
更改中：
1 6 6 6 6 
更改后：
1 6 6 6 6 

数组在方法中改变值，在主方法中值也会改变。

原因是：
我们定义了一个数组{6,6,6,6,6}，就是在内存中开辟了一个连续的一份空间，里面填了{6,6,6,6,6}。其中a就指向了数组的第一个元素，也就是说，a是一个地址。
我们在调用方法时传的是a(地址)，则会直接对内存中的值进行修改了，所以会变化。

可变参数列表

格式如：

public void sum(int... n)//我直接类比C++的vector<int>n

写一个参数为int…的求和代码：

package com.t1.method;

public class ArgsDemo {

	public void sum(int... n) {
		int ans = 0;
		for (int i : n) {
			ans += i;
		}
		System.out.println("sum=" + ans);
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArgsDemo a1 = new ArgsDemo();
		a1.sum(1, 2, 3);
		a1.sum(1, 2, 3, 4);
		a1.sum(1, 2, 3, 4, 5);
	}

}

输出：

sum=6
sum=10
sum=15

一个参数包含int…n的查找代码：

package com.t1.method;

public class ArgsDemo {

	public boolean find(int a, int... n) {
		for (int i : n) {
			if (i == a)
				return true;
		}
		return false;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArgsDemo a1 = new ArgsDemo();
		boolean flag;
		int[] n = { 1, 2, 3, 4, 5 };
		flag = a1.find(0, n);
		if (flag)
			System.out.println("找到了");
		else
			System.out.println("没找到");

		int[] n1 = { 1, 2, 3, 4, 6, 6, 6 };
		flag = a1.find(2, n1);
		if (flag)
			System.out.println("找到了");
		else
			System.out.println("没找到");
	}

}

输出：

没找到
找到了

注意：
可以把数组传给可变参数列表，但不能把可变参数列表传给数组
如：数组传给可变参数列表

public boolean find(int a, int... n);//这是find函数
find(1,arr1);//这样传值，可以——数组传给可变参数列表

可变参数列表传给数组

public boolean find(int a, int[]n);//这是find函数
find(1,2,3,4,5);//这样传值，不可以——可变参数列表传给数组

一个方法中只能由一个可变参数列表，且要放在参数的末尾

可变参数列表作为方法参数的重载

可变参数列表所在的方法是最后被访问的

如代码：

package com.t1.method;

public class Add {

	public int add(int n, int m) {
		System.out.println("不带可变参数列表的方法调用！");
		return n + m;
	}

	public int add(int... n) {
		int ans = 0;
		for (int i : n) {
			ans += i;
		}
		System.out.println("带可变参数列表的方法调用！");
		return ans;
	}

	public static void main(String[] args) {
		Add add1 = new Add();
		int ans = add1.add(1, 2);
		System.out.println(ans);
	}

}

输出：

不带可变参数列表的方法调用！
3

文档注释

可生成的帮助文档文档注释
/**再回车：

@后会出现很多参数：

文档注释如何生成帮助文档？通过Java的doc命令从文档注释中提取内容，生成程序的API帮助文档。
命令如下：

javadoc -d doc 文件名.java

我们查看index.html文件即可。

方法的调试

F5可以跳到方法内部执行。
F6可以在调试中看下一步（单步调试）。
F7由方法内部返回调用处。

细节与总结

方法的语法格式

访问修饰符 返回类型 方法名(参数列表)
{
	方法体
}

访问修饰符：

• public
• private
• protected
• 啥都不写

也可以写其他修饰符，如static.
方法调用

创建对象：

Demo d=new Demo();
类名 对象名=new 类名();

调用方法：

d.show();
对象名.方法名();

只有在主方法中调用函数需要写对象名，在其他方法中不用写对象名
方法重载
方法名相同，方法参数不同。

可变参数列表
可变参数一定是方法中的最后一个参数
数组可以传递给可变参数的方法，反之不行
在重载中，含有可变参数的方法是最后被调用的

方法的传值问题

• 基本数据类型传值：方法中对参数的修改不会改变主方法中的变量
• 引用数据类型传值：会改变，如数组。

参数为数组是引用，因为传的是地址。