欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

JavaSE-方法定义与调用

程序员文章站 2022-03-17 10:35:50
...

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);
	}
}