杏仁海棠花饼的Java学习日记第五天（for循环Java方法）
一，前言
今天就是第五天了，顺便祝大家520快乐，没有人一起过也没关系，祝大家此生幸福平安！今天来学没学完的流程控制，和Java方法的一些内容。
二，流程控制续
1.for循环
在 Java 里，for循环是经常会用到的一种流程控制结构，它能够让特定的代码块重复执行。
1. 标准for循环
这种循环的结构是最基本的，由初始化语句、循环条件和迭代语句组合而成。
for (初始化; 循环条件; 迭代语句) {
// 循环体
}下面是一个具体的例子，展示了如何使用标准for循环来输出数字 1 到 5：
for (int i = 1; i <= 5; i++)
{
System.out.println(i);
} 2. 增强for循环（foreach 循环）
增强for循环主要用于遍历数组或者集合。
for (元素类型 变量名 : 数组或集合) {
// 循环体
}以下是使用增强for循环遍历数组的示例：
int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
System.out.println(num);
}//输出1到53. 嵌套for循环
嵌套for循环指的是在一个for循环的循环体中再嵌套另一个for循环，常用于处理多维数据结构。
for (初始化1; 循环条件1; 迭代语句1) {
for (初始化2; 循环条件2; 迭代语句2) {
// 内层循环体
}
// 外层循环体
}下面是一个使用嵌套for循环打印九九乘法表的示例：
package com.Begonia.method;
public class Demo02 {
public static void main(String[] args) {
// 外层循环控制行数
for (int i = 1; i <= 9; i++) {
// 内层循环控制每行的列数
for (int j = 1; j <= i; j++) {
// 打印乘法表
System.out.print(j + "×" + i + "=" + (i*j) + "\t");
}
// 每行打印完后换行
System.out.println();
}
}
}
可以自己试着写一下。
2.循环控制语句
循环执行过程中，可以使用以下控制语句来改变循环的执行流程：
-
break：直接终止整个循环。 -
continue：跳过当前循环体中剩余的代码，直接进入下一次循环。
下面是使用break和continue的示例：
package com.Begonia.method;
public class Demo01 {
public static void main(String[] args) {
// break示例：输出1到4
for (int i = 1; i <= 10; i++) {
if (i == 5) {
break;
}
System.out.println("break示例：" + i);
}
// continue示例：输出1到10中的奇数
for (int i = 1; i <= 10; i++) {
if (i % 2 == 0) {
continue;
}
System.out.println("continue示例：" + i);
}
}
}
break示例：1
break示例：2
break示例：3
break示例：4
continue示例：1
continue示例：3
continue示例：5
continue示例：7
continue示例：9练习打印一个标准等腰三角形（使用星号打印*）
package com.Begonia.method;
public class Demo03 {
public static void main(String[] args) {
int n = 5; // 三角形行数
for (int i = 1; i <= n; i++) {
// 打印空格
for (int j = 1; j <= n - i; j++) {
System.out.print(" ");
}
// 打印星号
for (int k = 1; k <= 2 * i - 1; k++) {
System.out.print("*");
}
// 换行
System.out.println();
}
}
/* 输出结果：
*
***
*****
*******
*********
*/
}
三，Java方法
原子性一个方法只完成一个功能
在 Java 里，“方法”（Method）是用于实现特定功能的代码片段，它会被封装在类中，并且可以被多次调用。下面为你介绍 Java 方法的相关知识，涵盖定义、参数、返回值以及重载等方面。
1. 方法的定义与调用
pubic class Calculator {
// 定义一个方法：返回两个整数的和
public int add(int a, int b) {
return a + b;
}
// 定义一个无返回值的方法（返回类型为void）void就是无返回值
public void printResult(int result) {
System.out.println("计算结果：" + result);
}
public static void main(String[] args) {
Calculator calc = new Calculator();//创建一个名为 “calc” 的 Calculator 类型的对象。
// 调用方法
int sum = calc.add(5, 3);
calc.printResult(sum); // 输出：计算结果：8
}
}方法的组成部分：
-
访问修饰符（如
public、private） -
返回类型（例如
int、void） -
方法名（遵循驼峰命名法，像
addNumbers） -
参数列表（放在括号内，参数之间用逗号分隔）
-
方法体（用花括号括起来的代码块）
2. 方法的参数传递
一共有两种参数传递方式：
注意：Java只有值传递
-
值传递（针对基本数据类型，像
int、double） -
引用传递（针对对象类型，如
String、数组） -
在 Java 中，数组（Array） 是一种用于存储固定大小的相同类型元素的数据结构。数组中的元素可以是基本数据类型（如
int、char）或引用数据类型（如String、Object）。例如：int[] numbers = {1, 2, 3, 4, 5};
public class ParameterDemo {
// 值传递示例
public void changeValue(int num) {
num = 100; // 不会改变原始值
}
// 引用传递示例
public void changeArray(int[] arr) {
arr[0] = 100; // 会改变原始数组
}
public static void main(String[] args) {
ParameterDemo demo = new ParameterDemo();
int value = 10;
demo.changeValue(value);
System.out.println(value); // 输出：10（未改变）
int[] array = {1, 2, 3};
demo.changeArray(array);
System.out.println(array[0]); // 输出：100（已改变）
}
}3. 方法重载（Overloading）
在同一个类中，可以定义多个名称相同但参数列表不同的方法。
public class OverloadingExample {
// 方法重载示例
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
public String add(String a, String b) {
return a + b;
}
public static void main(String[] args) {
OverloadingExample example = new OverloadingExample();
System.out.println(example.add(1, 2)); // 输出：3
System.out.println(example.add(1.5, 2.5)); // 输出：4.0
System.out.println(example.add("Hello", " World")); // 输出：Hello World
}
}重载的规则：
-
方法名必须相同。
-
参数列表必须不同（可以是参数的类型、个数或者顺序不同）。
-
返回类型可以相同，也可以不同。
4. 可变参数（Varargs）
允许方法接收任意数量的同一类型参数。
public class VarargsExample {
// 计算多个整数的和
public int sum(int... numbers) {
int total = 0;
for (int num : numbers) {
total += num;
}
return total;
}
public static void main(String[] args) {
VarargsExample example = new VarargsExample();
System.out.println(example.sum(1, 2, 3)); // 输出: 6
System.out.println(example.sum(10, 20, 30, 40)); // 输出: 100
}
}5. 递归方法
方法自己调用自己，需设置终止条件避免无限循环。注意递归次数过多会导致栈溢出。
递归过深的危害
性能问题：递归调用会频繁创建和销毁栈帧，导致内存和 CPU 资源浪费。
栈溢出：当栈深度超过 JVM 限制时，会抛出致命错误，程序崩溃。
内存泄漏风险：如果递归中持有大量对象引用，可能导致内存泄漏。
public class Recursion {
// 计算阶乘（n! = n × (n-1) × ... × 1）
public int factorial(int n) {
if (n == 0 || n == 1) {
return 1; // 终止条件
} else {
return n * factorial(n - 1); // 递归调用
}
}
public static void main(String[] args) {
Recursion rec = new Recursion();
System.out.println(rec.factorial(5)); // 输出: 120 (5! = 120)
}
}今天满课就这么多吧！！！黑暗的星期二。