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

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

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

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

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

//看一个案例 类 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;inums.length;i++)
    {
      ret+=nums[i];
    }
    return ret;
  }
}

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)//错误
  {

  }
}

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;iscores.length;i++)
    {
      totalscore+=scores[i];
    }
    return name+"有"+scores.length+"门课的成绩总分为="+totalscore;
  }
}

//作用域
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);
  }
}