Java05-方法定义与调用

方法定义与调用内容导航

1 方法的声明
  1.1 方法的定义
  1.2 方法的分类
    1.2.1 无参方法
    1.2.2 有参方法
    1.2.3 无返回值方法
    1.2.4 有返回值方法
    1.2.5 基本数据类型与引用数据类型的区别
2 方法的调用
  2.1 调用定义
  2.2 递归调用方法
3 方法的重载
4 练习

1.方法的声明

1.1方法的定义

  方法声明，又叫定义方法，指编写一段有特定功能的代码，在程序中使用时调用定义好的方法即可。可以实现代码的重用，简化程序编写和维护工作。
  方法的结构为：
修饰符号 返回值类型 方法名称(参数类型1 形式参数1,…){
    方法的主体;
    返回值;
}
  在方法定义时，如果声明返回值类型，则必须在方法体中使用return语句返回一个类型匹配的值。如果方法存在多个分支，则每个分支都需要使用return返回一个值。
  例1：计算两个整数进行加法计算，并返回和。
Ans：

public int add(int a,int b){
			if(a==0 && b==0){
			return 0;
		}else{
			int c = a+b;
			return c;
		}

  当方法内部需要返回不同值时，可以使用多个return语句，在不同情况下返回不同值，也可以根据不同情况，修改统一的返回值变量；再在方法的后面使用同一个return语句返回变量值。
  例2：计算两个整数进行加法计算，并返回和。
Ans：

public int add(int a,int b){
		int ret = 0;
		if(a==0 && b==0){
			ret= -1;
		}else{
			ret = a+b;
		}
		return ret;
	}

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

1.2 方法的分类

1.2.1 无参方法

  无参方法是指方法名称后没有参数，格式为：方法名()。
例：

private void printColor(){
		System.out.print("nono");
	}

1.2.2 有参方法
  有参方法时指方法名称后有参数，格式为：方法名(参数类型 形式参数,参数类型 形式参数…)。
  有参方法的参数类型可分为基本数据类型和引用数据类型。
  基本数据类型有：byte , short, int, long, float, double, char, long。
  引用数据类型有：类，接口类型，数组类型，枚举类型，注解类型。
  例1：基本数据类型

public void change(int a){//参数是基本数据类型
		a = 12;
		System.out.print("in method "+a);
	}

  例2：引用数据类型

public void change(String str){//参数是一个对象类型，引用数据类型
		str = "in method";
		System.out.print(str+" ");
	}

1.2.3 无返回值方法
  方法执行后不向本方法外部返回任何值。声明方法返回类型的位置不能省略不写，返回类型使用void关键字。
例：

public static void printColor(char color){
		System.out.println(color);
	}

1.2.4 有返回值方法
  方法执行后向本方法外部返回数据值。使用return关键字，完成方法的返回值。遇到return语句，方法结束执行，后续语句不执行。因此在方法中，return语句只能执行一次。方法的返回值，必须与方法声明中的返回值类型匹配。
  return表示返回值和终止方法的执行。
例：

public static int add(int x,int y){
		int z=x+y;
		return z;
	}

1.2.5 基本数据类型与引用数据类型的区别
  a).存储形式差别
  基本数据类型在被创建时，在栈上给其划分一块内存，将数值直接存储在栈上；引用数据类型在被创建时，首先要在栈上给其引用分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。其中，压栈：把数据放入栈中；弹栈：把数据取出；栈结构：先进后出。
  b).调用方式差别
  基本数据类型是传值调用，传递的参数是参数的数据。方法内部对形参修改不影响方法外面。
  引用数据数据类型是传引用调用。①在方法内部对引用的修改，不影响方法外面；所谓的对引用进行修改就是使用赋值符号对形参进行赋值。②在方法内部对形参内部数据的修改，会影响方法外面；即对引用对象数据的修改会产生传递的效果。
① 修改数据内部数据，会影响实参数据值的情况，没有对数据数组重新赋值。即方法内部的修改会影响方法外面。
方法：

public void change(int[] array){//数组是一个引用数据类型
		array[0] = 9;
		for(int i : array){
			System.out.print(i+"\t");
		}
		System.out.println();
	}
调用：
int[] array = new int[]{1,2,3,4,5};
rp.change(array);
for(int k:array){
	System.out.print(k+"\t");
}
System.out.println();

  结果：9 2 3 4 5
② 修改数组的引用，不影响实参数据值情况，重新对数组进行赋值操作。即方法内部的修改不会影响方法外面。
方法：

public void change2(int[] array){
		array = new int[]{2,3,4,5,6};
		for(int i : array){
			System.out.print(i+"\t");
		}
		System.out.println();
	}

  调用:

array = new int[]{1,2,3,4,5};
rp.change2(array);
for(int k:array){
	System.out.print(k+"\t");
}
System.out.println();

  结果：1 2 3 4 5

2.方法的调用

2.1 调用定义

  方法调用，就是给方法的入口传入一些值（参数），然后在出口得到方法执行的结果（返回值）。注意：需要根据方法名称调用方法，方法只有在被调用后才生效。
  注意方法调用的理解：优先从子类中查询方法，调用跟子类最接近的方法。
  没有使用static修饰的方法称为实例方法，使用static修饰的方法称为类方法或静态方法。静态方法可以使用类名，方法名进行调用；实例方法必须通过实例对象进行调用。如果在同一个类中，可以省略类名，直接调用。
  static修饰的全局变量或常量可以通过类名进行调用，例：String sex = VariableClass.WOMEN;
  在定义方法时，参数列表上的参数称为形式参数，简称形参。形参是为了占位用，还不知道具体值。实际传递的参数叫实参.
  对象引用方法/调用方法或属性/实例变量的操作符号时点号(.)。
  例1:无参无返回值方法调用
package chap5.classroom;

public class Practice {
	public static void show(){
		System.out.println("hello");//方法声明
	}
	public static void main(String[] args) {
		show();//调用方法
		show();
 	}
}

  例2：有参无返回值方法调用

package chap5.classroom;
public class Practice {
	public static void show(int x,int y){
		System.out.println(x+y);//方法声明
	}
	public static void main(String[] args) {
		show(2,3);//调用方法
 	}
}

  例3：查找颜色
  方法：

private void printColor(String color,int count){
		for(int i=0;i<count;i++){
			System.out.println(color);
		}
	}

  调用：

public static void main(String[] args) {
		MethodsClass mClass = new MethodsClass();
		mClass.printColor("紫色");
	    mClass.printColor("蓝色",3);
		//静态方法可以使用类名，方法名进行调用
		MethodsClass.printColor('白');
		//如果在同一个类中，可以省略类名，直接调用
		printColor('蓝');
}

  mClass是一个实例变量的引用，经常把它称为实例对象。

2.2 递归调用方法

  递归调用是方法体内调用自己。方法递归包含了一种隐式循环，它会重复执行某段代码，但这种代码执行无须循环控制。
  递归调用时必须有终止条件，否则会产生死循环。
  例1：用递归方法，计算1~100的和
Ans：

package chap5.classroom;
public class Recursion {
		public static int sum(int num,int sum){
		sum+=num--;
		if(num==0){
			return sum;
		}else{
			return sum(num,sum);
		}
	}
	public static void main(String[] args) {
		int a = 100;
		int result = new Recursion().sum(a, 0);
		System.out.println(result);
	}

  例2：用递归方法，计算阶乘:n!
Ans：

package chap5.classroom;
public class Recursion {
	public static int factorial(int n,int sum){
		sum*=n--;
		if(n==1){
			return sum;
		}else{
			return factorial(n,sum);
		}
	}
	public static void main(String[] args) {
		int b = 3;
		int r = new Recursion().factorial(b,1);
		System.out.println(r);
	}
}

3.方法的重载

  方法的重载(overload)就是在同一个类中，方法名相同参数列表不同。（参数的个数不同，参数的类型不同,参数类型的顺序不一样），与访问修饰符和返回值类型无关。
  例：

public class MethodsClass {
	public int add(int a,int b){
		int ret = 0;
		if(a==0 && b==0){
			ret= -1;
		}else{
			ret = a+b;
		}
		return ret;
	}
	public static void printColor(char color){ 
		System.out.println(color);
	}
	private void printColor(){
		System.out.print("nono");
	}
	protected void printColor(String color){
		System.out.println(color);
	}
	private void printColor(int color){
		System.out.println(color);
	}
	public void printColor1(int count){
		System.out.println(count);
	}
	//访问修饰符号时是默认（default）的
	private void printColor(String color,int count){
		for(int i=0;i<count;i++){
			System.out.println(color);
		}
	}
	void printColor(int count,String color){
		for(int i=0;i<count;i++){
			System.out.println(color);
		}
	}
	public static void main(String[] args) {
		MethodsClass mClass = new MethodsClass();
		mClass.printColor("紫色");
		mClass.printColor("蓝色",3);
		MethodsClass.printColor('白');
		printColor('蓝');
		mClass.printColor(4,"红色");
		int a = 5;
		mClass.printColor(a);
	}
}

4.练习

1.编写一个方法，求整数n的阶乘，例如5的阶乘是12345。 [必做题].

package chap5;
public class Subject1 {
	public static int factorial(int n,int sum){
		sum*=n--;
		if(n==1){
			return sum;
		}else{
			return factorial(n, sum);
		}
	}
	public static void main(String[] args) {
		new Subject1();
		int b = 5;
		int r = Subject1.factorial(b, 1);
		System.out.println(r);
	}
}

2.编写一个方法，判断该年份是平年还是闰年。[必做题]

package chap5;
public class Subject2 {
	public static boolean leapYear(int n){
		if(n%4==0 && n%10!=0 || n%40==0){
			return true;
		}else {
			return false;
		}
	}
	public static void main(String[] args) {
		boolean b = leapYear(1890);
		System.out.println(b);
	}
}

3.编写一个方法，输出大于200的最小的质数。[选做题]

package chap5;
public class SubjectS1 {
	public static int isPrime(){
		boolean b = false;
		int i;
		int start = 201;
		int num = 201;
		while(b==false){
			int k = (int)Math.sqrt(start);
			for(i=2;i<=k;i++){
				if(start%i==0){
					break;
				}
			}
			//如果start%i==0，那抛掉start，此时情况为：i<k
			if(i<k){
				start++;
			}else{
				b=true;
				num=start;
			}
		}
		return num;
	}
	public static void main(String[] args) {
		int result = isPrime();
		System.out.println(result);
	}
}

4.写一个方法，功能：定义一个一维的int 数组，长度任意,然后将它们按从小到大的顺序输出（使用冒泡排序）（知识点：方法的定义和访问）。[选做题]

package chap5;
public class SubjectS2 {
	public static int[] order(int[] arr){
		for(int i=1;i<arr.length;i++){
			for(int j=0;j<arr.length-i;j++){
				if(arr[j]>arr[j+1]){
					int a=arr[j+1];
					arr[j+1]=arr[j];
					arr[j]=a;
				}
			}
		}
		return arr;
	}
	public static void main(String[] args) {
		int[] arr = {34,54,23,11,43,3};
		System.arraycopy(order(arr), 0, arr, 0, arr.length);
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}
	}
}

5.判断一个数是不是质数

package chap5;
public class SubjectSS1 {
	public static boolean prime(int n){
		int m=2;
		if(m<n){
			if(n%m==0){
				m++;
				return false;
			}
			else{
				return true;
			}
			
		}else{
			return false;
		}
	}
	public static void main(String[] args) {
		boolean r = prime(300);
		System.out.println(r);
	}
}