Java学习之方法

方法

方法声明格式：

调用方式：

详细说明

示例 --方法的声明及调用

语句块

练习

方法的重载(overload)

构成条件

示例 --方法重载

递归结构

缺陷

方法

方法(method)：一段用于完成特定功能的代码片段，类似于其他语言的函数(function)。

面向过程中，函数是最基本单位，整个程序由一个个函数调用组成
面向对象中，整个程序的基本单位是类，方法属于类和对象

方法声明格式：

[修饰符1 修饰符2 ...] 返回值类型方法名(形式参数列表){

Java 语句 ; ... ... ...

}

调用方式：

普通方法	对象名.方法名(实参列表)
静态方法	类名.方法名(实参列表)

详细说明

形式参数：在方法声明时用于接收外界传入的数据。(方法定义时)
实参：调用方法时实际传给方法的数据。(方法调用时)
返回值：执行完毕后，返还给调用它的环境的数据。
返回值类型：事先约定的返回值的数据类型，如无返回值，则为void。

示例 --方法的声明及调用

public class TestMethod {
    public static void main(String[] args) {
      sayLoveU();
      add(33,66,56) ;  // add(33,66,56)
      add(100,200,300); // 调用的是实参
    }

    public static void sayLoveU(){
      System.out.println("I Love U~");
      System.out.println("我爱你~");
      System.out.println("520~");
    }

    public static int add(int a, int b, int c){  // 定义时是形参
      int sum = a + b + c;
      System.out.println(sum);
      return sum;   // return 用于返回值及结束方法运行
    }
}

语句块

也叫复合语句，定义的变量只能用于自己，外部不能使用语句块的变量，但语句块可以使用外部的变量。

public class TestMethod {
    public static void main(String[] args) {

      int n;
      int i;
      {
        int j;
        int n; // 错误
      } // j 的作用域仅限于此
    }
}

练习

定义一个方法处理公司的迟到问题：

输入：迟到时间、月薪
处理逻辑：
- 迟到1-10分钟，警告
- 迟到11-20分钟，罚款100元
- 迟到21-30分钟，罚款200元
- 迟到30分钟以上，扣除半日工资
- 迟到一小时以上，按照旷工计算，扣3日工资
输出：罚款金额

public class TestLatePunish {
    public static void main(String[] args) {
     int a = punishLate(6000,5);
     int b = punishLate(6000,25);
     int c = punishLate(5000,55);
     int d = punishLate(6600,66);
     int punishSum = a + b + c + d;

      System.out.println("公司总罚款数是：" + punishSum);
    }

    public static int punishLate(int monthSalary, int time){
      int punishSalary = 0;
      System.out.println("你迟到的时间：" + time);
      System.out.println("你的月薪：" + monthSalary);
      if(time >= 1 && time <= 10){
        System.out.println("警告一次奥！再迟到罚钱啦！");
      }else if(time <= 20){
        monthSalary -= 100;
        punishSalary = 100;
        System.out.println("罚款:" + punishSalary);
        System.out.println("本月工资还剩：" + monthSalary);
      }else if(time <= 30){
        monthSalary -= 200;
        punishSalary = 200;
        System.out.println("罚款:" + punishSalary);
        System.out.println("本月工资还剩：" + monthSalary);
      }else if(time <= 60){
        monthSalary -= monthSalary / 30;
        punishSalary = monthSalary / 30 / 2;
        System.out.println("罚款：" + punishSalary);
        System.out.println("扣除半日工资！本月工资还剩：" + monthSalary);
      }else{
        monthSalary -= monthSalary / 30 * 3;
        punishSalary = monthSalary / 30 * 3;
        System.out.println("罚款：" + punishSalary);
        System.out.println("本月工资还剩：" + monthSalary);
      }
      return punishSalary;
    }
}

方法的重载(overload)

重载：一个类中可以定义多个名称相同，但形式参数列表不同的方法。

注：重载的方法，实际上是完全不同的方法，只是名称相同

构成条件

不同的含义：形参类型、形参个数、形参顺序不同
只有返回值不同不构成方法的重载
- eg：int a(String str()){} 与 void a(String str()){} 不构成重载
只有形参的名称不同，不构成方法的重载
- eg：int a(String t){} 与 int a(String s){} 不构成重载

示例 --方法重载

public class TestOverload {
    public static void main(String[] args) {
        add();
        add(10);
        add(10,20);
        add(33.56);
        add(33,56.33);
        add(33.56,66);

    }
// 以下是方法的重载：
    static void add(int a,int b){
    }
    static void add(int a){
    }
    static void add(){
    }
    static void add(double a){
    }
    static void add(double a,int b){
    }
    static void add(int b,double a){
    }

}

递归结构

递归是一种常见的算法思路，如：深度优先搜索等

包括以下两部分：

定义递归头：解决-- 什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归结束的条件。
递归体：解决-- 什么时候需要调用自身方法

示例 --使用递归求 n!

public class TestdiGui {
    public static void main(String[] args) {
      long startTime = System.currentTimeMillis();   // 获取当前时刻
      long result = factorical(10);
       long endTime = System.currentTimeMillis();   
      System.out.println(result);
      System.out.println(endTime - startTime);
    }

    public static long factorical(int n){
      if(n == 1){
        return 1;
      }else{
        return n * factorical(n-1);
      }
    }
}

// 使用循环求
   public static void main(String[] args) {
      int i = 10;
      int result = 1;
      for(int j = 0;j < i; j++) {
        if (i > 1) {
            result = result * i * (i - 1);
            i -= 2;   // 第一次 10*9，第二次减2：8*7 ....
        }
      }
      System.out.println(result);
    }