Java方法

Posted on Edited on Views: Valine:
Symbols count in article: 1.5k Reading time ≈ 1 mins.

什么是方法

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

方法声明

语法格式：

访问修饰符 返回类型 方法名（参数列表）｛

​ 方法体

｝

方法分类

根据方法是否带参数、是否返回值，可分为四类：

-无参无返回值方法

-无参带返回值方法

-带参无返回值方法

-带参带返回值方法

无参无返回值方法

例：一行打印输出一串星号

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

public class MethodDemo {
	
//打印输出星号的方法
public void printStar() {
	System.out.println("*****************");
}

public static void main(String[] args) {
	// TODO Auto-generated method stub
	MethodDemo myMethodDemo=new MethodDemo();
	myMethodDemo.printStar();
	//System.out.println("*****************");
	System.out.println("欢迎来到Java的世界");
	//System.out.println("*****************");
	myMethodDemo.printStar();

}

}

无参带返回值方法

例：求长方形的面积 

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

public class Rectangle {
	//求长方形面积的方法
	public int area() {
		int length=10;
		int width=5;
		int getArea=length*width;
		return getArea;//返回语句
	}

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

}

}

带参无返回值方法

例：定义一个求两个float类型数据最大值的方法，在方法中将最大值打印输出。

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
package imoocProj;

public class MaxDemo {
	//求最大值方法
	public void max(float a,float b) {
		float max=0;
		if(a>b) {
			max=a;
		}else {
			max=b;
		}
		System.out.println("最大值为:"+max);
	}

public static void main(String[] args) {
	// TODO Auto-generated method stub
	MaxDemo maxDemo=new MaxDemo();
	int a=5,b=3;
	maxDemo.max(a, b);
	float m=5.6f,n=9.8f;
	maxDemo.max(m, n);
	maxDemo.max(9.8f, 12.8f);
}

}

编程练习

定义一个方法，根据商品总价，计算出对应的折扣并输出。折扣信息如下：

1） 总价<100，不打折

2） 总价在100到199之间，打9.5折

3） 总价在200以上，打8.5折

效果图：折后商品总价为:142.5

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
public class DisCountDemo {
    public void discount(double price){
        if(price<100){
            price=price*1;
            System.out.println("折后商品总价为:"+price);
        }else if((price>=100)&(price<=199)){
            price=price*0.95;
            System.out.println("折后商品总价为:"+price);
        }else if(price>200){
            price=price*0.85;
            System.out.println("折后商品总价为:"+price);
        }
    }//根据商品总价输出折后总价

public static void main(String[] args) {
	DisCountDemo ds=new DisCountDemo();//定义对象
	
	double price=150;//定义商品总价存放到变量中
	ds.discount(price);

	//调用方法，输出折后商品总价
	
}

}

带参有返回值方法

定义一个求n!的方法，然后再求1！+2！+3！+4！+5！

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
package imoocProj;

public class FacDemo {
	//求阶乘的方法
	public int fac(int n) {
		int s=1;
		for(int i=1;i<=n;i++) {
			s*=i;//s=s*i
		}
		return s;
	}
	public static void main(String[] args) {
		FacDemo facDemo=new FacDemo();
		int fac=facDemo.fac(3);
		System.out.println("3!="+fac);
		//求1！+2！+3！+4！+5！
		int sum=0;
		for(int i=1;i<=5;i++) {
			fac=facDemo.fac(i);
			sum=sum+fac;
		}
		System.out.println("1！+2！+3！+4！+5！="+sum);
}

}

数组作为方法参数

例：定义方法，打印输出数组元素的值

public void printArray(int[] arr){}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package imoocProj;

public class ArrayMethod {
	public void printArray(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]+"  ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		int[] arr= {10,20,30,40,50};
		ArrayMethod Array=new ArrayMethod();
		Array.printArray(arr);

}

}

编程练习

编写方法，求数组元素的平均值（效果：数组的平均值为:70.1）

任务

1、定义一个方法，求数组的平均值

2、在主方法中定义对象，并初始化一个float类型的数组，调用方法求数组元素的平均值，并将平均值打印输出

提示：

当数组元素的内容为：78.5,98.5,65.5,32.5和

75.5时，可得到效果图所示的结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class AverageDemo {
    public void avrArr(double[] arr){
        double sum=0;
        for(int i=0;i<arr.length;i++){
            sum=sum+arr[i];
        }
        double avr=sum/arr.length;
        System.out.println("数组的平均值为:"+avr);
    }//求数组元素的平均值

public static void main(String[] args) {
	AverageDemo array=new AverageDemo();//定义对象
	
	double[] arr={78.5,98.5,65.5,32.5,75.5};
	//创建float类型的数组并初始化
	
	array.avrArr(arr);//调用方法求平均值并打印输出
	
}

}

例：查找数组元素的值

​ –方法参数为：数组、要查找的元素

​ –返回值：boolean类型

public boolean search(int n,int[] arr){}

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
package imoocProj;

import java.util.Scanner;

public class ArraySearch {
	//查找数组元素值的方法
	public boolean search(int n,int[] arr) {
		boolean flag=false;//默认是没找到
		for(int i=0;i<arr.length;i++) {
			if(arr[i]==n) {
				flag=true;
				break;
			}
		}
		return flag;
	}

public static void main(String[] args) {
	int[] arr1= {10,20,30,40,50,60};
	Scanner sc=new Scanner(System.in);
	System.out.println("请输入要查找的数据:");
	int n1=sc.nextInt();
	ArraySearch as=new ArraySearch();
	boolean flag=as.search(n1, arr1);
	if(flag) {
		System.out.println("找到了！");
	}else {
		System.out.println("没找到！");
	}

}

}

方法重载

方法重载原则：
方法名相同，参数列表不同，这里的不同即可以是数量不同，也可以是类型不同。
方法重载作用：
重载的最直接作用是方便了程序员可以根据不同的参数个数，顺序，类型，自动匹配方法，减少写过个函数名或方法名的重复步骤

方法重载的应用

定义三个方法，实现int、double、和数组类型和的问题

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
 package imoocProj;

public class MathDemo {
	
//求两个int类型数的和
public int plus(int m,int n) {
	return m+n;
}
//求两个double类型数的和
public double plus(double m,double n) {
	return m+n;
}
public int plus(int[] arr) {
	int sum=0;
	for(int i=0;i<arr.length;i++) {
		sum=sum+arr[i];
	}
	return sum;
}
public static void main(String[] args) {
	int m=5,n=10;
	int[] arr= {1,2,3,4,5,6};
	MathDemo mathDemo=new MathDemo();
	System.out.println("int类型的和:"+mathDemo.plus(m, n));
	System.out.println("double类型的和:"+mathDemo.plus(m, n));
	System.out.println("数组元素的和:"+mathDemo.plus(arr  ));
}

}

编程练习

定义两个重载的方法，分别求圆和长方形的面积。

效果：

1
2
圆的面积为:63.61725123519331
长方形面积为:40.0

任务：

1、定义两个求面积的重载方法，圆周率可以用Math.PI表示

2、在主方法中调用方法并将结果输出。

注意：当圆的半径为4.5，长方形长和宽分别为8和5时，可得到如效果图所示的结果

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
public class AreaDemo {
    public double Area(double r){
        double s=Math.PI*r*r;
        return s;
    }//求圆形面积

public double Area(double a,double b){
    double s=a*b;
    return s;
}//求长方形面积

public static void main(String[] args) {
	AreaDemo area=new AreaDemo();//定义对象
	
	double r=4.5;
	//定义一个double类型的变量存放半径，并初始化
	
	double a=8,b=5;//定义两个变量存放长和宽，并初始化
	
	System.out.println("圆的面积为:"+area.Area(r));
	//调用方法，求圆的面积并打印输出
	
	System.out.println("长方形面积为:"+area.Area(a,b));
	//调用方法，求长方形面积并打印输出
	
}

}

基本数据类型的传值

值传递：实参将值拷贝传给形参，形参的改变并不会影响实参的改变。

在普通方法中调用当前类中的其它方法时，与在主方法中不同，无需创建对象再调用方法，可以直接调用方法使用
主方法和普通方法调用时候的区别：
1.主方法必须使用对象名调用（就是xx a=new xx();a.xxx();
2.普通方法如果和当前方法在一个类里面，直接使用方法名调用即可，不用定义对象

基本数据类型进行传递的时候，传递的是值的拷贝，例如：int a = 1;传递进去的是1而不是a的内存地址（特殊例子是String）
而引用数据类型，如对象（含数组）传递的都是地址，它们都指向同一块内存空间

可变参数列表

int… n 可变参数列表
可变参数：例如：public void sum(int… n),可变参数必须写在参数列表的最后。

可以将数组传给可变参数，在方法重载中，参数若为数组和可变参数，即视为重复，报错。

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

public class ArgsDemo {
	//求和
	public void sum(int... n) {
		int sum=0;
		for(int i:n) {
			sum=sum+i;
		}
		System.out.println("sum="+sum);
	}
	public static void main(String[] args) {
		ArgsDemo ad=new ArgsDemo();
		ad.sum(1);
		ad.sum(1,2);
		ad.sum(1,2,3);
	}

}
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
package MoocJava;

public class ArgsDemo1 {
	//查找
	public void search(int n,int... a) {
		boolean flag=false;
		for(int a1:a) {
			if(a1==n) {
				flag=true;
				break;
			}
		}
		if(flag) {
			System.out.println("找到了！"+n);
		}else {
			System.out.println("没找到！"+n);
		}
	}
//	public void search(int n,int[] a) {}
//	报错，数组和可变参数视为同一种
	public static void main(String[] args) {
		ArgsDemo1 ad1=new ArgsDemo1();
		ad1.search(3,1,2,3,4,5);
		int[] a= {1,2,3,4,5};
		ad1.search(3, a);
	}

}

方法的调试

方法的调试跟普通调试没有太大的区别

F5:跳入方法中调试
F6：单步调试
F7：由方法内部跳入调用处

在eclipes 中如果写入Scanner 语句没有自动导入相应的包，按ctrl+shift+o

-------------本文结束感谢您的阅读-------------