【05】JAVASE-方法讲解【从零开始学JAVA】

用户4919348

发布于 2024-05-25 13:57:49

330

发布于 2024-05-25 13:57:49

文章被收录于专栏：波波烤鸭波波烤鸭

Java零基础系列课程-JavaSE基础篇

Lecture：波哥

Java 是第一大编程语言和开发平台。它有助于企业降低成本、缩短开发周期、推动创新以及改善应用服务。如今全球有数百万开发人员运行着超过 51 亿个 Java 虚拟机，Java 仍是企业和开发人员的首选开发平台。

五、方法讲解

1. IDEA导入项目

实现准备了一个小游戏的案例，导入IDEA中运行，导入的方式 File --》 Open

导入后调整下jdk环境的设置

打开后乱码，提示修改编码方式

运行即可

2.方法概念的引入

2.1 方法和没有使用方法的对比

没有使用方法的情况

package com.bobo.funcation;

public class FunDemo01 {

	/**
	 * 为什么要使用方法
	 * @param args
	 */
	public static void main(String[] args) {
		// 在控制台输出 1 到 100的偶数
		for (int i = 1 ; i <= 100 ; i++) {
			if(i % 2 == 0){
				System.out.println(i);
			}
		}
		// 在控制台输出300 到500的偶数
		for (int i = 300 ; i <= 500 ; i++) {
			if(i % 2 == 0){
				System.out.println(i);
			}
		}
		// 在控制台输出200 到1000的偶数
		for (int i = 200 ; i <= 1000 ; i++) {
			if(i % 2 == 0){
				System.out.println(i);
			}
		}
	}

}

使用方法的情况

package com.bobo.funcation;

public class FunDemo02 {

	/**
	 * 为什么要使用方法
	 * @param args
	 */
	public static void main(String[] args) {
		// 在控制台输出 1 到 100的偶数
		printEven(1, 100);
		// 在控制台输出300 到500的偶数
		printEven(300, 500);
		// 在控制台输出200 到1000的偶数
		printEven(200, 1000);
	}
	
	/**
	 * 我们定义的第一个方法
	 *    作用：输入 x 到 y之间的所有的偶数
	 * @param x
	 * @param y
	 */
	public static void printEven(int x,int y){
		for (int i = x ; i <= y ; i++) {
			if(i % 2 == 0){
				System.out.println( i);
			}
		}
	}

}

2.2 方法的概念

一段用来完成特定功能的代码片段

/**
	 * 我们定义的第一个方法
	 *    作用：输入 x 到 y之间的所有的偶数
	 * @param x
	 * @param y
	 */
public static void printEven(int x,int y){
    for (int i = x ; i <= y ; i++) {
        if(i % 2 == 0){
            System.out.println( i);
        }
    }
}

2.3 为什么使用方法

程序中多次使用到的功能
便于程序的阅读
提供程序的重用性

在其他语言中，方法又称为函数

3.方法的定义

3.1 方法的语法规则

访问修饰符 返回值类型  方法名称(参数类型 参数1 , 参数类型 参数2 ...){
    方法体;
    return 返回值;
}

访问修饰符: 暂时使用 public static.后面我们会在面向对象的课程中详细介绍这部分的内容

返回值类型:该方法的返回结果的数据类型，可以是八大基本数据类型也可以是引用类型[后面介绍]

方法名称:自定义的，符合标识符的命名规则即可，见名知意

参数：表明该方法要完成特定功能所需要的支持

实际参数【实参】：水果榨汁机案例中，具体放进榨汁机中的水果，比如苹果，西瓜等。

方法调用时的参数，也就是实际参与运算的参数

形式参数【形参】：水果榨汁机案例中，这个机器在设计的时候定义的外部要给与的类型

方法定义时的参数，用于接收实际的参数。

参数类型：参数的数据类型，可以是八大基本数据类型和引用类型

参数名：就是变量名，满足标识符的命名规则几个

方法体：就是完成特定功能的代码，具体根据需求来确定

返回值：方法特定功能的结果，通过过return返回给调用者的，哪里调用的就返回到哪里去

3.2 方法的具体实现

3.2.1 方法写在哪？

// 位置 5
public class FunDemo03 {
	
	// 位置 1
	
	public static void main(String[] args) {
		// 位置 2

	}
	// 位置 3

}
// 位置 4

首先方法和方法是平级的关系，main方法也是一个方法，所以方法是不能写在main方法中的
方法只能定义在类以内。不能单独的写到类以外
一个类中可以包含任意个方法，没有先后顺序

3.2.2 课堂案例

1.求两个数之和

/**
	 * 求两个数之和
	 * @param x 
	 * @param y
	 * @return
	 */
public static int add(int x,int y){
    int sum = x + y; // 方法体
    return sum;
}

2.键盘录入年份判断是否是闰年

package com.bobo.funcation;

import java.util.Scanner;

public class FunDemo05 {

	/**
	 * 键盘录入年份判断是否是闰年
	 *   1.把方法的基本结构定义出来
	 *   2.根据得到的年份实现闰年判断的逻辑
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.println("请输入一个年份:");
		int year = in.nextInt();
		boolean flag = isLeapYear(year);
		if(flag){
			System.out.println(year + "是闰年");
		}else{
			System.out.println(year + "不是闰年");
		}
			

	}
	
	/**
	 * 判断 year 是否是闰年
	 * 闰年的规则：
	 *    1.year能被4整除同时year不能被100整除
	 *    2.或者year能被400整除
	 * @param year
	 * @return
	 */
	public static boolean isLeapYear(int year){
		if((year % 4 == 0 && year % 100 != 0 ) || year % 400 == 0){
			// 表示满足闰年的条件
			return true;
		}
		return false;
	}

}

3.键盘录入数据，返回两个数中较大的值

package com.bobo.funcation;

import java.util.Scanner;

public class FunDemo06 {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.println("请输入两个要比较的整数:");
		int x = in.nextInt();
		System.out.println("再输入一个：");
		int y = in.nextInt();
		int max = max(x, y);
		System.out.println(x + " 和 " + y +"中值大的是："+ max);

	}
	
	// 键盘录入数据，返回两个数中较大的值
	public static int max(int i , int j){
		/*if(i >= j){
			return i;
		}
		return j;*/
		return i >= j ? i : j;
	}

}

4.输出1到100之间的所有的素数

package com.bobo.funcation;

public class FunDemo07 {

	public static void main(String[] args) {
		for(int i = 2; i < 100; i ++){
			// 调用方法判断是否是素数
			if(isPrimeNumber(i)){
				System.out.println(i);
			}
		}

	}

	/**
	 * 输出1到1000之间的所有的素数
	 * 比1大的整数中，除了1和它本身以外，不再有别的因数，这种整数叫做 质数或者素数
	 * i = 7  7%2 7%3  7%4  7%5  7%6
	 * i=23   23%2 23%3 .... 23%22 
	 * @param num
	 * @return
	 */
	public static boolean isPrimeNumber(int num){
		boolean isPrime = true; // 默认是素数
		// 让 num 对 2到num-1 取余，如果结果都不为0说明是素数否则不是
		for(int j = 2 ; j <= num/2 ; j++){
			if(num % j == 0){
				// 说明不是素数
				isPrime = false;
				break;
			}
		}
		return isPrime;
	}
	
}

输出的结果：

3.3 方法的调用

方法在定义完成之后，如果没有被调用是永远不会执行的！main方法之所以不会被调用，是因为main方法是由Java虚拟机调用的，main方法是程序的唯一入口。

方法的调用三要素：

需要什么类型的参数就传什么类型的参数
返回什么类型的值就拿什么类型的变量来接收
实参的数目、数据类型、和次序必须和调用方法声明的形参列表匹配

方法的调用的三种方式

输出调用：输出调用适用于直接显示结果
赋值调用：适用于有返回结果的，并且返回值可以后续继续使用
直接调用：适用于没有返回值，只需要执行方法即可

方法如果没有返回结果，可以省略掉return 关键字；

public static void show(){
    System.out.println("HelloWorld");
    return ;
}

4.方法的重载

在一个类中可以定义有相同名称，但参数列表不同的多个方法，调用的时候会根据不同的参数列表类选择对应的方法。

参数列表不同：参数的个数，顺序，类型不同

重载的特点：

发生在同一个类中
方法名称相同
参数列表不同(类型、个数、顺序)
和返回类型没有关系

public class FunDemo08 {
    /**
     * 方法的重载
     *   1.方法名称相同
     *   2.方法参数列表不同
     *       参数个数
     *       参数类型
     *       参数顺序
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(add(1,2));
        System.out.println(add(2,3,4));
        System.out.println(add(12.3,45.6));
        System.out.println(add(2.3,6));
    }

    /**
     * 两个int类型的求和
     * @param a
     * @param b
     * @return
     */
    public static int add(int a,int b){
        return a + b;
    }

    public static double add(double d1 ,double d2){
        return d1 + d2;
    }

    public static double add(double d1 ,int d2){
        return d1 + d2;
    }
    public static double add(int d1 ,double d2){
        return d1 + d2;
    }
    public static int add(int a ,int b,int c){
        return a + b + c;
    }
}

相关面试题：介绍下Java中的重写和重载的区别？

5.递归

5.1 什么是递归

方法中调用本地方法，自己调用自己

5.2 递归的注意事项

递归一定要有出口，否则很容易出现死递归，走不出来，类似死循环
递归的次数太多，容易出现内存溢出的情况
构造方法不能递归【后面的内容】

5.3 递归的案例

5.3.1 n的阶乘计算

package com.bobo.funcation;

public class FunDemo11 {

	/**
	 * 求n的阶乘   5 ！  5*4*3*2*1
	 * @param args
	 */
	public static void main(String[] args) {
		//System.out.println(getFactorial(10));
		System.out.println(getFactorialRecursion(10));
	}
	
	/**
	 * 通过递归的方式来实现N的阶乘计算
	 * 分析 递归的出口
	 * 5!=5*4!=5*4*3!
	 * @param num
	 * @return
	 */
	public static int getFactorialRecursion(int num){
		if(num < 0){
			return 0;
		}
		// 先确定递归的出口
		if( num == 0 || num == 1){
			return 1;
		}else{
			return num * getFactorialRecursion(num-1);
		}
	}
	
	
	/**
	 * 普通的获取num的阶乘
	 * @param num
	 * @return
	 */
	public static int getFactorial(int num){
		if(num <=0 ){
			return 0;
		}
		int factorial = 1;
		for( int i = 1 ; i <= num;i++){
			factorial *= i;
		}
		return factorial;
	}
	

}

5.3.2 斐波拉契数列

斐波拉契数列，又称黄金分割数列，因数据集列昂多.斐波拉契以兔子繁殖为例而引入，又称为"兔子数列"

1 1 2 3 5 8 13 21 34 …

计算第N个位的值是多少

package com.bobo.funcation;

public class FunDemo12 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(getFibonacci(9));
	}
	/**
	 * 获取斐波拉契数列
	 * @return
	 */
	public static int getFibonacci(int n){
		// 定位到 出口
		if(n == 1 || n == 2){
			return 1;
		}
		
		return getFibonacci(n-1) + getFibonacci(n-2);
	}

}

实现过程分解：