java 带参数的方法

目录

1 带参方法

1.1 定义带参方法

1.2 调用带参方法

1.3 带多个参数的方法

1.4常见错误

2 深入理解带参方法

2.1 数组作为参数的方法

2.2 对象作为参数的方法

3 包

3.1 为什么需要包

3.2 如何声明包

3.3 使用 MyEclipse 创建包

---

1 带参方法

 

1.1 定义带参方法

通过前面的学习，我们知道，类的方法是一个功能模块，其作用是"做一件事情"，实现某一个独立的功能，可供多个地方使用。在现实生活中，大家使用过榨汁机吗？榨汁机提供了一个很好的"榨汁"功能。如果放进去的是苹果，榨出来的就是苹果汁。如果放进去的是草莓，榨出来的就是草莓汁。如果同时放入两种水果，榨出来的就是苹果草莓汁。如果什么都不放，那就无法榨汁。因此，在使用榨汁机时，必须提供一个被榨的水果。再如，使用 ATM 取钱时，要先输入取款金额，然后ATM 才会"吐出"纸币。方法中某种功能的实现依赖于我们给它的初始信息，这时候在定义方法时就需要在括号中加入参数列表。

结合前面学习过的无参方法，现在给出定义类的方法的一般格式。

语法

    ＜访问修饰符＞ 返回值类型 ＜方法名＞(＜参数列表＞){

//方法的主体

}

其中：

• ＜访问修饰符＞指该方法允许被访问的权限范围，只能是 public 、protected 或 private。其中public 访问修饰符表示该方法可以被任何其他代码调用，另外两种修饰符将在后续课程中陆续学习。

• 返回值类型指方法返回值的类型。如果方法不返回任何值，它应该声明为 void 类型。Java对待返回值的要求很严格，方法返回值必须与所说明的类型相匹配。使用 return 语句返回值。

• ＜方法名＞是定义的方法的名字，它必须使用合法的标识符。

• ＜参数列表＞是传送给方法的参数列表。列表中各参数间以逗号分隔。参数列表的格式如下:数据类型 参数 1, 数据类型 参数 2,…… ，数据类型 参数 n, 其中 n≥0。

如果 n=0, 代表没有参数，这时的方法就是前面学习过的无参方法。

下面举一个实际的例子，如示例 1 所示。

示例1

public class StudentsBiz {
    String[] names = new String[30];         // 学员姓名数组

    public void addName(String name){        //有参方法

         //增加学生姓名

    }

public void ShowNames(){                   //无参方法

}

}

示例 1 定义了一个学生信息管理类 StudentsBiz, 包含学生姓名数组的属性 names 、增加学生姓名的方法。其中方法 addName (String name) 的功能是在 names 中增加学生姓名，这里只有一个参数 name。

注意：类中的属性可以是单个变量，也可以是一个数组，如示例 1 代码中的数组 names。可以通过运算符访问类的数组成员或数组成员的元素。例如，下面的代码：

StudentsBiz stuBiz = new StudentsBiz();

stuBiz.names;或stuBiz.names[1];

1.2 调用带参方法

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

语法

    对象名.方法名(参数 1, 参数 2, …，参数 n)

在定义方法和调用方法时，把参数分别称为形式参数和实际参数，简称形参和实参。形参是在定义方法时对参数的称呼，目的是定义方法需要传入的参数个数和类型。实参是在调用方法时传递给方法处理的实际的值。

调用方法时，需要注意以下两点。

• 先实例化对象，再调用方法。
• 实参的类型、数量、顺序都要与形参一一对应。

如下所示，示例 2 调用了  addName()方法，添加了五名学生。

示例2

public class TestAdd {
    public static void main(String[] args) {
        StudentsBiz st = new StudentsBiz();
        Scanner input = new Scanner(System.in);
        for(int i=0;i<5;i++){
            System.out.print("请输入学生姓名：");
            String newName = input.next();
            st.addName(newName);           //调用方法并传实参
        }
        st.showNames();              //显示全部学生的姓名
    }
}

1.3 带多个参数的方法

问题：指定查找区间，查找学生姓名并显示是否查找成功。

分析：在数组的某个区间中查询学生姓名，设计方法，通过传递三个参数(开始位置、结束位置、查找的姓名)来实现，如示例 3 所示。

示例3

public boolean searchName(int start,int end,String name){
    boolean find = false;  // 是否找到标识
    // 指定区间数组中，查找姓名
    for(int i=start-1;i<end;i++){
        if(names[i].equals(name)){
            find=true;
            break;
        }
    }
    return find;
}

调用该方法的类代码片段如下。

System.out.print("\n请输入开始查找的位置：");
int s = input.nextInt();
System.out.print("请输入结束查找的位置：");
int e = input.nextInt();
System.out.print("请输入查找的姓名：");
String name = input.next();
System.out.println("\n*****查找结果*****");
if(st.searchName(s,e,name)){
    System.out.println("找到了！");
}
else{
    System.out.println("没找到该学生！");
}

示例 3 的方法 searchName( )带有三个参数，数据类型分别是 int、int 、String, 调用该方法传递的实参 s、e、name 的类型都与之一一对应，并且 searchName( )方法定义返回值为 boolean 类型，return的 find 为 boolean 类型 。

通过前面示例的学习，我们发现，带参方法的参数个数无论多少，在使用时只要注意实参和形参一一对应：传递的实参值与形参的数据类型相同、个数相同、顺序一致，就掌握了带参方法的使用。

经验：

编程时，对于完成不同功能的代码，学员可以将它们写成不同的方法，每一个方法完成一个独立的功能模块，在需要的时候调用就可以了，使用方法可以提高代码重用率及程序的效率。

1.4常见错误

在编程过程中，带参方法的定义和调用对于初学者来讲，总是会出现各种不可避免的错误，如数据类型错误、参数传递错误等。

常见错误1

//方法定义

public void addName(String name){

     //方法体

}

//方法调用

对象名.addName(String “张三”)；

        代码中，调用方法时，在传递的实参前添加数据类型，正确的调用方法如下。

             对象名 .addName (" 张三”);

常见错误2

        //方法定义

    public boolean searchName(int start,int end,String name){

        //方法体

    }

    //方法调用

    String s = “开始”；

    int e = 3;

    String name = “张三”；

    boolean flag = 对象名.searchName(s,e,name);

代码中，形参和实参的数据类型不一致。searchName()方法定义的形参要求数据类型为int、int、String类型，而实际传递的实参数据类型为String、int、String。

常见错误3

//方法定义

    public boolean searchName(int start,int end,String name){

        //方法体

    }

    //方法调用

    int s = 1;

    int e = 3;

    boolean flag = 对象名.searchName(s,e);

形参和实参的数量不一致。 searchName! )方法定义了三个形参，而实际传递的实参只有两个。

常见错误4

还有一种情况比较常见，从语法结构讲不能称之为错误，但从程序设计的角度讲，算是程序设计错误的一种。

//方法定义

    public boolean searchName(int start,int end,String name){

        //方法体

    }

    //方法调用

    int s = 1;

    int e = 3;

    String name = “张三”;

    对象名.searchName(s,e,name);

方法定义有返回值，但是调用该方法后没有对返回值做任何处理

2 深入理解带参方法

2.1 数组作为参数的方法

问题：有五位学员参加了 Java 知识竞赛的决赛，输出决赛的平均成绩和最高成绩。

分析：将多个类型相同的数值型数据存储在数组中，并对其求总和、平均值、最大值、最小值等是实际应用中常见的操作，可以设计求总和、平均值、最大值、最小值等的方法，并把数组作为参数，这样便可以在多种场合下调用这些方法，如示例 4 所示。

示例4

package cn.jbit.classandobject;
/**
 *
 * 实现学生信息的管理
 *
 */
public class StudentsBiz {
   String[] names = new String[30];  // 学员姓名数组
  
   /**
    * 增加学生姓名
    * @param name要增加的姓名
    */
   public void addName(String name){
      for(int i =0;i<names.length;i++){
         if(names[i]==null){
            names[i]=name;
            break;
         }
      }
   }
   /**
    * 显示本班的学生姓名
    */
   public void showNames(){
      System.out.println("本班学生列表：");
      for(int i =0;i<names.length;i++){
         if(names[i]!=null){
            System.out.print(names[i]+"\t");
         }
      }
      System.out.println();
   }
  
   /**
    * 修改学员姓名
    * @param oldName旧名字
    * @param newName新名字
    */
   public boolean editName(String oldName,String newName){
      boolean find = false;  // 是否找到并修改成功标识
     
      // 循环数组，找到姓名为oldName的元素，修改为newName
      for(int i=0;i<names.length;i++){
         if(names[i].equals(oldName)){
            names[i] = newName;
            find=true;
            break;
         }
      }
      return find;
   }
   /**
    * 在一定区间查找学生姓名
    * @param start 开始位置
    * @param end 结束位置
    * @param name 查找的姓名
    * @return find 是否查找成功
    */
   public boolean searchName(int start,int end,String name){
      boolean find = false;  // 是否找到标识
     
      // 指定区间数组中，查找姓名
      for(int i=start-1;i<end;i++){
         if(names[i].equals(name)){         
            find=true;
            break;
         }
      }
      return find;
   }
  
    /**
     * 求平均分
     * @param scores 参赛成绩数组
     */
    public double calAvg(int[] scores){
        int sum=0;
        double avg=0.0;
        for(int i =0;i<scores.length;i++){
            sum+=scores[i];
        }
        avg=(double)sum/scores.length;
        return avg;
    }

    /**
     * 求最高分
     * @param scores 参赛成绩数组
     */
    public int calMax(int[] scores){
        int max=scores[0];
        for(int i =1;i<scores.length;i++){
            if(max<scores[i]){
                max=scores[i];
            }
        }
        return max;
    } 
}

示例 4 中的 StudentsBiz 类定义了两个方法，分别实现了求平均成绩和最高成绩，它们都是带数组参数并且带返回值的方法。

public double calAvg(int[] scores)

public int calMax(int[] scores)

参数 scores 数组传递所有学员的比赛成绩，而且定义方法时并没有指定数组大小，而是在调用方法时确定要传递的数组的大小。 return 语句用来返回平均成绩和最高成绩。

示例 4 的运行结果如图 14.3 所示。

图 14.3 示例 4 的运行结果

2.2 对象作为参数的方法

问题：在示例 1 中，实现了增加一个学生姓名的功能，那么，如果不仅要增加学生的姓名，还要增加学生的年龄和成绩，应该如何实现呢？

分析：在示例 1 中，设计了一个方法，通过传递一个参数（新增的学生姓名）来实现。同样，要新增年龄和成绩，可以在类中定义两个分别表示年龄和成绩的数组，同时在方法中增加两个参数（要新增的学生的年龄、要新增的学生的成绩）。但是，这样设计会有一些问题，在类中声明的数组较多，在方法中的参数较多，试想，如果新增的学生信息包括的更多，如家庭住址、联系电话、身高、体重、性别等，那么是不是需要在类中定义更多的数组和在方法中定义更多的参数呢？显然，这不是最好的解决方案。其实，大家已经学习过类和对象，可以使用面向对象的思想，把所有要新增的学生信息封装到学生类中，只需要在方法中传递一个学生对象就可以包含所有的信息，如示例 5 所示。

示例5

package cn.jbit.class4;
/*
 *
 * 学生类
 *
 */
class Student{
    public int id;
    public String name;
    public int age;
    public int score;

    public void showInfo(){
        System.out.println(id+"\t"+name+"\t"+age+"\t"+score);
    }
}

/*
 *
 * 实现学生信息的管理
 *
 */
public class StudentsBiz {
    Student[] students = new Student[30];  // 学生数组
    /*
     * 增加学生
     * @param 一个学生
     */
    public void addStudent(Student stu){
        for(int i =0;i<students.length;i++){
            if(students[i]==null){
                students[i]=stu;
                break;
            }
        }
    }
    /*
     * 显示本班的学生信息
     *
     */
    public void showStudents(){
        System.out.println("本班学生列表：");
        for(int i =0;i<students.length;i++){
            if(students[i]!=null){
                students[i].showInfo();
            }
        }
        System.out.println();
    }
}

调用该方法的类代码如下。

package cn.jbit.class4;
import java.util.Scanner;
public class TestAdd {
    /**
     * 调用有参方法
     */
    public static void main(String[] args) {
        //实例化学生对象
        Student student1=new Student();
        student1.id=10;
        student1.name="王紫";
        student1.age=18;
        student1.score=99;
        Student student2=new Student();
        student2.id=11;
        student2.name="郝田";
        student2.age=19;
        student2.score=60;
        //新增学生对象
        StudentsBiz studentsBiz=new StudentsBiz();
        studentsBiz.addStudent(student1);
        studentsBiz.addStudent(student2);
        studentsBiz.showStudents();//显示学生信息
    }
}

在示例 5 中， Student[] students = new Student[30] ； 表示声明了大小为 30 的学生对象数组，即数组 students 可以存储 30 个学生对象。

方法 addStudent (Student stu) 带有一个 Student 类型的参数，调用时将传递一个学生对象。就传递的参数而言，这里的 Student 类型的参数与前面学习的 int 、 String 等类型的参数相同，需要保证形参和实参的一致。程序运行结果如图 14.4 所示。

图 14.4 示例 5 的运行结果

注意：关于数组和对象作为参数的情况，大家先模仿示例，掌握其基本用法，在第二学期会进行更深入的学习。

3 包

3.1 为什么需要包

在生活中，保存文档时会经常使用文件夹，把不同类型的文档归类，然后分放到不同的文件夹中，易于管理和查找，如图 14.7 所示。

h在计算机中保存电子文档也不例外。图 14.8 是大家经常看到的 Windows 系统中的树形目录结构。

在复杂的文件系统中，文件分门别类存储在不同的文件夹中解决了文件同名冲突的问题。事实上，在编写复杂程序的过程中，也会遇到同样的问题。 Java 以类组织程序，开发一个大型的工程可能需要编写成百上千个类。如果要求开发人员确保自己选用的类名不和其他程序员选择的类名冲突，这是很困难的。例如，在程序中，开发人员定义了一个 Sort 类，使用冒泡的方法排序，但另一个人也定义了一个 Sort 类，于是类名冲突，问题就这么产生了， Java 提供包来管理类。类似于文件存储在文件夹中， Java 的类文件可以存储在不同的包中。

包主要有以下三个方面的作用。

(1) 包允许将类组合成较小的单元(类似文件夹)，易于找到和使用相应的类文件。

(2) 防止命名冲突： Java 中只有在不同包中的类才能重名。世界上有千千万万的程序员，命名同名的类几乎是难免的。有了包，类名就好管理多了。 A 定义了一个类 Sort, 封装在包 A 中，B 定义了一个类 Sort, 封装在包 B 中。在使用时，为了区别 A 和 B 分别定义的 Sort 类，便可以通过包名区分开，如 A.Sort 和 B.Sort 分别对应于 A 和 B 定义的 Sort 类。

(3) 包允许在更广的范围内保护类、数据和方法，可以在包内定义类。根据规则，包外的代码有可能不能访问该类。

3.2 如何声明包

要声明一个包 (package), 只要包含一个 package 命令作为一个 Java 源文件的第一条语句就可以，如示例 6 所示。

示例6

package cn.jbit.classandobject;

public class AccpSchool {
    public AccpSchool() {
    }
    public void showMessage() {
        System.out.println("这是上海Accp中心。");
    }
}

在示例 6 中, AccpSchool 类就属于包  cn.jbit.classandobject 。

下面是声明包的通用形式。

语法：

package 包名；

package 是关键字。包的声明必须是 Java 源文件中的第一条非注释性语句，而且一个源文件只能有一个包声明语句。在示例 6 中，使用 package 声明包，包名是 cn.jbit.classandobject 。

Java 中，包被设计与文件系统结构相对应。因此，在命名包时，要严格遵守以下编码规范。

• Java 包的名字通常由小写字母组成，不能以圆点开头或结尾。例如， ".mypackage" 是错误的包名。

• 一个唯一包名的前缀通常是全部小写的 ASCII 字母，并且是一个顶级域名 com 、edu 、gov 、net 或 org, 通常使用组织的网络域名的逆序。例如，如果域名为 javagroup.net, 我们可以声明包为

package net.javagroup.mypackage;

• 包名的后续部分依不同机构各自内部的规范不同而不同。这类命名规范可能以特定目录名的组成来区分部门、项目、机器或注册名。例如：

package net.javagroup.research.powerproject;

3.3 使用 MyEclipse 创建包

问题：使用  Idea  创建  AccpSchool  类，并且使之位于包  cn.jbit.classandobject 中。

分析：在 Idea 中创建包有以下两种方式。

方法一：分别创建包和类。

方法二：在创建类的过程中创建类所属的包。

1. 使用方法一创建包

首先新建一个项目 "项目", 然后选择 "Java模块"点击“next” → "Create project from template" 点击“next”选项。在弹出的 "New Project" 对话框中，在"Preject name"文本框中填写项目名称。在"Preject Location" 文本框中填写项目的存放位置，在"Base package"文本框中填写包名 "cn.jbit.classandobject"，如图 14.9 所示。

单击 "Finish" 按钮，在包资源管理器中就能看到图 14.10 所示的效果。

图 14.10 创建包成功的效果                          图 14.11 在包中创建类

选择 "cn.jbit.classandobject" 选项，然后新建类 AccpSchool, 在弹出的对话框中填写类名，单击 "Finish" 按钮。大家会在包资源管理器中看到类创建成功的效果，如图 14.11 所示。

14.3.4 包和目录的关系

我们通过创建包来组织程序，在 MyEclipse 中创建包后， Java 源文件是如何存储的呢？

在 Java 中，包被设计与文件系统相对应，事实上， Java 中的每个包都对应于文件系统中同名的子目录。包的嵌套反映了文件系统中的目录层次，如包 cn.jbit.classandobject 对应于文件系统中的cn\jbit\classandobject, 如图 14.14 所示，声明包事实上是在文件系统中创建了相对应的一层层文件夹，而类文件 AccpSchool.java 就存储在最内层文件夹 classandobject 中。

图 14.14 创

下面就来解决一个实际问题。

问题：在 “ PackageTest ” 项目中，在  AccpSchool 类中添加方法 showMessage(), 然后创建 HelloAccp 类，要求该类位于包 “Demo” 中，在 HelloAccp 类中实现 main() 方法调用showMessage( )。

分析：要使用别的包中的类，首先要使用 import 导入这个类。注意：包的声明位于源文件的第一条语句。 import 语句要写在类定义之前，如示例 7 所示。

示例7

AccpSchool 类的实现：

package cn.jbit.classandobject;
public class AccpSchool {
    public AccpSchool() {
    }
    public void showMessage() {
        System.out.println("这是上海Accp中心。");
    }
}

HelloAccp 类的实现：

package Demo;
import cn.jbit.classandobject.AccpSchool;
public class HelloAccp {
    public HelloAccp() {
    }
    public static void main(String[] args) {
        AccpSchool center = new AccpSchool();
        center.showMessage();
    }
}

小结：声明包的含义：声明当前类所处的位置。

导入包的含义：声明在当前类中要使用到的其他类所处的位置。