静态方法
1. 方法的概念
概念：实现特定功能的一段代码，可反复使用。
2. 方法的定义格式
public static void 方法名称( ){ //方法主体 }
3.方法的定义位置
定义在类中，与main方法并列。
4. 方法的调用
在需要调用方法的位置直接书写方法名即可。
5. 编写方法优化诗句打印
package com.xxx.test4;
/**
* 使用方法优化诗句打印1
*/
public class TestMethod1 {
public static void main(String[] args) {
System.out.println("床前明月光");
printSign();
System.out.println("疑是地上霜");
printSign();
System.out.println("举头望明月");
printSign();
System.out.println("低头思故乡");
printSign();
}
public static void printSign(){
for(int i = 1;i <= 10;i++){
System.out.print("-");
}
System.out.println();
}
}
6. 单个参数
使用方法优化诗句打印2 : 使用单个参数让用户灵活的控制横线的个数
package com.xxx.test4;
/**
* 使用方法优化诗句打印2 : 使用单个参数让用户灵活的控制横线的个数
*/
public class TestMethod2 {
public static void main(String[] args) {
System.out.println("床前明月光");
int a = 10;
printSign(a); // 局部变量的赋值
System.out.println("疑是地上霜");
printSign(5);
System.out.println("举头望明月");
int b = 3;
int c = 5;
printSign(b + c); // 这种方式也可以 但是不推荐 因为可读性较差 很容易会误认为传入两个参数
System.out.println("低头思故乡");
printSign(10 * 2);
}
/**
*
* @param num 为形参 形参规定了参数的：个数、类型、顺序
*/
public static void printSign(int num){ // 局部变量的声明
for(int i = 1;i <= num;i++){
System.out.print("-");
}
System.out.println();
}
}
7. 多个参数
使用方法优化诗句打印3 : 使用多个参数让用户灵活的控制符号的个数 以及 符号的类型
package com.xxx.test4;
/**
* 使用方法优化诗句打印3 : 使用多个参数让用户灵活的控制符号的个数 以及 符号的类型
*/
public class TestMethod3 {
public static void main(String[] args) {
System.out.println("床前明月光");
int num = 4;
String s1 = "%";
printSign(num,s1); // num s1 实参 实际参数 调用方法实际传入的参数 必须遵循形参的规定
System.out.println("疑是地上霜");
printSign(10, "$"); // 10 $ 实参 实际参数 调用方法实际传入的参数 必须遵循形参的规定
System.out.println("举头望明月");
String s2 = "&";
printSign(5,s2); // 5 s2 实参 实际参数 调用方法实际传入的参数 必须遵循形参的规定
System.out.println("低头思故乡");
int number = 10;
printSign(number,"&");// // number & 实参 实际参数 调用方法实际传入的参数 必须遵循形参的规定
}
/**
* 形参：形式参数 表示方法定义的时候书写的参数 规定了参数的个数、类型、顺序
* @param count
* @param sign
*/
public static void printSign(int count , String sign){
for(int i = 1;i <= count;i++){
System.out.print(sign);
}
System.out.println();
}
}
8. 返回值和返回值类型
返回值引入 ：为什么需要返回值？
需求：编写方法计算两个int类型整数之和 并且在main方法判断最终的和是奇数还是偶数
package com.xxx.test5;
/**
* 返回值引入 ：为什么需要返回值？
*
* 需求：编写方法计算两个int类型整数之和 并且在main方法判断最终的和是奇数还是偶数
*/
public class TestReturnedValue1 {
public static void add(int a,int b){
System.out.println("a与b之和为：" + (a + b));
}
/**
* 返回值类型不是void 那么必须在方法体内 通过return关键字返回对应类型的数据 否则编译报错
* return 关键字表示 ：结束方法 并且 返回数据
* @param a
* @param b
* @return
*/
public static int addition(int a,int b){
System.out.println("a与b之和为：" + (a + b));
int sum = a + b;
return sum;
}
public static void main(String[] args) {
add(10, 20);
int sum = addition(13331, 22220);
if(sum % 2 == 0){
System.out.println("偶数");
}else{
System.out.println("奇数");
}
}
}
在分支结构中返回数据，必须保证每一条分支语句都有正确的返回值
需求：根据用户传入整数 判断是奇数还是偶数
package com.xxx.test5;
/**
* 在分支结构中返回数据，必须保证每一条分支语句都有正确的返回值
*
* 需求：根据用户传入整数 判断是奇数还是偶数
*/
public class TestReturnedValue2 {
public static String isEven1(int num){
if(num % 2 == 0){
return "偶数";
}else{
return "奇数";
}
}
public static String isEven4(int num){
if(num % 2 == 0){
return "偶数";
}
return "奇数";
}
public static String isEven7(int num){
return num % 2 == 0 ? "偶数" : "奇数";
}
public static boolean isEven2(int num){
if(num % 2 == 0){
return true;
}else{
return false;
}
}
public static boolean isEven5(int num){
if(num % 2 == 0){
return true;
}
return false;
}
public static boolean isEven8(int num){
return num % 2 == 0 ;
}
public static int isEven3(int num){
if(num % 2 == 0){
return 0;
}else{
return 1;
}
}
public static int isEven6(int num){
if(num % 2 == 0){
return 0;
}
return 1;
}
public static int isEven9(int num){
return num % 2;
}
}
在返回值类型为void的方法中 也可以使用return 只表示结束方法
不能返回任何内容
package com.xxx.test5;
/**
* 在返回值类型为void的方法中 也可以使用return 只表示结束方法
* 不能返回任何内容
*/
public class TestReturnedValue3 {
public static void show(){
for(int i = 1;i <= 10;i++){
if(i == 5){
return; // 注意和break的区别
}
System.out.println(i);
}
System.out.println("show方法执行完毕");
}
public static void main(String[] args) {
show();
}
}
9. 方法多级调用
多级调用：我们自定义的方法也可以互相调用 直接书写方法名即可
方法要进栈，栈遵循先进后出的顺序
package com.xxx.test6;
/**
* 多级调用：我们自定义的方法也可以互相调用 直接书写方法名即可
*
* 方法要进栈，栈遵循先进后出的顺序
*
*/
public class TestNestInvoke {
public static void main(String[] args) {
System.out.println("main方法开始执行");
m1();
System.out.println("main方法执行完毕");
}
public static void m1() {
System.out.println("m1 method start");
m2();
System.out.println("m1 method end");
}
public static void m2() {
System.out.println("m2 method start");
System.out.println("m2 method end");
}
}
10. 方法重载(method overload)
方法重载：同一个类中的方法 名称相同 参数列表(个数、类型、顺序)不同 这种现象即可称之为方法重载
跟返回值类型 访问权限修饰符 无关
方法重载属于静态多态
方法重载的优点：屏蔽使用差异 统一程序结构 灵活 方便
package com.xxx.test6;
/**
* 方法重载：同一个类中的方法 名称相同 参数列表(个数、类型、顺序)不同 这种现象即可称之为方法重载
* 跟返回值类型 访问权限修饰符 无关
*
* 方法重载属于静态多态
*
* 方法重载的优点：屏蔽使用差异 统一程序结构 灵活 方便
*/
public class TestMethodOverload {
public static int add(int a, int b) {
System.out.println(a + b);
return a + b;
}
public static double add(int c, String d) {
System.out.println(c + d);
return 2.5;
}
public static boolean add(String c, int d) {
System.out.println(c + d);
return true;
}
public static void add(int a, int b, int c) {
System.out.println(a + b + c);
}
public static void add(int a, int b, int d, int c) {
System.out.println(a + b + c + d);
}
public static void add(int a, int b, int c, int d, int e) {
System.out.println(a + b + c + d + e);
}
public static void add(int a, int b, int c, int d, int e, int f) {
System.out.println(a + b + c + d + e + f);
}
public static void main(String[] args) {
add(20, 30);
}
}
11. 递归
递归：递进和回归
递归可以简单的理解为：方法自己调用自己
递归
1.一个大的问题拆分为若干个小的问题
2.必须有结束的条件 否则将造成无穷递归(死循环)
举例：
赵四 刘能 大拿 小宝 广坤
需求：
1.实现 1 ~ n之和
2.阶乘
3.打印斐波那契数列
4.八皇后
5.汉诺塔问题
6.文件遍历
package com.xxx.test1;
/**
* 递归：递进和回归
* 递归可以简单的理解为：方法自己调用自己
*
* 递归
* 1.一个大的问题拆分为若干个小的问题
* 2.必须有结束的条件 否则将造成无穷递归(死循环)
*
* 举例：
* 赵四 刘能 大拿 小宝 广坤
*
*
* 需求：
* 1.实现 1 ~ n之和
* 2.阶乘
* 3.打印斐波那契数列
* 4.八皇后
* 5.汉诺塔问题
* 6.文件遍历
*
*/
public class TestRecursive {
public static void m1(){
m1();
}
public static int getSum5(){
return 5 + getSum4();
}
public static int getSum4(){
return 4 + getSum3();
}
public static int getSum3(){
return 3 + getSum2();
}
public static int getSum2(){
return 2 + getSum1();
}
public static int getSum1(){
return 1;
}
public static int getSum(int num){
if(num == 1){
return 1;
}
return num + getSum(num - 1);
}
public static int getFactorial(int num){
if(num == 1 ){
return 1;
}
return num * getFactorial( num - 1);
}
public static void main(String[] args) {
int sum5 = getSum5();
System.out.println("sum5 = " + sum5);
System.out.println(getSum(100));
System.out.println(getFactorial(5));
}
}
