1、格式
for (初始化语句1 ; 循环的条件表达式2; 初始化变量的自增3 ) {
循环体语句;4
}
模拟执行时会出现的情况：（从左边开始）
1
2 false for语句结束
2true -4-3-2true-4-3-2true-4-3-2false-结束
2、执行流程：
3、说明：
代码示例
并且：（偏门用法）
代码示例
class Demo_3 {
//for语句的注意事项
public static void main(String[] args) {
//初始化变量只执行一次
for(int i = 1,j=6;i < j/*必须是boolean类型的*/;i = i +3,j=j - 1)/*;*/{
//如果循环体语句中只有一条语句，我们可以省略大括号
//循环体语句
System.out.println(i+" "+j);//循环体语句是在初始化变量自增前执行
}
}
}
练习1
打印数字1-5
练习2
打印数字5-1
练习3
计算1+2+3+...+100的和
练习4
计算1-100的偶数和
练习5
列举所有的“四叶玫瑰数”，并统计四叶玫瑰数的个数
四叶玫瑰数：是一个四位数，各个位的数字的四次方的和，为该数字本身
1、在一次大的循环中，每次的循环内容（循环体语句）又是一个复杂的操作，是重复的操作，就需要在大的循环体语句中，定义小的循环，称为循环的嵌套（在打印矩形或其他形状的图案时，如果使用两层for嵌套，外层循坏表示行数，内层循环表示列的个数）
2、格式：
for（初始化语句1 （1）; 循环条件表达式1（2）；初始变量的自增1（3））{
for（初始化语句2（4）；循环条件表达式2（5）；初始变量自增2（6））{
循环体语句7
}
}
模拟语句运行的流程如下：
1->2false 结束
1 -> 2true ->4 -> 5 false 内层循环结束->3->2 直到2为false 循环结束
1 -> 2true -> 4 -> 5 true -> 7 -> 6 ->5 true(回到7) false-> 3 -> 2(true)回到4 ，2为false结 束
3、执行流程
循环条件表达式1，true，初始化语句2，循环条件表达式2，true，循环体语句，初始变量自增2，循环条件表达式2，false，
代码示例
class Demo_2 {
public static void main(String[] args) {
//嵌套循环
/*
for(初始化语句1;循环条件表达式1;初始化变量自增1){
for(初始化语句2;循环条件表达式2;初始变量自增2){
循环体语句;
}
}
*/
for(int i = 1;i < 6 ;i++){//外层循环循环一次，内层循环是要执行完
for(int j = 1;j < 4;j++){
System.out.println("i = " + i +";j = " + j);
}
}
}
}
练习1
使用嵌套循环，打印四行五列星星矩形
*****
*****
*****
*****
提示：打印不换行，使用print方法，不要加ln
class Demo_7 {
public static void main(String[] args) {
/*
使用嵌套循环，打印四行五列星星矩形
*****
*****
*****
*****
提示：打印不换行，使用print方法，不要加ln
*/
//外层循环控制行数，内层循环控制列数
for(int i = 1;i < 5;i++){
//内层循环控制列数
for(int j = 1;j < 6;j++){
System.out.print("*");
}
//换行
System.out.println();
}
}
}
练习2
使用嵌套循环，打印5行5列的直角三角形
*
**
***
****
class Demo_8 {
public static void main(String[] args) {
/*
使用嵌套循环，打印5行5列的直角三角形
* 1行 打印1列，内层循环1次
** 2行 打印2列，内层循环2次
*** 3行 打印3列，内层循环3次
****
*****
*/
for(int i = 1;i < 6;i++){
for(int j = 1;j <= i;j++){
System.out.print("*");
}
System.out.println();
}
}
}
练习3
打印99乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
........................................
1*9=9 2*9=18 3*9=27 .......... 8*9=72 9*9=81
class Demo_9 {
public static void main(String[] args) {
/*
打印99乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
........................................
1*9=9 2*9=18 3*9=27 .......... 8*9=72 9*9=81
*/
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();
}
}
}
1、格式：
初始化语句
while(条件表达式) {
循环体语句;
初始化变量的自增;
}
2、执行流程：
3、注意事项：
代码示例
class Demo_10 {
public static void main(String[] args) {
//while语句
/*
初始化语句
while(条件表达式){
循环体语句；
初始变量的自增;
}
*/
int i = 1;
while(i < 6){
System.out.println("爱你三千遍");
//初始变量的自增
// i++;//i = i * 2;
System.out.println(i++);
}
}
}
练习
使用while循环，统计1-100范围内，有多少数字可以被7整除
class Demo_11 {
public static void main(String[] args) {
//使用while循环，统计1-100范围内，有多少数字可以被7整除
int i = 1;
//定义一个辅助变量用来统计被7整除的个数
int count = 0;
while(i <= 100){
//判断是否可以被7整数
if(i % 7 == 0){
count++;
}
//初始变量的自增
i++;
}
System.out.println(count);
}
}
1、格式：
初始化语句;
do {
循环体语句;
初始化变量的自增;
} while (循环条件表达式);
2、执行流程：
3、注意事项：
代码示例
class Demo_12 {
public static void main(String[] args) {
//do while 语句
//初始化变量
int i = 1;
do{
System.out.println("do while虚幻");
//初始化变量的自增
++i;
}while(i < 5);
//常用的循环语句，for语句，while语句
}
}
1、do while语句和其他两种语句的区别：
2、while语句和for的区别：
1、死循环：无限循环。循环永远都不停止。
2、格式：
1、for语句的死循环：
for ( ; ; ) {
循环体语句;
}
2、while语句的死循环：【常用】
while (true) {
循环体语句;
}
注意：
//破坏循环的方法：使条件变为false
//方式：1.直接使判断表达式条件变为false 2.通过修改自增表达式（不一定使用a++这种），使判断表达式失效即为false 3.使用break，continue，return，system.exit（0）结束循环/方法/虚拟机
3、死循环的作用：
代码示例
import java.util.Scanner;
class Demo_14 {
public static void main(String[] args) {
//死循环
//for语句的死循环
/* for(;;){
System.out.println("死循环");
}
*/
//System.out.println("我能执行到吗，好好想想");
//while语句的死循环
//while (true){
// System.out.println(true);
// }
Scanner sc = new Scanner(System.in);
System.out.println("选择你心仪的战队");
while(true){
int a = sc.nextInt();
if(a == 1){
System.out.println("I like RNG");
break;
}else if(a == 2){
System.out.println("I like IG");
break;
}else if(a == 3){
System.out.println("I like FPX");
break;
}else if(a == 4){
System.out.println("I like SKT");
break;
}else if(a == 5){
System.out.println("I like DWG");
break;
}else{//不加else有可能一个语句体都不执行，加上后要执行一个语句体
System.out.println("你输入的战队不存在，请重新输入");
}}
}}
1、跳转语句：在循环的循环体语句中，结束循环，控制循环，使用的语句。
2、continue语句：
3、break语句：
4、return语句：
5、System.exit(0);
代码示例
class Demo_15 {
public static void main(String[] args) {
//跳转语句
for(int i = 1;i<=10;i++){
//continue
if(i == 5){
continue;//结束本次循环，继续下次循环
}
System.out.println(i);
}
System.out.println("----------==================");
// break语句
for(int i = 1;i<=10;i++){
if( i == 5){
break;// 把整个循环结束了
}
System.out.println(i);
}
System.out.println("------------------------------------");
//return
for(int i = 1;i<=5;i++){
for(int j = 1;j < 8;j++){
if( j == 5){
return;// 直接把方法结束了
//break; //结束的是内层循环，外层循环不受影响
//System.exit(0);//把虚拟机结束了
}
System.out.println("i = "+i +";j="+j);
}}}}
1、具有某种特定功能的代码段
2、某段代码经常使用，所以使用大括号，将这段代码包起来，起个名字。以后就使用这个名字来代替这段代码。
3、好处：
1、方法定义的格式
修饰符 返回值类型 方法名称 (参数列表) {
方法体语句;
return语句;//使用void时，return后面不接东西，表示结束这个方法，其他返回值类型，return返回对应类型数据作为这个方法的一个结果输出
}
2、详细解释：
注：静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。
1、格式：直接书写方法名称即可（在不使用面向对象编程的时候）
方法名称(实际参数);
2、方法调用的三种形式：
3、方法调用总体特点：
方法不调用，就不执行。
代码示例
class Demo_17 {
public static void main(String[] args) {
//方法的调用
//直接调用
method_1();
method_2(/*实际参数*/5,8);
//输出调用
method_3(1,2);//sum
System.out.println(method_3(3,4));
//赋值调用
int a = method_3(2,3);
System.out.println(a);
}
//无参数列表，无返回值
public static void method_1(){
System.out.println("method_1 方法被调用了");
}
//有参数列表的，无返回值
public static void method_2(/*定义诺干个变量*/int i ,int j){
System.out.println("method_2 方法被调用了"+ "i= "+i +";j="+ j );
}
//有参数列表，有返回值的
public static int method_3(/*定义诺干个变量*/int i ,int j){
System.out.println("method_3");
int sum = i + j;
return sum;
}
}
1、方法定义：
2、参数列表：
3、return语句：
1、重载：Overload，超载
2、方法的重载：（只有参数的数据类型，个数，参数的位置这三个改变，才算方法重载）
3、说明：
4、方法重载的好处：
5、当前学习过的常见重载：
println方法，任意类型的数据，都可以放到这个方法中打印
在System.out类型中，将各种数据类型的打印方法，都定义出来了，都起了println方法的名称
代码示例
class Demo_20 {
public static void main(String[] args) {
//方法的重载
int a = 1;
int b = 2;
System.out.println(sum(a,b));
double m = 1.2;
double n = 1.3;
System.out.println(sum(1.2,1.3));
//重载
System.out.println(1);//PrintStream
System.out.println(1.2);
System.out.println("asdf");
}
//在同一个类中，方法名字一样，参数列表不同（参数的数据类型不一样，参数的顺序不一样，参数的个数不一样）与返回值类型无关
public static int sum(int a,int b){
return a + b;
}
public static double sum(double a,double b){
return a + b;
}
/*public static double sum(double aa,double bb){
return aa + bb;不是方法的重载
}*/
public static double sum(double a,int b){
return a + b;
}
public static double sum(int a,double b){
return a + b;
}
public static int sum(int a,int b,int c){
return a + b + c;
}
}
练习1
定义一个方法getMax，可以获取两个整数的较大值
在主方法中，键盘录入两个整数，调用方法获取两者最大值
练习2
定义一个方法isEqual，可以判断两个小数是否相等
在主方法中，键盘录入两个整数，自动提升为小数，调用方法比较两者是否相等
练习3
定义一个方法，可以打印指定行数和列数的矩形
在主方法中，键盘录入两个整数，作为行数和列数，调用方法打印对应规模的矩形
原文：https://www.cnblogs.com/pwj-StudyCode/p/11774044.html