方法
回顾
循环语句:
循环：重复执行一段代码，直到条件为false为止。
循环的组成:
(1) 循环变量初始化部分，int i=0
(2) 循环条件，如果为true，执行循环体，如果false不执行
(3) 循环体，重复执行的特定代码
(4) 更新循环变量部分
java中三个循环语句：
1.while(boolean条件){
...
}
先判断，再执行
2.do{
...
}while(boolean条件);
先执行，再判断
3.for(初始化变量;条件;更新循环变量){
...
}
先判断，再执行
三种循环比较：
1 语法不同
2 特点：while for 先判断 再执行 do while 先执行 再判断
3 循环次数固定优先 使用for , 不固定使用while do{} while();
二重循环:
循环中嵌套循环，
特点：外层执行一次，内层执行一遍。
(1)打印矩形
(2)打印直角三角形
(3)打印等腰三角形
(4)九九乘法表
跳转语句 :
break:
使用场合: switch 和循环中
作用:跳出(终止) switch和循环语句
continue:
使用场合:用在循环中
作用:跳过本次循环，继续下一次循环今天任务
1.方法
2.方法重载
3.递归算法教学目标
1.理解什么是方法
2.掌握方法的声明格式
3.掌握方法的使用
4.掌握方法的重载
5.了解递归第一节：方法
1.1 什么是方法
Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段。1.2 为什么要声明方法
1 把复用的逻辑抽取出来，封装成方法，提高代码的重用性
2 实现相对独立的逻辑，提高代码的维护性
3 可以对具体实现进行隐藏、封装1.3 方法的作用
简化代码，提高代码的可读性，可维护性，可重用性。1.4 方法的声明格式
语法：
访问权限修饰符 其他修饰符 返回值类型 方法名称(参数列表) {
//方法体【函数体】
return 返回值；//如果返回值类型void ,可以不用写return
}1.4.1方法的分类
根据方法有没有参数,可分为:
1.无参方法
2.有参方法
根据有没有返回值，可分为：
1.无返回值方法
2.有返回值方法
1.4.2 注意事项
1.一个完整的方法定义包含声明部分和实现部分
2.访问权限修饰符:public,[default],private ,protected【如果没有添加任何的访问权限修饰符，则默认为default，而default不需要显式的写出来】，目前使用的访问权限修饰符都和main函数保持一致，使用public
3.其他修饰符：static 【静态的】，要么不写【非静态函数】，要么写上【静态函数】，现在都写上。
4.返回值类型：方法运行之后返回的结果的数据类型，如果没有运行结果，则直接为void【空】，如果有就写具体类型。
5.方法名称：标识符【遵循驼峰命名法】，尽量做到见名知意
6.参数列表：如果方法所实现的功能中有未知项参与运算，就可以将未知项设置为参数。
形式参数：形参，在方法中定义，用于接收实参的值，相当于是一个未被赋值的变量。
实际参数：实参，在另外一个方法中定义，表示实际参与运算的值或者变量，作用为了给形参进行赋值
7.方法体：抽取出来的具有特殊功能的代码段。
8.return 返回值：将当前方法运行之后的结果进行返回，返回给当前方法的调用者
return作用：返回结果，结束方法。上机练习:
1. 最简单的无参方法
void sum1(){
System.out.println("加法操作");
}
2. 拥有修饰符的无参方法
public static void sum2(){
System.out.println("加法操作");
}
3. 拥有参数的方法
public static void sum3(int a,int b){
System.out.pritln("两数相加结果"+a+b);
}
4.拥有返回值的方法
public static int sum4(int a,int b){
return a+b;
}
5.声明一个无参数带返回值
public static int sum5(){
int x=20;
int y=28;
int z=x+y;
return z;
}1.5 方法的调用格式
语法：方法名称(实参列表);
注意：
a.实参的数量和类型必须和形参保持完全的一致。
b.方法之间只能进行相互的调用，而不能在方法中声明方法，就目前而言声明的方法都和main方法时并列的
c.如果定义方法有返回值，运算的结果会返回给调用者，调用者需要定义变量接收数据 1.5.1 方法调用练习
class TextDemo01
{
public static void main(String[] args)
{
//需求：打印2遍九九乘法表
/*
for(int i = 1;i <= 9;i++) {
for(int j= 1;j <= i;j++) {
System.out.print(j + "x" + i + "=" + i * j + " ");
}
System.out.println();
}
for(int i = 1;i <= 9;i++) {
for(int j= 1;j <= i;j++) {
System.out.print(j + "x" + i + "=" + i * j + " ");
}
System.out.println();
}
*/
System.out.println("start");
print();
print();
System.out.println("end");
}
//对于打印九九乘法表的功能提取出来一个函数
/*
访问权限修饰符 其他修饰符 返回值类型 函数名称(参数列表) {
//函数体【方法体】
return 返回值；
}
*/
public static void print() {
for(int i = 1;i <= 9;i++) {
for(int j= 1;j <= i;j++) {
System.out.print(j + "x" + i + "=" + i * j + " ");
}
System.out.println();
}
}
}1.6 方法中的参数
工作原理：调用方法的时候，用实参给形参进行赋值，这个过程被称为传参
形参就是一个变量，实参就是一个常量或者携带着值的变量，传参就是把实参赋值给形参
传参时需要注意的事项：实参的数量和类型必须和形参的数量和类型保持一致【相兼容的数据类型】
上机练习：
//演示参数的使用
class FunctionUsageDemo03
{
public static void main(String[] args)
{
//需求：交换两个变量的值
//实参
int a = 10;
int b = 20;
//调用函数
swap(a,b);
System.out.println("main函数中的a=" + a);//10
System.out.println("main函数中的b=" + b);//20
}
//分析：需要参数（两个参数）
// 不需要返回值
//形参：没有携带值的变量，多个变量之间使用逗号分隔
public static void swap(int a,int b) {
//定义一个中间的临时变量
int temp = 0;
temp = a;
a = b;
b = temp;
System.out.println("swap函数中的a=" + a);//20
System.out.println("swap函数中的b=" + b);//10
}
}1.7 方法的返回值
return关键字的作用：结束方法,返回结果，
return关键字的使用
表示一个方法执行完成之后所得到的结果.
(1) 如果方法的返回类型是void：表示没有返回值，可以不用写return，如果要是写 return; 建议不写return。return单独成立一条语句，类似于break或者continue，后面不能跟任何的数值。
作用：结束整个方法
(2) 在一个有返回值的方法中使用return，这种情况下方法中必须出现return，return后面必须跟一个具体的数值，而且数值的类型和返回值类型必须保持一致。
作用：结束整个方法，并且返回结果给调用者 (3) 如果一个自定义的方法有返回值，并且在方法中遇到了分支结构，在每一个分支后面都需要出现一个return。
1.7.1 方法的返回值练习
class ReturnUsageDemo01
{
public static void main(String[] args)
{
show();
}
/*
1>在没有返回值的函数中使用return
return单独成立一条语句，类似于break或者continue，后面不能跟任何的数值
作用：结束整个方法
*/
public static void show() {
System.out.println("Hello World!");
int x = 10;
if(x > 5) {
return;//结束方法
}
// 不能执行
System.out.println("Hello World!========");
}
}class ReturnUsageDemo02
{
public static void main(String[] args)
{
int result = add(10,20);
System.out.println(result);
}
/*
2>在一个有返回值的函数中使用return
这种情况下函数中必须出现return
return后面必须跟一个具体的数值，而且数值的类型和返回值类型必须保持一致
作用：结束整个方法，并且将返回值携带给调用者
*/
//需求：求两个变量的和
public static int add(int a,int b) {
int sum = a + b;
//谁调用，返回给谁
//return每次只能携带一个数据返回
return sum;
}
}class ReturnUsageDemo03
{
public static void main(String[] args)
{
int result = compare(34,67);
System.out.println(result);
}
/*
3>如果一个自定义的函数有返回值，并且在方法中遇到了分支结构，使用return
在每一个分支后面都需要出现一个return
*/
//需求：比较两个变量的大小，返回较大的一个
public static int compare(int num1,int num2) {
if(a>b){
return a;
}else if(a<b){
return b;
}else{
return 0;
}
}
}第二节：方法重载
2.1 方法重载的概念
同一个类中，方法名字相同，参数列表不同，则是方法重载。
注意：
1. 参数列表的不同包括，参数个数不同，参数数据类型不同，参数顺序不同
2. 方法的重载与方法的修饰符和返回值没有任何关系2.2 方法重载练习
//演示方法的重载
//测试类
class TextDemo04
{
public static void main(String[] args)
{
show("10");
show("10",10);
}
public static void show() {
System.out.println("无参无返回值的show");
}
public static void show(int a) {
System.out.println("int的show");
}
public static void show(String a) {
System.out.println("String的show");
}
public static void show(String a,int b) {
System.out.println("String int的show");
}
}第三节： 递归算法
3.1 递归算法的概念
在一个方法的方法体内调用该方法本身，称为方法的递归。简单理解自己调用自己。
演示案例：
方法递归包含了一种隐式的循环，会重复执行某段代码，但是这种重复不需要使用循环语句来进行控制
出现问题： StackOverFlowError 栈空间溢出异常，所以递归不能一直运行，一定要有结束条件。递归的必备条件
（1）子问题须与原始问题必须可以递推完成，且有规律。
（2）不能无限制地调用本身，比须有个出口。
3.2 案例一：求10的阶乘
//使用递归实现10 的阶乘
//求 10阶乘 , 求9的阶乘 * 10
//求 9阶乘， 求8的阶乘 *9
//...
//...
//求2的阶乘 ，1的阶乘*2
//1 1
//使用递归求10的阶乘
public class Demo4{
public static void main(String[] args){
int result=jiecheng(10);
System.out.println(result);
}
public static int jiecheng(int num){
if(num==1){
return 1;
}else{
return jiecheng(num-1)*num;
}
}
}3.3 案例二：求1~某个数之间所有整数的和
class DiGuiUsageDemo02
{
public static void main(String[] args)
{
int result = total(100);
System.out.println(result);
}
//需求：求1~某个数之间所有整数的和
//普通方式
public static int add(int n) {
int sum = 0;
for(int i = 1;i <= n;i++) {
sum += i;
}
return sum;
}
//使用递归实现
/*
total(1) = 1
total(2) = total(1) + 2
total(3) = total(2) + 3 = total(1) + 2 + 3
....
total(n) = total(n - 1) + n
*/
public static int total(int n) {
if(n == 1) {
return 1;
} else {
return total(n - 1) + n;
}
}
}3.4 案例三： 求斐波那契数列中的第30个数
class DiGuiUsageDemo01
{
public static void main(String[] args){
/*
斐波那契数列
1,2,3,4,5,6, 7, 8, 9,10,11,.....
1,1,2,3,5,8,13,21,34,55,89....
分析：
1.第一个位置和第二个位置上的数是固定的，都是1
2.第n个位置上的数 = 第n - 1个位置上的数 + 第n - 2个位置上的数
fun(1) = 1
fun(2) = 1
fun(3) = fun(2) + fun(1) = 1 + 1
fun(4) = fun(3) + fun(2) = fun(2) + fun(1) +fun(2)
fun(5) = fun(4) + fun(3) = fun(3) + fun(2) + fun(2) + fun(1) = fun(2) + fun(1) + fun(2) + fun(2) + fun(1)
....
fun(n) = fun(n - 1) + fun(n -2)
*/
int result1 = fun(10);
System.out.println(result1);
}
//需求：报个数，获取在斐波那契数列中对应的数
public static int fun(int n) {
if(n == 1 || n == 2) {
return 1;
} else {
return fun(n - 1)+fun(n-2);
}
}
}递归算法的应用场景：
1 正常思维无法解决问题时才采用递归算法 (汉诺塔问题)
2 使用递归能够大大提高执行效率。高效的排序算法：快速排序
第四节：课堂练习
4.1 练习
class PracticeDemo01
{
public static void main(String[] args)
{
method1();
method2(10);
}
public static void method1() {
//输出100~200之间能被3整除的数
for(int i = 100;i <= 200;i++) {
if(i % 3 != 0) {
continue;
}
System.out.println(i);
}
}
public static boolean method2(int num) {
//判断一个数是否为质数
//质数：除了1和本身能整除，如果出现一个数可以将这个数整除的话，那么这个数就不是质数
//1.假设是质数
boolean isPrime = true;
//2.寻找能够整除num的数，只要出现一个，则原来的假设被推翻
for(int i = 2;i < num;i++) {
//3.大对小求余
if(num % i == 0) {
//4.修改原来假设的状态
isPrime = false;
break;
}
}
return isPrime;
}
}class PracticeDemo02
{
public static void main(String[] args)
{
System.out.println(getNum(100));
System.out.println(getNum1(10));
}
//1.求1--某个数之间可以被7整除的数的个数
public static int getNum(int n) {
int count = 0;
for(int i = 1;i <= n;i++) {
if(i % 7 == 0) {
count++;
}
}
return count;
}
}总结
1 方法：完成特定功能的一段代码。
作用：提高代码的可重用性、可维护性、 可读性。
语法：
访问修饰符 其他修饰符 返回类型 方法名(参数列表){
方法体
}
public static void method1(){
}
public static void method2(int x){
}
public static int method(){
return 10;
}
方法调用:
方法名();
方法名(参数);
如果方法有返回值，需要定义变量接收。
2 方法重载
同一个类中，方法名相同，参数列表不同
（1）参数列表不同： 个数不同，类型不同，顺序不同
（2）和修饰符、返回值没有关系
3 递归算法 ： 在一个方法内部调用自己本身。
3.1 阶乘
3.2 求1-100的和
3.3 求第30个斐波那契数
默写
1.Java中的循环语句有那些：
2.各种循环语句的特点?
3.使用for循环输出1-100的素数。
作业
编程题(使用方法实现，调用方法)
1.计算从1到某个数以内所有奇数的和。
2.计算从1到某个数以内所有能被3或者17整除的数的和。
3.计算1到某个数以内能被7或者3整除但不能同时被这两者整除的数的个数。
4.计算1到某个数以内能被7整除但不是偶数的数的个数。
5.从键盘输入一个数n，判断是不是一个质数（质数是只能被1和它自身整除的数）。
中级：
编程题1.求2〜某个数之内的素数。【素数 ： 只能被1或本身整除的数】
2.判断某个年份是否是闰年。
A：能被4整除，并且不能被100整除 (2020)
B：或者能被400整除。3.已知有一个数列：f(0) = 1,f(1) = 4,f(n+2) = 2 * f(n+1) + f(n),其中n是大于0的整数，求f(n)的值（提示：使用递归）
4.求2+22+222+2222。
int a=0,sum=0; for(int n=1;n<=4;n++){ a=(a*10)+2; sum+=a; } System.out.print("sum="+sum);5.使用递归实现10 的阶乘。
高级
编程题1.求某个三位数以内的水仙花数：
水仙花数：一个数各个位上的立方之和，等于本身
例如： 153 = 1（3） + 5（3）+3（3） = 1+125+27 = 153
面试题
1.方法的传参过程是如何工作的
在调用方法的使用，在方面参数中写入实参，jvm运行时，会把实参赋值给形参。
2.return关键字的用法有哪些，举例说明
return; //结束方法 ,可以省略
return sum; //返回结果 sum ，结束方法
3.什么是方法的重载？举例说明
同一个类中，方法名相同，方法参数列表不同
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
