4方法

方法：解决事情的办法

作用：实现功能的办法

注意：方法定义在类中的方法 ，方法本身不能嵌套 方法不调用不执行 优点：提高了代码的复用性 提高了程序的安全性

语法：没有返回值类型的方法 修饰符void方法名（参数列表）{ 实现功能的代码段； [return；] }

有返回值类型的方法 修饰符 返回值类型 方法名（参数列表）{ 实现功能的代码段； return返回值； }

修饰符:访问权限的修饰符 目前为：public static 方法值：方法执行完毕之后是否需要得到一个结果（值） 结果值的数据类型：就是返回值类型方法的返回值类型 void：没有返回值类型的 方法名：标识符——>命名规则|规范 调用方法需要跟随方法名掉调用

参数列表：功能定义的时候是否存在位置的数据，有可能会改变的数据，如果存在定义在参数列表中 可以定义参数，可以不定义参数 参数：数据类型，参数名，数据类型，参数名.... 相当于局部变量的声明——>作用域只属于当前的方法| 数据类型：可以为基本数据类型|引用数据类型

{}：方法体 具体实现功能的代码段

return： 1.提出结束方法 2.带出返回值——>return返回值；

方法的调用： 执行方法中的代码 基础调用：方法名（参数列表）； 赋值调用：数据类型 变量名=方法名（参数列表）； 输出调用：System.out.println(方法名（参数列表）)； 赋值调用与输出调用关注返回值，接收使用了返回值，基础调用只是执行方法中的代码没有接收返回值

public class Class033_Method {
    //成员位置 : 类中方法外
    
    
    public static void main(String[] args) {
        //有返回值方法调用
         //基础调用
         getPi();
         //赋值调用
         double pi = getPi();
         System.out.println(pi);
         //输出调用
         System.out.println(getPi());
         
         System.out.println(getSum(3,5));
         System.out.println(getSum(7,5));
         
         //没有返回值方法调用
         //基础调用
         print();
         print();
         print();
         print();
    }
    
    //需求 : 返回pi的值
    //参数 : 没有参数
    //返回值 : 返回pi的值  double
    //方法名 : getPi
    public static double getPi(){
        System.out.println("没有参数有返回值类型的方法");
        return 3.1415926;
    }
    
    //需求 : 计算两个整数的和
    //参数 : int x,int y
    //返回值 : int
    //方法名 : getSum
    public static int getSum(int x,int y){
        System.out.println("有参数有返回值类型的方法");
        return x+y;
    }
    
    //需求 : 输出99乘法表
    //参数 : 没有
    //返回值 : 不需要
    //方法名 : print
    public static void print(){
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println();
        }
    }
    
}     

方法参数： 形式参数（形参）：定义方法的时候（）中的参数——>局部变量的声明 实际参数（实参）：调用方法的时候（）中的参数——>局部变量的赋值 形参与实参之间要求一一对应

public class Class035_Method{
    
    public static void main(String[] args) {
        int area = getArea(5,7);
        System.out.println(area);
    }
    
    
    //矩形面积
    public static int getArea(int w,int h){
        return w*h;
    }
}

4.1 return

return： 有返回值类型的方法中：必须存在return,同时需要带出返回值 1）提前结束方法 2）带出返回值返回给方法的调用出 没有返回值类型的方法中：可以存在return，但是不能带出返回值 1）提前结束方法

问：break，continue，return之间的区别 1）作用：break结束终止 continue跳过本次直接进入下一次 return终止返回 2）应用场景：break——>switch|循环 continue——>循环 return——>方法 兼容类型： 1.参数兼容类型： 形参类型>=实参类型

2.返回值兼容类型 ​ 接收返回值的变量类型>=方法的返回值类型>=return后面结果的类型

public class Class036_Return{
    
    public static void main(String[] args) {
        byte b = 1;
         i = test(b);
    }
    
    public static int test(int i){
        return 'a';
    }
}

4.2方法的重载

实现重载的三个条件： ​ 1.一个类中的多个方法 ​ 2.方法名相同 ​ 3.参数列表不同|方法签名不同 方法签名：方法的唯一标识 ​ 方法名+参数列表=方法签名

重载方法的调用： 根据实参区分

分析： 1.方法的重载与参数名无关 2.方法的重载与方法的修饰符无关 3.方法的重载与方法的返回值无关

总结:方法的重载只与方法名与参数列表有关 方法就是封装的体现

public class Class037_OverLoad{
    
    public static void main(String[] args) {
        getSum(3.0,5.0);
    }
    
    //求2个数的和 : 
    //返回值 
    //2个参数
    //getSum
    public static void getSum(int i,int j){
        System.out.println("两个int类型整数的和"+(i+j));
    }
    private  boolean getSum(int i,int j){
        System.out.println("两个int类型整数的和"+(i+j));
        return false;
    }
    
    public static void getSum(double i,double j){
        System.out.println("两个double类型的和"+(i+j));
    }
    public static void getSum(int i,double j){
        System.out.println("1个int1个double类型的和"+(i+j));
    }
    public static void getSum(double i,int j){
        System.out.println("1个double个int类型的和"+(i+j));
    }
}

4.3递归

递归 : (了解) 方法的内部自己调用自己

优点 : 程序设计更简单,简洁 缺点 : 使用不好,极有可能造成内存的溢出

实现组成: 基线条件|递归头 : 停止自己调用自己的条件 递归条件|递归体 : 自己调用自己

执行过程 : 1.递归前进段 : 不停的自己调用自己 2.临界条件 : 停止自己调用自己的条件 3.递归后退段 : 从临界条件开始,不停的将结果返回给上一层

public class Class039_Recurtion{
    
    public static void main(String[] args) {
        System.out.println(rec(-1));;
    }
    
    //求阶乘 : 求某一个数阶乘
    public static int rec(int i){
        if(i<=0){
            System.out.println("数据i为负数,不能求阶乘!!!");
            return 0;
        }
        if(i==1){
            return 1;
        }
        return i*rec(i-1);
    }
}