什么是对象，可变参数，重载，递归

1.类和对象

• 1.一个方法可以有0个参数，也可以有多个参数，中间用，隔开
• 2.参数类型可以为任意类型，基本数据类型还有引用数据类型
• 3.调用参数方法的时候，一定要对应着我们的参数列表，传入相同的和兼容的
• 4.定义的时候称为行参，调用的时候称为实参
• 6.同一个类中调用方法直接调用就行了
• 7.不同类中去调用方法，需要用对象名来调用
• 8.跨类方法的调用和访问修饰符有关

public class Class04 {
    public static void main(String[] args) {
        //如何去创建对象
        //1.先声明在创建
        AA aa;//先声明aa
        aa=new AA();//创建
        //2.直接创建
        AA aa1=new AA();
        //如何访问属性？ 对象名.属性名
    }
}
class AA{
    int id;
}

2.可变参数：

• 基础语法：访问修饰符 返回类型 方法名（数据类型…行参名）{}
• 注意事项：
• 1.可变参数的实参，可以为0个或者多个
• 2.可变参数的实参可以为数组
• 3.可变参数的本质就是一个数组
• 4.可变参数在最后
• 5.一个行参列表里面只能够出现一个可变参数

/**
 *有三个方法，分别实现返回姓名和两门成绩总分，返回姓名和三门成绩的总分，返回姓名和五门成绩的总分，封装成一个可变参数的方法！
 */
public class Print02 {
    public static void main(String[] args) {
        MeThed meThed = new MeThed();
        System.out.println(meThed.showScore("张鑫", 80, 90));
        System.out.println(meThed.showScore("张鑫", 100, 90, 120));
        System.out.println(meThed.showScore("张鑫", 100, 120, 130, 140, 150));
    }
}

class MeThed {
    public String showScore(String name, double... scores) {
        double MyScores = 0;
        for (int i = 0; i < scores.length; i++) {
            MyScores += scores[i];
        }
        return name + "有" + scores.length + "门课成绩的总分为" + MyScores;
    }
}

3.方法的重载 overload

• 减轻了起名的麻烦 减轻了记名的麻烦

• 在同一个类里面，允许存在一个以上同名方法

• 注意事项和使用细节

  • 1.方法名 必须相同
  • 2.行参列表 必须不同
  • 3.与返回值无关，只看参数列表。
  • 4.返回类型 无要求

  public class Overload01 {
      public static void main(String[] args) {
          MyCalculator myCalculator = new MyCalculator();
          System.out.println(myCalculator.num(4, 5));
          System.out.println(myCalculator.num(7, 5));
          System.out.println(myCalculator.num(5, 7.8));
          System.out.println(myCalculator.num(1, 2, 3));
      }
  }
  
  class MyCalculator {
      //两个整数的和
      public int num(int n1, int n2) {
          System.out.println("int num(int n1,int n2)会被调用");
          return n1 + n2;
      }
  
      //一个double和一个int的和
      public double num(double n1, int n2) {
          System.out.println("double num(double n1,int n2)会被调用");
          return n1 + n2;
      }
  
      //一个int和一个double的和
      public double num(int n1, double n2) {
          System.out.println("double num(int n1,double n2)会被调用");
          return n1 + n2;
      }
  
      //三个int的值相加
      public int num(int n1, int n2, int n3) {
          System.out.println("int num(int n1,int n2,int n3)会被调用");
          return n1 + n2 + n3;
      }
  }
  

  4.方法的递归

• 1.当执行一个方法的时候，就会创建一个新的受保护的独立空间

• 2.方法的局部变量是独立的，不会相互影响，

• 3.如果方法中使用的引用数据类型，（数组，对象），就会共享该引用类型的数据

• 4.递归必须项推出递归的条件逼近，否则就会无限递归，出现死归

• 5.执行完毕之后，遇到return，就会返回，

• 6.必须满足两个条件

  ​ （1）有边界，即终止条件

  ​ （2）需要调用自己

  递归中不是必须要有return，比如

  public void test(int n) {
          if (n > 1) {
              test(n - 1);
          }
          System.out.println(n);
      }
  

  递归的实例

  猴子吃桃子问题:有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个! 以后每天猴子都吃其中的一半，然后再多吃一个。当到第 10 天时，想再吃时(即还没吃)，发现只有1个桃子了。问题:最初共多少个桃子?

  思路：逆推
  1.day=10 有1个桃子
  2.day=9 有（day10+1）* 2=4
  3.day=8 有（day9+1）* 2= 10
  4.规律就是前一天的桃子=（后一天的桃子+1）*2
  5.递归

    //求第day天有多少个桃子
	public int peach(int day) {
        if (day == 10) {//-1
            return 1;
        } else if (day >= 1 && day <= 9) {
            return (peach(day + 1) + 1) * 2;
        } else {
            System.out.println("day在1-10");
            return -1;
        }
    }