Java内功提升之定义方法

（一）如何定义Java中的方法

1）什么是方法

方法，指的就是解决一类问题的代码的有序组合，是具有功能的模块。

语法：

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

方法体

｝

说明：

（1）访问修饰符：方法被允许访问的权限范围，可以是public ， private ，protected 甚至可以省略。

（2）返回值类型：方法返回值的类型，如何方法不返回任意的值，则返回值的类型指定为void ；如何方法具有 返回值，则需要指定返回值的类型，并且在方法体中使用return 语句返回。

（3）方法名：定义的方法的名字，必须使用合法的标识符。

（4）参数列表：传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类 型和参数名组成，以空格隔开根据方法是否带参，是否带返回值，可将方法分为四类：

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

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

比如：（这是一个无参无返回值方法）

public class mytest {

//定义了一个方法名为 print 的方法，实现输出信息功能
public void print() {
System.out.println("Hello World");
}

public static void main(String[] args){

//在 main 方法中调用 print 方法
mytest test=new mytest();
test.print();
}
}

（二）Java中无参无返回值方法的使用

无参无返回值方法，指的就是方法不包含参数，且没有返回值。

方法的使用分为俩种：

1）定义方法：

//定义了一个方法名为 print 的方法，实现输出信息功能
public void print() {
System.out.println("Hello World");
}

注：

（1）方法体必须在大括号中。

（2）方法名命名要规范，遵循驼峰标识符（首个单词的首字母要小写，其他单词首字母大写的形式）

2）调用方法：
当需要调用方法执行某个操作时，可以先创建类的对象，然后通过，***对象名.方法名（）；***来实现。
比如：

public class mytest {
public static void main(String[] args){

//创建对象，对象名为test
mytest test=new mytest();
//通过“对象名.方法名（）；”的形式来调用方法。
test.print();//在 main 方法中调用 print 方法
}
}
//定义了一个方法名为 print 的方法，实现输出信息功能
public void print() {
System.out.println("Hello World");
}

（三）Java中无参带返回值方法的使用

无参带返回值方法，即方法不包含参数，但有返回值。

比如：

public int sum（）
｛
int a=9;
int b=5;
sum=a+b;
return sum;
｝

在sum（）方法中，返回值类型为int 类型，因此在方法体中必须使用return返回一个整数值。调用带返回值的方法时，一般会接收其返回值并进行处理。

比如：

public class mytest {
public static void main(String[] args){

//创建对象，对象名为test
mytest test=new mytest();
//调用方法并接收其返回值，保存在变量sum中
int sum =test.sumCalc（）;
System.out.println("俩数的和为："＋sum);
}
}
public int sumCalc（）
｛
int a=9;
int b=5;
sum=a+b;
return sum;
｝

使用无参带返回值的方法时需要注意的是：

1）若方法为void型，则不可以使用return返回值。比如：

public void loop(){
.....
return num;//***这是错误的写法！！！！！！***
}

2）返回值只能有一个，不可以有多个！比如：

public void dogNum(){
int num = 9 ;
int num3 = 7;
return num2 ，num3 ;//***这是错误的写法！！！！！！***
}

3)返回值类型必须匹配兼容，比如：

你不可以定义一个int的方法，而返回值却是一个String类型的。

public int catNum(){
String Name = " kven ";
return Name;//***这是错误的写法！！！！！！***
}

一个无参数带返回值的完美例：

功能：计算成绩的平均值

public class scoresArg {

public static void main(String[] args) {

// 创建名为scores的对象
scoresArg scores = new scoresArg();

// 调用scores对象的calAvg()方法，并将返回值保存在变量avg中
double avg = scores.calAvg();

System.out.println("平均成绩为：" + avg);
}

// 定义一个返回值为double类型的方法
public double calAvg() {

double math = 92.5;
double histort = 83.0;
double avg = (math + histort) / 2; // 计算平均值

// 使用return返回值
return avg;

}

小试牛刀：

编写一个 Java 程序，实现输出学生年龄的最大值。

要求：

1、 要求通过定义无参带返回值的方法来实现，返回值为最大年龄

2、 方法中将​学生年龄保存在数组 ages 中，数组元素依次为 18 ,23 ,21 ,19 ,25 ,29 ,17

运行结果为： 最大年龄为：29

public class HelloWorld {

//完成 main 方法
public static void main(String[] args) {

// 创建对象，对象名为hello
HelloWorld hello = new HelloWorld();

// 调用方法并将返回值保存在变量中
int maxScore = hello.getMaxAge();

// 输出最大年龄
System.out.println("最大年龄为：" + maxScore);
}

/*
* 功能：输出学生年龄的最大值
* 定义一个无参的方法，返回值为年龄的最大值
* 参考步骤：
* 1、定义一个整形数组 ages ，保存学生年龄，数组元素依次为 18 ,23 ,21 ,19 ,25 ,29 ,17
* 2、定义一个整形变量 max ,保存学生最大年龄，初始时假定数组中的第一个元素为最大值
* 3、使用 for 循环遍历数组中的元素，并与假定的最大值比较，如果比假定的最大值要大，则替换当前的最大值
* 4、使用 return 返回最大值
*/
public int getMaxAge() {

int ages[]={18 ,23 ,21 ,19 ,25 ,29 ,17};
int max=ages[0];
for(int i = 0 ; i < ages.length ; i++){
if(ages[i] > max){
max = ages[i];
}
}
return max;
}
}

(四）Java中带参无返回值方法的使用：

带参无返回值，即当方法执行时需要一定的条件，比如：烧菜（烧菜就是带参无返回值的方法）需要食材（这个食材就是条件）。其中，我们可以通过在方法中加入参数列表接收外部传入的数据信息，参数可以是任意基本类型或者引用类型数据。

一个简单的带参无返回值方法：

public void String(String fruit){
System.out.println("你要的水果是：: " + fruit);
}

语法：

调用带参方法与调用无参方法的语法类似，但在调用时必须传入实际的参数值。

对象名.方法名（实参1 ，实参2 ， ... ，实参N）

比如：

// 创建对象，对象名为hello
HelloWorld hello = new HelloWorld();
// 调用带参方法时，必须传入参数
hello.scores(98.5);

1）形参与实参

形参,把定义方法时的参数称为形参。
目的是用来定义方法需要传入的参数的个数和类型；
实参，把调用方法时的参数称为实参。
是传递给方法真正被处理的值。

注意：<1>调用带参方法时，必须保证实参的数量，类型，顺序与形参一一对应。
比如：

public class HelloWorld {
public static void main(String[] args) {
// 创建对象，对象名为hello
HelloWorld hello = new HelloWorld();
// 调用方法，传入两门课程的成绩
hello.look(94）；//***看这里呀！**调用的方法是String类型，传入的实参却是int 类型（就是指94）***造成形参与实参类型不一致的问题！！！***
public String look(String names ){
return    "names is :" + names;
}
}

2）实参调用时，不需要指定数据类型.

比如：hello.look(”一份耕耘，一份收获！！“）；

3）方法的参数可以是基本数据类型，比如：int ， char等，也可以是引用数据类型，比如：数组 ，String

import java.util.Arrays;
public class Test{
public static void main(String[] args) {
// 创建对象，对象名为hello
Test test = new Test();
int [] scores={56,78,34,89};
test.print(scores); //实参为整型数组
}
public void print( int[] scores){ //参数为整型数组
//使用Arrays类的toString()方法将数组转化为字符串输出
System.out.println(Arrays.toString(scores));
}

4)当方法参数个数有多个时，多个参数可以以逗号分隔

public int scores(int scores_1 ,int scores_2){
avg =(scores_1 + scores_2) / 2;
return avg;
}

(五）Java 中带参带返回值方法的使用

带参带返回值方法，即指的是方法既包含参数，又带有返回值。

比如：

//定义一个带参带返回值方法selectNmaes
public String selectNmaes(String name ){

return "你选择的名字是：" + name ;
}
//调用带参带返回值的方法：
selectNmaes myname = new selectNmaes();
String mySelect = myname.selectNmaes("小刚");//调用带参带返回值的方法, 并将它保存在mySelect中
System.out.println(mySelect);

运行结果是：
你选择的名字是：小刚

编程练习：

实现功能：将考试成绩排序并输出，返回成绩的个数。

实现思路：

定义一个包含整型数组参数的方法，用来传入成绩数组

在方法体中使用 Arrays.sort( ) 方法对成绩数组进行排序，然后使用 Arrays.toString( ) 方法将数组转换为字符串并输出，最后使用 return 返回数组中元素的个数。

调用方法时需要先创建对象，然后再调用.调用时为其传入成绩数组，并获取方法的返回值，保存在变量中，最后输出成绩的个数。

import java.util.Arrays;

public class HelloWorld {
public static void main(String[] args) {
HelloWorld hello = new HelloWorld();
int[] scores={79,52,98,81};

//调用方法，传入成绩数组，并获取成绩的个数
int count=hello.sort(scores);

System.out.println("共有"+count+"个成绩信息！");
}

/*
* 功能：将考试成绩排序并输出，返回成绩的个数
* 定义一个包含整型数组参数的方法，传入成绩数组
* 使用Arrays类对成绩数组进行排序并输出
* 方法执行后返回数组中元素的个数
*/
public int sort(  int[] scores ){
Arrays.sort(scores);
System.out.println(Arrays.toString(scores));

//返回数组中元素的个数
return scores.length;
}
}

(六）Java中方法的重载

方法的重载，指的就是在同一个类中，方法名相同，而参数的个数，顺序或类型不同的方法。

比如：

//无参方法
public  void sort(  ){
System.out.println("我要的是fruit");
}
public  void sort( String fruit ){
System.out.println("我要的是fruit");
}

public  void sort(String fruit , int number ){
System.out.println("我要的是fruit");
System.out.println("fruit number"+ number);
}

public  void sort(int number , String fruit  ){
System.out.println("我要的是fruit");
System.out.println("fruit number"+ number);
}

注意：

1）如何区分调用重载方法

当调用重载方法时，Java会根据参数的个数与类型，来判断该使用那个重载方法，参数完全匹配的方法将被执行！！

比如：

public static void main(String[] args) {
// 创建对象
myFruit myfruit = new myFruit();
myfruit.sort();//调用无参的sort方法
myfruit.sort("apple"); //调用带有一个字符串参数的sort方法
myfruit.sort("oranges" , 10 );//调用带有字符串参数与整形参数的sort方法
}

判断方法是否重载的条件：

1.必须是在同一个类中

2.方法名相同

3.方法参数的个数、顺序或类型不同

4.与方法的修饰符或返回值没有关系

编程练习：

编写一个JAVA程序，创建指定长度的 int 型数组，并生成 100 以内随机数为数组中的每个元素赋值，然后输出数组。

要求：

1.要求通过定义带参带返回值的方法来实现

2.通过参数传入数组的长度（例如长度为 8），方法执行后返回赋值后的数组

3.通过 (int)(Math.random() 100) 生成 100 以内的随机数*

注：Math 类是用于进行算术操作的类，Math.random() 生成 0–1 的浮点数。 关于该类的其他应用在后面章节会有详细介绍，先熟悉随机数方法的使用.

运行效果为： [ 2 , 52 , 8 , 26 , 66 , 32 , 98 , 0 ]

< 1 > 定义一个带参带返回值的方法，实现输出随机数数组

提示：

1. 定义一个带参带返回值的方法，通过参数传入数组的长度，返回值为赋值后的数组

2.创建指定长度的整型数组

3. 使用 for 循环遍历数组，通过 Math.random( ) 生成随机并给数组成员赋值

4. 使用 return 返回赋值后的数组

完成 main 方法

< 2 >完成main方法

提示：

1、 调用自定义方法，保存方法执行后返回的数组
2、 使用 Arrays.toString( ) 将数组转换为字符串并输出，注意导入 java.util.Arrays;

import java.util.Arrays;
public class myElement {
public static void main(String[] args) {
// 创建对象，对象名为hello
myElement myelement = new myElement();
// 调用方法并将返回值保存在变量中
int[] nums = hello.getArray(8);
// 将数组转换为字符串并输出
System.out.println(Arrays.toString(nums));
}
/*
* 功能：创建指定长度的int型数组，并生成100以内随机数为数组中的每个元素赋值
* 定义一个带参带返回值的方法，通过参数传入数组的长度，返回赋值后的数组
*/
public int[] getArray(int length) {
// 定义指定长度的整型数组
int[] nums = new int[length];
// 循环遍历数组赋值
for ( int i = 0 ;i < nums.length ; i++) {
// 产生一个100以内的随机数，并赋值给数组的每个成员
nums[i] =(int)(Math.random() * 100){
}
return nums; // 返回赋值后的数组
}
}

阶段练习：

编写一个 JAVA 程序，实现输出考试成绩的前三名

要求：

1.考试成绩已保存在数组 scores 中，数组元素依次为 89 , -23 , 64 , 91 , 119 , 52 , 73

2.要求通过自定义方法来实现成绩排名并输出操作，将成绩数组作为参数传入

3.要求判断成绩的有效性（ 0—100 ），如果成绩无效，则忽略此成绩

分析：

定义一个包含整型数组参数的方法，用来接收成绩数组，进行成绩排序并输出前三名

提示：

1. 在方法中使用 Arrays 类的 sort( ) 方法对数组进行排序，默认按升序排列，注意 Arrays 类的使用需要导入 java.util.Arrays

2. 由于只需要输出考试成绩的前三名，所以定义一个变量，统计有效成绩的前三名的数量

3. 使用 for 循环遍历数组中的元素，由于要输出的是前三名成绩，所以从后往前遍历，即倒序遍历 如 for ( int i = scores.length - 1; i >= 0; i– ) { }

4. 判断成绩的有效性，如果成绩小于 0 或大于 100 ，则使用 continue 忽略此成绩

5. 如果成绩有效，则有效成绩数加 1 。判断有效成绩的个数，如果有效成绩数大于 3 ，则结束循环，只输出成绩的前三名

完成 main 方法

提示：

1. 定义一个成绩数组 scores ，保存预定的考试成绩 89 , -23 , 64 , 91 , 119 , 52 , 73

2. 调用自定义方法，传入成绩数组，完成功能

import java.util.Arrays;

public class outScores {

//完成 main 方法
public static void main(String[] args) {
int  scores[] ={ 89 , -23 , 64 , 91 , 119 , 52 , 73} ;//成绩数组
System.out.println("前三名的成绩为：");
outScores  outscores = new outScores ();//创建对象名为outscores
outscores.showTops3(scores);//调用方法，传入成绩数组
}
**//功能：输出考试成绩的前三名 定义一个包含整型数组参数的方法，用来传入成绩数组**

//定义方法完成成绩排序并输出前三名的功能
public void showTop3(int scores[]){
Arrays.sort(scores);//使用Arrays.sort()方法实现数组排序
int num = 0;//保存有效成绩的数量
for(int i = soures.length -1 ; i>=0 ; i--){//倒序遍历数组中的每一个元素
if(scores[i] < 0 && scores[i] >100){//判断成绩的有效性
continue;//如果成绩无效，则跳出本次循环，忽略该成绩
}
num++;//有效成绩的数量加1
if( num > 3){//判断有效成绩的数量
break;//如果有效成绩大于3 ，则结束循环，输出成绩的前三名，并结束
}
System.out.println(scores[i]);
}
}

}