0422方法深入

方法

文章概述

1.return关键字及return的作用？//2点
2.方法分析 分为4步？//
3.文档注释return关键字内容？//类型，内容
4.方法调用过程及调用以后的数据处理方式？//
5. @param的解释？//变量名，类型，及作用
6.局部变量定义，作用域，生存期？
7.变量未定义会怎样？

1. 返回值【难点】

1.2 代码中返回值需要使用的关键字

return 
	返回
作用：
	1. 结束当前方法的执行
	2. 返回return之后的数据，到方法之外，要求返回值的数据和方法声明位置告知调用者的返回值数据类型一致
	【数据类型一致化】

1.3 完成一个无参数有返回值的方法

1.3.1 方法分析

需求
	give me five
	返回一个5

方法分析:
	固定格式:
		public static 不要问
	返回值类型【重点】:
		返回值是一个5， 5是什么数据类型？
		int类型
	方法名:
		giveMeFive 
	形式参数列表:
		这里是返回一个数据5，不需要参数
		()

方法声明：
	public static int giveMeFive()

1.3.2 方法实现和文档注释

/*
@return 
	在文档注释中告知调用者，当前方法的返回值是什么类型，怎么解释，什么含义
*/
/**
* 该方法返回一个5，一个整数
*
* @return 返回一个整数5
*/
public static int giveMeFive() {
    return 5;
}

1.3.3 方法调用过程

class Method1 {
	public static void main(String[] args) {
		/*
		调用一个带有返回值的方法
			返回值怎么用？？？
			赋值，运算，打印
			
			方法的返回值返回到之外，调用者决定当前结果的
			使用方式。
		*/
		int ret = 0;
		
		System.out.println("调用方法之前 ret : " + ret);
		
		ret = giveMeFive();
		System.out.println("直接调用方法：" + giveMeFive());
		
		System.out.println("调用方法之后 ret : " + ret);
	}
	
	/**
	* 该方法返回一个5，一个整数
	*
	* @return 返回一个整数5
	*/
	public static int giveMeFive() {
		return 5;
	}
}

1.3.4 执行过程图例

1.3.5 小总结

1. 返回值使用的关键字 return关键字
2. 带有返回值的方法，需要在文档注释中加入@return 告知调用者方法返回值的类型，含义...
3. 方法返回值类型和方法体内返回数据的类型必须一致，如果不一致报错，【数据类型一致化】
4. 方法的返回值处理方式，由程序员自己决定，因为我们现在只会sout，但是不代表只有sout。后期数据的处理方式有很多，传递，展示，发送，保存。。。。

1.3.6 小练习

/*
无参数有返回值的方法
需求:
	返回值一个大写字符 'A'

方法分析:
	固定格式:
		public static 
	返回值类型:
		返回值数组为大写字符'A'
		char类型数据
	方法名：
		giveMeLetter
	形式参数列表:
		方法需要返回一个字符A，不需要参数
		()
方法声明:
	public static char giveMeLetter()
*/

/**
* 该方法返回一个大写字符 'A'
*
* @return 返回值类型为char类型，返回的数据是一个大写字符 'A'
*/
public static char giveMeLetter() {
	return 'A';    
}

class Method2 {
	public static void main(String[] args) {
		char ch = 'a';
		
		System.out.println("方法运行之前 ch : " + ch);
		ch = giveMeLetter();
		System.out.println("方法运行之后 ch : " + ch);
	}
	
	/**
	* 该方法返回一个大写字符 'A'
	*
	* @return 返回值类型为char类型，返回的数据是一个大写字符 'A'
	*/
	public static char giveMeLetter() {
		return 'A';    
	}		
}

1.4 完成一个有参数有返回值的方法

1.4.1 方法分析

/*
需求:
	计算两个int类型数据之和，通过返回值返回到方法外
	1. 可以从需求中获取到当前方法需要两个参数
	2. 方法的返回值可以考虑使用int类型，或者long类型

方法分析:	
	固定格式:
		public static 不要问
	返回值类型:
		int 可以使用，没有问题，符合人之常情的理解
		long 可以满足如果出现两个int类型数据相加之后，结果超出了int类型范围，可
			以使用long
	方法名:
		 getSumOfTwoNumber
		 小驼峰命名法，见名知意，动宾结构
	形式参数列表:
		两个int类型数据之和，多个参数的情况下使用 逗号隔开
		(数据类型1 参数名1, 数据类型2 参数名2 ...)
		(int num1, int num2) 正确格式

方法声明:
	public static int getSumOfTwoNumber(int num1, int num2)
*/

1.4.2 方法实现和文档注释

/**
* 该方法是传入两个int类型的数据，返回值是两数之和
*
* @param num1 int类型数据
* @param num2 int类型数据
* @return 返回值类型为int类型，是两个int类型数据之和
*/
public static int getSumOfTwoNumber(int num1, int num2) {
    return num1 + num2;
}

1.4.3 方法调用过程

class Method3 {
	public static void main(String[] args) {
		/*
		当前方法需要两个参数，并且有返回值
		这里需要参数类型是int类型，给予当前方法两个int类型
		实际参数
		调用带有多参数的方法，要求传入的参数数据类型，个数和
		顺序必须和方法声明一致
		*/
		int sum = 0;
		
		System.out.println("方法运行之前 sum : " + sum);
		sum = getSumOfTwoNumber(30, 20);
		System.out.println("方法运行之后 sum : " + sum);
		
	}
	
	/**
	* 该方法是传入两个int类型的数据，返回值是两数之和
	*
	* @param num1 int类型数据
	* @param num2 int类型数据
	* @return 返回值类型为int类型，是两个int类型数据之和
	*/
	public static int getSumOfTwoNumber(int num1, int num2) {
		return num1 + num2;
	}
}

1.4.4 小总结

调用带有多参数的方法，要求传入的参数数据类型，个数和顺序必须和方法声明一致

1.5 操练起来

/*
要求:
	1. 方法功能单一化!!!越单一越好!!!
		a. 可移植性更高
		b. 复用度更强
		c. 模块更加明确
		参考生活中:
			乐高，游戏<<我的世界>>
			
	2. 不允许在方法中使用Scanner从键盘上获取数据!!!
		a. 不符合方法功能单一化
		b. Scanner不是我们后期开发的核心知识点
*/

class Method4 {
	public static void main(String[] args) {
		int max = maxOfNumber(30, 20);
		
		System.out.println("Max : " + max);
	}
	
	/**
	* 该方法是返回两个整数里的较大那个
	*
	* @param num1 int类型数据
	* @param num2 int类型数据
	* @return 两个int类型数据中较大的一个，如果相同返回任意一个
	*/
	public static int maxOfNumber(int num1, int num2) {
		/*
		当前方法体是存在两个return，而在开发中return的使用是需要有一些
		注意事项
			尽量减少return的使用 增强阅读性，代码逻辑更加明确
		
		if (num1 > num2) {
			return num1;
	    } else {
			return num2;
	    }
		*/
		
		/*  
		当前写法是没有问题，而且使用到假设的思想，可以提供代码的
		阅读性，并且简化代码逻辑，减少return使用
		
		int max = num1;
		
		if (max < num2) {
			max = num2;
		}
		
		return max;
		*/
		/*
		三目运算符/条件运算符
			条件 ? true处理方式 : false处理方式;
			简化版，功能缺失版 if else结构
		建议:
			在一些简单的逻辑中可以使用，提高一定的效率
		*/
		return num1 > num2 ? num1 : num2;
	}
}

class Method5 {
	public static void main(String[] args) {
		double min = minOfNumber(4.5, 3.8);
		System.out.println(min);
		
		boolean ret = isMyUpper('Z');
		System.out.println(ret);
	}
	
	/**
	* 返回两个浮点数里的较小那个
	* 
	* @param num1 double类型数据
	* @param num2 double类型数据
	* @return 两个浮点数里的较小那个
	*/
	public static double minOfNumber(double num1, double num2) {
		return num1 < num2 ? num1 : num2;
	}

	/**
	* 封装一个方法，来判断一个字符是否是大写字母
	* 如果是，返回true,否则返回false
	*
	* @param c 字符类型数据
	* @return 如果字符是大写字母返回true，否则返回false
	*/
	public static boolean isMyUpper(char c) {
		return c >= 'A' && c <= 'Z';
	}
}

class Method6 {
	public static void main(String[] args) {
		System.out.println(isMyNumber('a'));
		System.out.println(isMyEnglish('1'));
	}
	
	/**
	* 封装一个方法，来判断一个字符是否是数字字符
	* 如果是，返回true，否则返回false!
	*
	* @param c 字符类型数据c
	* @return 如果是数字字符，返回true,否则返回false
	*/
	public static boolean isMyNumber(char c) {
		return c >= '0' && c <= '9';
	}

	/**
	* 封装一个方法，来判断一个字符是否是英文字母
	* 如果是，返回true,否则返回false! 
	*
	* @param c 字符类型的数据c
	* @return 如果是英文字母返回true，否则返回false
	*/
	public static boolean isMyEnglish(char c) {
		return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'); 
	}
}

class Method7 {
	public static void main(String[] args) {
		System.out.println(toMyLower('D'));
		
		reverse(7654321);
	}
	
	/**
	* 封装一个方法，传入一个字符，如果是大写那么转化小写然后返回，否则保持不变返回
	*
	* @param c char字符类型数据
	* @return 如果是大写字母转换为小写字母返回，否则不变
	*/
	public static char toMyLower(char c) {
		if (c >= 'A' && c <= 'Z') {
			// c += 32; // 正确操作
			c += ('a' - 'A'); // 更推荐
		}
		
		return c;
	}

	/**
	* 封装一个方法，实现将一个正整数，倒序打印输出! 1234 4321 
	*
	* @param number 传入一个int类型数据
	*/
	public static void reverse(int number) {
		while (number > 0) {
			System.out.print(number % 10);
			number /= 10;
		}
	}
}

class Method8 {
	public static void main(String[] args) {
		isPositiveNumber(1000);
	}
	
	/**
	* 表达式（立方） 编写程序，计算该数的立方
	*
	* @param number 传入参数是一个double类型数据
	* @return  double类型返回值，这里使用double类型数据是
	*			防止数据溢出
	*/
	public static double cube(double number) {
		return number * number * number;
	}

	/**
	* 输入一个年份，判断该年份是平年还是闰年,如果是返回 true  不是返回false
	* 
	* @param year 传入一个年份，int数据类型
	* @return 如果是闰年返回一个true，不是闰年返回false
	*/
	public static boolean isLeap(int year) {
		return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
	}

	//表达式(正数判断)传入一个数字, 判断这个数是否是正数(是，打印YES，不是输出NO)
	public static void isPositiveNumber(int num) {
		// 不对！！！Java中三目运算符需要有结果产出，sout不是结果产出
		// num > 0 ? System.out.println("YES") : System.out.println("NO");
		/*if (num > 0) {
			System.out.println("YES");
		} else {
			System.out.println("NO");
		}*/
		
		// very good!!!
		System.out.println(num > 0 ? "YES" : "NO");
	}
} 

2 局部变量问题【小坑】

2.1 思考代码

class Method9 {
	public static void main(String[] args) {
        int num = 5;
        test(num);
        
        // 5 为什么是5
        System.out.println(num);
    }
    
    public static void test(int num) {
        num = 10;
    }
}

2.2 局部变量概念

局部变量概念
	除class大括号之外，其他大括号以内的变量都可以认为是一个局部变量。
	方法大括号以内，if分支结构以内，switch case结构大括号以内，循环大括号以内
	以上大括号以内全部都是【局部变量】
	
作用域
	当前局部变量能够使用的范围在什么地方
	局部变量有且只能在当前所处大括号以内使用，超出范围无法使用

	
生存期
	局部变量的生存期也在大括号以内，和作用域一致。

2.3 小题目

1. 
for (int i = 1; i <= 10; i++) {
    
}

System.out.println(i); // ??? 
Method10.java:7: 错误: 找不到符号
                System.out.println(i); // ???
                                   ^
  符号:   变量 i
  位置: 类 Method10
1 个错误

for (int i = 1; i <= 10; i++) {
    
}

for (int i = 1; i <= 10; i++) {
    
}
不冲突，两个for循环中，i循环变量分别属于不同的大括号以内，不同的作用域空间

for (int i = 1; i <= 10; i++) {
    for (int i = 1; i <= 10; i++) {
        
    }
}
冲突，在外层for循环中，已经定义了循环变量i,内层循环重新定义了循环变量，也是i，重复定义变量，冲突

for (int i = 1; i <= 10; i++) {
    if (i > 5) {
        int num = 10;
    }
	System.out.println(num);
}
System.out.println(num);
错误的！！！
    因为num变量定义在if 大括号以内，作用域和生存期有且只在if分支结构大括号以内，超出范围，无效！！！

2.4 总结

1. 关注局部变量的作用域和生存期范围，两者同步，并且都在对应的大括号以内
2. 变量未定义不能使用，要保证代码执行的，从上至下，从左至右原则