方法重载和可变参数--面向对象基础

1. 基本介绍 227

java 中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致！

比如：System.out.println(); 可以输出不同类型的值

out 是 PrintStream 类型

1.1 重载的好处

1) 减轻了起名的麻烦

2) 减轻了记名的麻烦

1.2 例

public class Test31
{
  public static void main(String[] args)
  {
    System.out.println(100); 
    System.out.println("hello,world"); 
    System.out.println('h'); 
    System.out.println(1.1);
    System.out.println(true);
  }
}

2. 方法重载的快速入门

2.1 具体案例 228

编写程序完成下列功能

1) calculate(int n1, int n2) //两个整数的和

2) calculate(int n1, double n2) //一个整数，一个 double 的和

3) calculate(double n1, int n2)//一个 double ,一个 Int 和

4) calculate(int n1, int n2,int n3)//三个 int 的和

public class Test31
{
  public static void main(String[] args)
  {
    MyCalculator mc = new MyCalculator();
    System.out.println(mc.calculate(1,2));//3匹配第一个方法
    System.out.println(mc.calculate(1.1,2));//3匹配第三个方法
  }
}
class MyCalculator
{
  //下面四个calculate方法构成了重载
  //两个整数的和
  public int calculate(int n1, int n2)  
  {
    return n1+n2;
  }
  //一个整数，一个 double 的和
  public double calculate(int n1, double n2) 
  {
    return n1+n2;
  }
  //一个 double ,一个 Int 和 
  public double calculate(double n1, int n2)
  {
    return n1+n2;
  }
  //三个 int 的和
  public int calculate(int n1, int n2,int n3)
  {
    return n1+n2+n3;
  }
}

3. 注意事项和使用细节 229

3.1 练习

3.1.1 判断 230

3.1.2 编程题 例1 231

编写程序，类 Methods 中定义三个重载方法并调用。方法名为 m。 三个方法分别接收一个 int 参数、两个 int 参数、一个字符串参数。分别执行平方运算并输出结果， 相乘并输出结果，输出字符串信息。在主类的 main ()方法中分别用参数区别调用三个方法 4

public class Test31
{
  public static void main(String[] args)
  {
    Methods mc = new Methods();
    mc.m(10);//100
    mc.m(10,20);//200
    mc.m("中国，hello");//中国，hello
  }
}
class Methods
{
  //分析
  //1 方法名 m 
  //2 形参 (int) 
  //3.void
  public void m(int n)
  {
    System.out.println("平方="+(n*n));
  }

  //分析
  //1 方法名 m
  //2 形参 (int,int) 
  //3.void
  public void m(int n1,int n2)
  {
    System.out.println("相乘="+(n1*n2));
  }

  //分析
  //1 方法名 m
  //2 形参 (String) 
  //3.void
  public void m(String str)
  {
    System.out.println("传入的str="+str);
  }
}

3.1.3 编程题 例2 232

定义三个重载方法 max()，第一个方法，返回两个 int 值中的最大值， 第二个方法，返回两个 double 值中的最大值，第三个方法， 返回三个 double 值中的最大值，并分别调用三个方法

public class Test31
{
  public static void main(String[] args)
  {
    Methods mc = new Methods();
    System.out.println(mc.max(10,24));//24
    System.out.println(mc.max(10.0,21.4));//21.4
    System.out.println(mc.max(10.0,1.4,30.0));//30.0
  }
}
class Methods
{
  //分析
  //1 方法名 max 
  //2 形参 (int,int) 
  //3.int
  public int max(int n1,int n2)
  {
    return n1>n2?n1:n2;
  }

  //分析
  //1 方法名 max 
  //2 形参 (double,double) 
  //3.double
  public double max(double n1,double n2)
  {
    return n1>n2?n1:n2;
  }

  //分析
  //1 方法名 max 
  //2 形参 (double,double,double) 
  //3.double
  public double max(double n1,double n2,double n3)
  {
    //先比较前两个
    double max1 = n1>n2?n1:n2;
    //在比较
    return  max1>n3?max1:n3;
  }
}

4. 可变参数基本概念

java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。

就可以通过可变参数实现

4.1 基本语法

访问修饰符 返回类型 方法名(数据类型... 形参名) {

}

4.2 例 233

看一个案例 类 HspMethod，方法 sum 【可以计算 2 个数的和，3 个数的和 ， 4，5， 。。】

//看一个案例 类 HspMethod，方法 sum 【可以计算 2 个数的和，3 个数的和 ， 4，5， 。。】 
public class Test32
{
  public static void main(String[] args)
  {
    HspMethod m = new HspMethod();
    System.out.println("和="+m.sum(1,3,5));//9
    System.out.println("和="+m.sum(1,19));//20
  }
}

class HspMethod
{
  //可以计算 2 个数的和，3 个数的和 ， 4， 5， 。。
  //可以使用方法重载
  // public int sum(int n1,int n2)//2个数的和
  // {
  //  return n1+n2;
  // }
  // public int sum(int n1,int n2，int n3)//3个数的和
  // {
  //  return n1+n2+n3;
  // }
  // public int sum(int n1,int n2,int n3,int n4)//4个数的和
  // {
  //  return n1+n2+n3+n4;
  // }

  //..... //上面的三个方法名称相同，功能相同, 参数个数不同-> 使用可变参数优化 
  //解读 
  //1. int... 表示接受的是可变参数，类型是 int ,即可以接收多个 int(0-多) 
  //2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组 
  //3. 遍历 nums 求和即可
  public int sum(int...nums)
  {
    //System.out.println("接受的参数个数="+nums.length);
    //把nums看成数组
    //遍历
    int ret = 0;
    for(int i=0;i<nums.length;i++)
    {
      ret+=nums[i];
    }
    return ret;
  }
}

5. 可变参数的注意事项 234

例1

2.1 可变参数的实参可以是数组

2.2 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后

2.3 一个形参列表中只能有一个可变参数

public class Test32
{
  public static void main(String[] args)
  {
    int arr[]={1,2,3};
    T t1 = new T();
    //可变参数的实参可以是数组
    t1.f1(arr);//编译通过
  }
}
class T
{
  public void f1(int...nums)
  {
    System.out.println("长度="+nums.length);
  }

  //细节: 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
  public void f2(String str,double...nums)//编译通过
  {

  }
          //一个形参列表中只能有一个可变参数
  public void f3(int...nums1,double...nums2)//错误
  {

  }
}

6. 可变参数练习 235

有三个方法，分别实现返回姓名和两门课成绩(总分)， 返回姓名和三门课成绩(总分)，返回姓名和五门课成绩（总分）。 封装成一个可变参数的方法

public class Test32
{
  public static void main(String[] args)
  {
    Method m = new Method();
    System.out.println(m.showScore("张三",90.1,80.0));
    System.out.println(m.showScore("李四",90.1,80.0,10));
    System.out.println(m.showScore("王五",90.1,80.0,10,30.5,70));
  }
}
class Method
{
  //分析 1. 方法名 showScore 2. 形参(String ,double... ) 3. 返回 String
  public String showScore(String name,double...scores)
  {
    //遍历求总成绩
    double totalscore = 0;
    for(int i=0;i<scores.length;i++)
    {
      totalscore+=scores[i];
    }
    return name+"有"+scores.length+"门课的成绩总分为="+totalscore;
  }
}

7. 作用域 236

7.1 基本概念

//作用域
public class Test32
{
  public static void main(String[] args)
  {
    
  }
}
class Cat
{
  //全局变量：也就是属性，作用域为整个类体 Cat 类：cry eat 等方法使用属性 
  //属性在定义时，可以直接赋值 
  int age = 10; //指定的值是 10

  //全局变量(属性)可以不赋值，直接使用，因为有默认值， 
  double weight; //默认值是 0.0
  
  //局部变量必须赋值后，才能使用，因为没有默认值
  public void hi()
  {
    int num;
    String address;
    System.out.println("num="+num);//报错
    System.out.println("address="+address);//报错
    System.out.println("weight="+weight);//正确
  }


  public void eat()
  {
    System.out.println("在eat中使用属性 age="+age);
  }

  public void cry()
  {
    //1. 局部变量一般是指在成员方法中定义的变量
    //2. n 和 name 就是局部变量 
    //3. n 和 name 的作用域在 cry 方法中
    int n = 10;
    String name = "jack";
    System.out.println("在cry中使用属性 age="+age);
  }
}