目录
方法
方法声明格式：
调用方式：
详细说明
示例 --方法的声明及调用
语句块
练习
方法的重载(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);
}
缺陷
会占用大量的系统堆栈，内存耗用多，递归调用层次多时速度要比循环慢得多
