Java Day2（Java基础语法）

Java基础

Java基础语法
- 1. 注释、关键字、标识符
- - 1.1 Java中的注释
  - 1.2 关键字
  - 1.3 标识符
- 2. 数据类型
- - （1）基本类型（primitive type）
  - - - a.字节
      - b.进制
      - c. 浮点数拓展
      - d. 字符拓展
  - （2）引用类型(Reference type )
- 3. 类型转换
- 4. 变量
- - （1）变量的声明：type varName [=value] [{,varName[=value]}]
  - （2）变量的作用域
  - （3）变量的命名规范
- 5.常量
- 6.基本运算符
- - 算术运算符：
  - 关系运算符
  - 逻辑运算符与(&&)或(||)非(!)
  - 位运算符（二进制运算）
  - 三元运算符？：， x?y : z（如果x==true,则结果为y，否则结果为z）
  - 运算符优先级
- 7. Java 包机制
- 8.JavaDoc
Java流程控制
- 1. 用户交互Scanner
- - next()
  - nextLine()
  - nextInt()和nextFloat()和nextDouble()
- 2. 顺序结构
- 3. 选择结构
- - （1）if单选择结构
  - （2）if双选择结构
  - （3）if多选择结构
  - （4）嵌套的if结构
  - （5）switch多选择结构
- 4. 循环结构
- - （1）while循环
  - （2）do...while循环
  - （3）for循环
  - 练习
  - （4）增强for循环
- 5. break &continue
- - break
  - continue
- 6.练习

Java基础语法

在创建项目之后要确保JDK版本和语言版本保持一致。
在这里插入图片描述

1. 注释、关键字、标识符

1.1 Java中的注释

单行注释 //
多行注释‘ /* 注释 */
文档注释’ /** */

1.2 关键字

java中的关键字
在这里插入图片描述

1.3 标识符

Java中的类名、变量名、方法名都是标识符。

所有的标识符都是由字母、数字、下划线_和美元符$组成。
数字不能作为开头
不能使用关键字作为变量名或者方法名
标识符是大小写敏感的
合法标识符：age,$salary,_self
非法标识符：3say,-studio

2. 数据类型

强类型语言
- 要求变量的使用要严格符合规定，所有变量都必须先定义（初始化）后才能使用
- Java，C，C++
- 安全性高，速度相对较低
弱类型语言
- VB，JavaScript

（1）基本类型（primitive type）

Java 中有 8 种基本数据类型，分别为：
6 种数字类型：
4 种整数型：byte、short、int、long
2 种浮点型：float、double
1 种字符类型：char
1 种布尔型：boolean。
在这里插入图片描述注意：

Java 里使用 long 类型的数据一定要在数值后面加上 L，否则将作为整型解析,同理，float类型在数值后加F。
char a = 'h’char :单引号，String a = “hello” :双引号。
这八种基本类型都有对应的包装类分别为：Byte、Short、Integer、Long、Float、Double、Character、Boolean 。

a.字节

位（bit）：计算机内部存储数据的最小单位，11110011是一个八位二进制数
字节（byte）：计算机中数据处理的基本单位，用B表示
1B（byte，字节） = 8bit（位）
字符：计算机中使用的字母、数字、字和符号

1 bit 表示1 位
1Byte 表示一个字节，1B= 8b
1024B = 1KB
1024KB = 1M
1024M = 1G

b.进制

二进制0b === 0,1 === 0b10 ->2
十进制 === 0~9 === 10
八进制0 === 0~7 ===010 -> 8
十六进制0x === 0-9 , A~F === 0x10 ->16

c. 浮点数拓展

public class Hello{
	public static void main(String[] args) {
	
		float f1 = 0.1f;
		double f2 = 1.0/10;
		System.out.println(f1);  //0.1
		System.out.println(f2);  //0.1
		System.out.println(f1==f2);  // false

		float f3 = 23232323232222f;
		float f4 = f3+1;
		System.out.println(f3);
		System.out.println(f4);
		System.out.println(f3==f4);  // true
	}
}

float : 有限、离散、存在舍入误差、大约、接近但不等于

最好不要使用浮点数进行比较

金融类问题中，涉及到钱的表示时，使用数学工具类BigDecimal

d. 字符拓展

所有的字符本质都是数字，可以对字符进行强制类型转换为int,即Unicode编码
Unicode编码，2字节，0-65526（2^16）
U0000 - UFFFF

public class Hello{
	public static void main(String[] args) {
		char c1 = 'a';
		char c2 = '你';
		char c3 = '\u0061';
		System.out.println(c1);  //a
		System.out.println((int)c1); //强制类型转换  97
		System.out.println(c2);  //你
		System.out.println((int)c2);  //强制类型转换  20320
		System.out.println(c3);  // a
	}
}

（2）引用类型(Reference type )

类
接口
数组

3. 类型转换

Java是强类型语言，在运算中，不同的数据类型必须转化为同一类型再进行运算。
优先级从低到高
byte，short，char ---->int—>long---->float ---->double

强制类型转换：优先级从高到低
自动类型转换：优先级从低到高

注意点

不能对布尔值进行转换
不能把对象类型转换为不相干的类型
在把高容量转换到低容量的时候，进行强制转换
转换的时候可能存在内存溢出或者精度问题！

public class Hello{
	public static void main(String[] args) {
		int a = 128;
		byte b = (byte)a;  //强制类型转换
		double c = a;  //自动类型转换
		System.out.println(a);  //128
		System.out.println(b);  //-128  byte类型的最大为127，内存溢出
		System.out.println(c);  //128.0
	}
}

public class Hello{
	public static void main(String[] args) {
		int money = 10_0000_0000;  //借助下划线进行分割，不影响输出
		int  year = 20;
		int total = money*year;
		long total1 = money*year;
		long total2 = money*((long)year);
		System.out.println(total);  //-1474836480 内存溢出
		System.out.println(total1);  //-1474836480 内存溢出
		System.out.println(total2);  //20000000000 先对一个数字进行强制类型转换
	}
}

4. 变量

Java是一种强类型语言，每个变量都必须声明其类型
Java变量是程序中最基本的存储单元，其要素包括变量名、变量类型和作用域。

（1）变量的声明：type varName [=value] [{,varName[=value]}]

type varName [=value] [{,varName[=value]}]
//数据类型  变量名= 值；可以使用逗号隔开来声明多个同类型变量（但是不建议，程序可读性较低）

注意点

每个变量都有类型，可以是基本类型也可以是引用类型
变量名必须是合法的标识符
变量声明是一条完整的语句，因此每一个声明都必须以分号结束

（2）变量的作用域

类变量（全局变量）
实例变量，从属于对象，不进行初始化则为默认值
局部变量，方法中的变量(作用域只在方法{}中)，使用之前必须声明和初始化值

public class Variable {
	// 实例变量
	String name;
	int age;
	//类变量（全局变量）static
	static int schoolId = 1002;

	public static void main(String[] args) {
		//局部变量，必须进行声明和初始化
		int stuId = 1002003;
		System.out.println(stuId);  // 1002003
		Variable variable = new Variable();
		System.out.println(variable.name); // null
		System.out.println(variable.age);  //0
		System.out.println(schoolId); //1002
	}
	public void add(){
		int a = 10;
		int b = 12;
		System.out.println(a+b);
		System.out.println(stuId); // 报错，未声明
		System.out.println(schoolId); //1002
	}
}

（3）变量的命名规范

所有的变量、方法、类名：见名知意
类成员变量、局部变量：首字母小写和驼峰原则，eg：monthSalary
常量：大写字母和下划线 MAX_VALUE
类名：首字母大写和驼峰原则： Student
方法名：首字母小写和驼峰原则：run(),getScore()

5.常量

常量（Constant）：初始化之后不再改变值。
也可以理解为一种特殊的变量，它的值被设定之后在程序运行过程中不允许被改变
final 常量类型常量名 = 值;
final double PI = 3.14;
常量名一般使用大写字符。

final static double PI = 3.14; 和static final double PI = 3.14; 都可以，修饰符不分先后顺序

6.基本运算符

Java语言支持如下运算符：

算术运算符：+，-，*，/，%，++，–
赋值运算符：=
关系运算符：>，<，>=，<=，==，!=，instanceof(子类判断)
逻辑运算符：&&，||，！
位运算符：&，|，^，~，>>，<<，>>>
条件运算符：？：
扩展运算符：+=，-=，*=，/=

算术运算符：

/ 在使用时，如果两个操作数都是int，结果也是int型的，会丢弃掉小数部分，结果有浮点数时注意类型转换；
+进行数值操作时，不同的数值类型进行相加，结果为优先级最高的类型（有long型则结果也为long，byte+short结果为int（类型提升））
Math类中提供了常用的数据操作类（Math.pow(2,3)=>2^3）
自增自减运算符++和–在变量前后的结果不同

public class HelloWorld {
    public static void main(String []args) {
    	int m = 10;
		int n = 4;
		System.out.println(m/n);// 2
		System.out.println(m/(double)n); //2.5
		
		int a = 2;
		int b = a++; //等价于 b=a,a=a+1,先赋值，后自增,b=2,a=3
		int c = ++a; //等价于 a=a+1,c=a,先自增，后赋值,a=4,c=4
		System.out.println("a的值："+a); //4
        System.out.println("b的值："+b);//2
		System.out.println("a的值："+a);//4
		System.out.println("c的值："+c);//4
    }
}

+在操作中如果有字符串，则作为字符串连接符，且字符串在前在后结果不同

public class HelloWorld {
    public static void main(String []args) {
    	//字符串连接符 +
		int a = 20;
		int b = 30;
		System.out.println("" +a+b);// 2030
		System.out.println(a+b+"");//50
    }
}

关系运算符

" = “是赋值运算，” == "是等于运算
" > “、” < “、” >= “、” <= “只支持数值类型的比较，” == “、” != "支持所有数据类型的比较
关系表达式的运算结果是布尔值

逻辑运算符与(&&)或(||)非(!)

短路运算：a&&b,若a为假，则不进行b的判断；a||b,若a为真，则不进行b的判断

public class HelloWorld {
    public static void main(String []args) {
    	//与(and)  或(or)  非(取反)
		boolean a = true;
		boolean b = false;
		
		System.out.println("a&&b："+(a&&b)); //false逻辑与运算，两者都为真结果才是true，有一个为假则是假
        System.out.println("a||b："+(a||b));//true逻辑或运算，变量有一个为真，结果就为真，两个全假，结果才是假
		System.out.println("!(a&&b)："+(!(a&&b)));//true取反，真变假，假变真	
		//短路运算
		int c1 = 8;
		int c2 = 8;
		int c3 = 8;
		boolean d = (c1>10)&&(c1++>8);
		boolean e = (c2>5)||(c2++>8);
		boolean f = (c3>5)&&(c3++>8);
		System.out.println("c1："+c1);//8
		System.out.println("c2："+c2);//8
		System.out.println("c3："+c3);//9
		System.out.println("d："+d);//false
		System.out.println("e："+e);//true
		System.out.println("f："+f);//false
    }
}

位运算符（二进制运算）

&（与）全1为1，有0则0
| （或）全0为0，有1则1
^ （异或）相同为0，不同为1
~（非）0变1,1变0
<< (左移) 相当于* 2 ,2 * 2 * 2* 2 等价于 2<<3
‘’>>(右移) 相当于/2

public class HelloWorld {
    public static void main(String []args) {
    	//与(&)  或(|)  非(~)  异或(^)
		/*
		A  =  0011 1100 
		B  =  0000 1101
		==============
		A&B = 0000 1100
		A|B = 0011 1101
		A^B = 0011 0001
		~A  = 1100 0011
		
		
		如何提高2*8 = 16的计算速度？
		使用位运算符中的<<, 2*8 =>2*2*2*2=>2<<3
		0000 0000   0
		0000 0001   1
		0000 0010   2
		0000 0011   3
		0000 0100   4
		0000 1000   8
		0001 0000   16
		*/
		
		int a = 2;
		System.out.println("a<<3："+(a<<3));// a<<3：16
    }
}

三元运算符？：， x?y : z（如果x==true,则结果为y，否则结果为z）

public class HelloWorld {
    public static void main(String []args) {
    	//三元运算符  ? :
		// x?y:z
		// 如果x==true,则结果为y,否则结果为 z
		int age = 17;
		String adult = age>18 ? "成年" : "未成年";
		System.out.println(adult);
    }
}

运算符优先级

括号级别最高，逗号级别最低，单目 > 算术 > 位 > 关系 > 逻辑 > 三目 > 赋值

优先级	运算符	结合性
1	( )　[ ] 　.	从左到右
2	! 　~　 ++　 –	从右到左
3	*　 /　 %	从左到右
4	+　 -	从左到右
5	<< 　>>　 >>>	从左到右
6	< 　<=　 > 　>=　 instanceof	从左到右
7	== 　!=	从左到右
8	&	从左到右
9	^	从左到右
10	\|	从左到右
11	&&	从左到右
12	\|\|	从左到右
13	? :	从左到右
14	= 　+= 　-= 　*=　 /=　 %=　 &=　 \|=　 ^=　 ~= 　<<= 　>>=　 >>>=	从右到左
15	，	从右到左

7. Java 包机制

《阿里巴巴Java开发手册》

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间
包语法的语法格式：
- package pkg1[.pkg2[.pkg3…]];
一般使用公司域名倒置作为包名
使用包中的成员时，再Java程序中使用import语言导入包即可：
- import package1[.package2…].(classname|*); (*表示引入包下包含的所有类)

8.JavaDoc

javadoc命令用于生成自己的API文档

javadoc [-encoding UTF-8 -charset UTF-8] Hello.java
使用该命令生成index.html即为Hello.java文件的API文档,[]中内容为设置字符编码
使用idea生成javadoc文件：工具（tool）->生成javaDoc->选择范围和目录，设置参数->查看index.html

参数信息：

@author 作者名
@version 版本号
@since 指明需要最早使用的jdk版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况

Idea设置文件创建时自动生成注释：
File–>settings–>Editor–>File and Code Templates–>Files–>Class文件类型–>includes

/**
*@author ${USER}
*@date ${YEAR}-${MONTH}-${DAY} ${HOUR}:${MINUTE}
*/

Java流程控制

1. 用户交互Scanner

Java.util.Scanner 是Java5的新特性，可通过Scanner类来获取用户的输入。
基本语法：

Scanner s = new Scanner(System.in);

通过Scanner 类的next()与nextLine()方法获取输入的字符串，再读取前使用hasNext()和haxNextLine()判断是否还有输入的数据。

next()

一定要读取到有效字符后才可以结束输入
对输入有效字符之前遇到的空白，next()方法会自动将其去掉
只有输入有效字符字后才将其后面输入的空白作为分隔符或者结束符
next()不能得到带有空格的字符串

nextLine()

以Enter为结束符，返回输入回车之前的所有字符
可以获得空白

import java.util.Scanner;
public class HelloWorld {
    public static void main(String []args) {
		// 创建一个扫描器对象，用于接收用户输入的键盘数据
		Scanner scanner = new Scanner(System.in);
		System.out.println("使用next方式进行接收：");
		//判断用户是否还有输入
		if(scanner.hasNext()){
			//使用next接收
			String str = scanner.next(); //程序等待用户输入完成之后继续运行
			System.out.println("用户输入为："+str);
		}
		System.out.println("使用nextLine方式进行接收：");
		//判断用户是否还有输入
		if(scanner.hasNextLine()){
			//使用next接收
			String str = scanner.nextLine(); //程序等待用户输入完成之后继续运行
			System.out.println("用户输入为："+str);
		}
		//凡是属于IO流的类，使用完之后要进行关闭，否则会一直占用资源
		scanner.close();
    }
		
}

nextInt()和nextFloat()和nextDouble()

import java.util.Scanner;
public class MyScanner {
    public static void main(String []args) {
		// 创建一个扫描器对象，用于接收用户输入的键盘数据
		Scanner scanner = new Scanner(System.in);
		//接收用户传入的数据
		int i = 0;
		float f = 0.0f;
		System.out.println("请输入整数：");
		//判断用户是否还有输入
		if(scanner.hasNextInt()){
			//使用nextInt接收
			i = scanner.nextInt(); //程序等待用户输入完成之后继续运行
			System.out.println("整数数据："+i);
		}else{
			System.out.println("输入的不是整数！！");
		}
		
		System.out.println("请输入小数：");
		//判断用户是否还有输入
		if(scanner.hasNextFloat()){
			//使用nextFloat接收
			f = scanner.nextFloat(); //程序等待用户输入完成之后继续运行
			System.out.println("小数数据："+f);
		}else{
			System.out.println("输入的不是小数！！");
		}
		//凡是属于IO流的类，使用完之后要进行关闭，否则会一直占用资源
		scanner.close();
    }	
}

练习：
计算连续输入的多个数字的和以及他们的平均数

import java.util.Scanner;
public class MyScanner {
    public static void main(String []args) {
		// 创建一个扫描器对象，用于接收用户输入的键盘数据
		Scanner scanner = new Scanner(System.in);
		//接收用户传入的数据
		int sum = 0;
		double n = 0.0;
		System.out.println("请输入整数：");
        while(scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            n++;
            sum +=x;
        }
        System.out.println("您一共输入了"+n+"个数字。");
        System.out.println(n+"个数字的总和是："+sum);
        System.out.println(n+"个数字的平均数是："+sum/n);
		
		//凡是属于IO流的类，使用完之后要进行关闭，否则会一直占用资源
		scanner.close();
    }	
}

2. 顺序结构

Java的基本结构就是顺序结构，除非特别指明，否则就是按照顺序一句一句执行
顺序结构是最简单的算法结构
语句与语句之间，框与框之间是按照从上到下的顺序进行的，它是由若干个一次执行的处理步骤组成的，顺序结构是任何一种算法都离不开的基本算法结构。

3. 选择结构

（1）if单选择结构

if (布尔表达式）{
//表达式为真，则执行语句
	语句;
}
其他语句;

在这里插入图片描述

import java.util.Scanner;
public class MyScanner {
    public static void main(String []args) {
		// 创建一个扫描器对象，用于接收用户输入的键盘数据
		Scanner scanner = new Scanner(System.in);
		//接收用户传入的数据
		String s = scanner.nextLine();
        if(s.equals("Hello")){
            System.out.println(s);
        }
        System.out.println("欢迎！");
	
		//凡是属于IO流的类，使用完之后要进行关闭，否则会一直占用资源
		scanner.close();
    }	
}

（2）if双选择结构

if(布尔表达式){
	//表达式为真
	语句一;
}else{
 	//表达式为假
	语句二;
}

在这里插入图片描述

import java.util.Scanner;
public class MyScanner{
    public static void main(String []args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的年龄：");
        int age = scanner.nextInt();
        if(age>=18){
            System.out.println("恭喜您，成年了！");
        }else{
            System.out.println("很遗憾，您还未成年！");
        }
        scanner.close();
    }
}

（3）if多选择结构

if(布尔表达式1){
    //布尔表达式1为真时的执行语句
    语句1;
}else if(布尔表达式2){
    //布尔表达式2为真时的执行语句
    语句2;
}else if(布尔表达式3){
    //布尔表达式3为真时的执行语句
    语句3;
}else{
    //以上布尔表达式都不为真时执行的代码
    语句4;
}

在这里插入图片描述

import java.util.Scanner;
public class MyScanner{
    public static void main(String []args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的成绩：");
        int score = scanner.nextInt();
        if(score == 100){
            System.out.println("恭喜您，满分！");
        }else if(score>=90 && score<100){
            System.out.println("A级！");
        }else if(score>=80 && score<90){
            System.out.println("B级！");
        }else if(score>=70 && score<80){
            System.out.println("C级！");
        }else if(score>=60 && score<70){
            System.out.println("D级！");
        }else if(score>=0 && score<60){
            System.out.println("很遗憾，不及格！");
        }else{
            System.out.println("输入成绩不合法！！！");
        }
        scanner.close();
    }
}

注意

if语句至多有一个else语句，else语句在所有的else if 语句之后
if 语句可以有若干个else if 语句，他们必须在else之前
一旦有一个else if 中的条件为真，则其他的语句都不执行

（4）嵌套的if结构

if(布尔表达式1){
// 如果布尔表达式1为真，则执行后续代码，否则直接跳出
	if(布尔表达式2){
	//布尔表达式2为真时执行的代码
	}
}

import java.util.Scanner;
public class MyScanner{
    public static void main(String []args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的号码：");
        int num = scanner.nextInt();
        if(0<num && num <100){
            if(0<num && num<50){
                System.out.println("num的位置在左边");
            }else{
                 System.out.println("num的位置在右边");
            }
        }else{
             System.out.println("您的num不合法");
        }
        scanner.close();
    }
}

（5）switch多选择结构

多选择结构还有一个实现方式就是switch case 语句
switch case 语句判断一个变量与一些列值中某一个值是否相等，每个值称为一个分支

switch 语句中的变量类型可以是：

byte、short、int或者char
从Java SE 7开始支持String类型,case标签必须为字符串常量或者字面量，原理是通过hashcode进行比较的

switch(expression){
	case value1:
		语句一;
		break;  //可选
	case value2:
		语句二;
		break;  //可选
	case value3:
		语句三;
		break;  //可选
		...  //case语句数量任意
	default:   //可选
		语句;
}

注意
case穿透
没有break的情况，满足条件的case之后的所有case不管是否满足条件都会执行


public class MyScanner{
    public static void main(String []args){
        char grade ='C';
        switch(grade){
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("中等");
                // break;
            case 'D':
                System.out.println("再接再厉");
                // break;
            default:
                System.out.println("输入有误");
        }
    }
}
//case 穿透，满足条件之后的所有case都执行了
// 中等
// 再接再厉
// 输入有误

字符的本质还是数字，switch case 中使用字符串，底层还是转换为了hashcode进行比较

反编译： Java编译生成 class 文件（字节码文件），使用Idea进行反编译，查看底层逻辑
项目结构（Project setting ） -->编译输出目录（Project compiler output）–>在目录中找到对应的class文件–>讲class文件从文件夹的角度放进Idea工作区（不能直接拖，会报错）–>双击class文件进行查看

Hello.java

public class Hello{
	public static void main(String[] args) {
		String  name = "肖战";
		switch(name){
			case "肖战":
				System.out.println("唯一");
				break;
			case "哥哥":
				System.out.println("张杰");
				break;
			default:
				System.out.println("还有谁");
		}
	}
}

Hello.class

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

public class Hello {
    public Hello() {
    }

    public static void main(String[] args) {
        String name = "肖战";
        byte var3 = -1;
        switch(name.hashCode()) {
        case 695456:
            if (name.equals("哥哥")) {
                var3 = 1;
            }
            break;
        case 1045570:
            if (name.equals("肖战")) {
                var3 = 0;
            }
        }

        switch(var3) {
        case 0:
            System.out.println("唯一");
            break;
        case 1:
            System.out.println("张杰");
            break;
        default:
            System.out.println("还有谁");
        }

    }
}

4. 循环结构

（1）while循环

while循环的基本结构

while(布尔表达式){
//循环内容
}

只要布尔表达式为true，循环就会一直执行下去
循环停止条件即为表达式为false
少部分需要循环一直执行，比如服务器的请求响应监听
循环条件一直为true会造成死循环，正常业务编程要尽量避免死循环，否则会影响程序性能或者造成程序卡死崩溃！！


public class MyScanner{
    public static void main(String []args){
        int i = 0;
        int sum = 0;
        while(i<100){
            i++;
            sum +=i;
        }
        System.out.println("0-100的和为："+sum);  // 0-100的和为：5050
    }
}

（2）do…while循环

对于while语句而言，如果不满足条件，则不能进入循环，有时需要即使不满足条件也至少执行一次。
do …while循环和while循环相似，但是do…while循环至少会执行一次。

do{
//代码语句
}while(布尔表达式);

public class MyScanner{
    public static void main(String []args){
        int i = 0;
        int sum = 0;
        // 使用while
        // while(i<100){
        //     i++;
        //     sum +=i;
        // }
        // System.out.println("0-100的和为："+sum);
        System.out.println("==========");
        // 使用do...while
        do{
            i++;
            sum += i;
        }while(i<100);
        System.out.println("0-100的和为："+sum);
    }
}

while 和do…while的区别

while先判断后执行
do…while 总是保证循环体会被至少执行一次

public class MyScanner{
    public static void main(String []args){
        int i = 0;
        // 使用while
        while(i>0){
            System.out.println(i);
        }
        System.out.println("==========");
        // 使用do...while
        do{
            System.out.println(i);
        }while(i>0);
    }
}
// 运行结果
// ==========
// 0

（3）for循环

在Java5中引入了一种主要用于数组的增强型for循环。

for循环语句是支持迭代的一种通用结构，时最有效最灵活的循环结构。
for循环的执行次数在执行前就确定的，语法格式如下：

for(初始化；布尔表达式；迭代更新）{
//代码块
}

public class MyScanner{
    public static void main(String []args){
        
        // 使用while循环
        int m = 0;  //循环初始条件
        while(m<10){ //循环终止条件
            System.out.println("while"+m); //循环执行语句
            m+=2;  //迭代条件
        }
        System.out.println("while循环结束");
        // 使用for循环
        for(int j=0;j<10;j+=2){//循环初始条件、终止条件、迭代语句
            System.out.println("for:"+j); //循环执行语句
        }
        System.out.println("for循环结束");
    }
}

注意点

for循环最先执行的是初始化步骤，可以声明一种类型，可初始化一个或者多个循环控制变量也可以是空语句
然后检测布尔表达式的值，如果为true，则执行循环体；如果为false，循环终止，开始执行循环体之后的语句；
执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）
再次检测布尔表达式，循环执行上述步骤

练习

（1）计算0-100之间的奇数和偶数的和


public class Sum{
    public static void main(String []args){
        int oddSum = 0;
        int evenSum = 0;
        for(int i=0;i<=100;i++){
            if(i%2==0){
                evenSum+=i;
            }
            else{
                oddSum+=i;
            }
        }
        System.out.println("0-100奇数的和："+oddSum);
        System.out.println("0-100偶数的和："+evenSum);
    }
}

（2）用while和for循环输出1-1000之间能够被5整除的数，一行输出5个


public class ForDemo{
    public static void main(String []args){
        // 用while和for循环输出1-1000之间能够被5整除的数，一行输出5个
        // 使用for循环
        int sum = 0;
        for(int i=1;i<=1000;i++){
            if(i%5==0){
                System.out.print(i+"\t");
            }
            if(i%(5*5)==0){
                System.out.println();
                //  System.out.print("\n");
            }
        }
        System.out.println("==========");
        // 使用while循环
        int sum2 = 0;
        int j = 1;
        while(j<=1000){
            if(j%5==0){
                System.out.print(j+"\t");
            }
            if(j%(5*5)==0){
                System.out.println();
                //  System.out.print("\n");
            }
            j++;
        }
    }
}

（3）打印九九乘法表

public class MultiNine{
    public static void main(String []args){
        // 打印九九乘法表
        // 1. 先打印列;2.将固定的1用循环包起来;3.去掉重复项，i<=j;4.调整样式
        // 1.倒三角
        for(int i=1;i<10;i++){
            for (int j=i;j<10;j++){
                System.out.print(i+"*"+j+"="+(i*j)+"\t");
            }
            System.out.println();
        }
        System.out.println("========================");
        // 2.正三角
        for(int i=1;i<10;i++){
            for (int j=1;j<=i;j++){
                System.out.print(i+"*"+j+"="+(i*j)+"\t");
            }
            System.out.println();
        }
    }
}

（4）增强for循环

Java 5中引入了一种主要用于数组或者集合的增强for循环，语法格式如下：

for(声明语句:表达式){
//代码语句;
}

声明语句：声明新的局部变量，该变量的类型必须与数组元素的类型匹配，其作用域限定在循环语句块中，它的值和此时数组元素的值相等。
表达式：表达式为要访问的数组或者返回值为数组的方法


public class ForPlus{
    public static void main(String []args){
        // 增强for循环
        int nums[] = {1,2,3,4,5,6};
        for(int x:nums){
            System.out.println(x);
        }
        System.out.println("===============");
        for(int i=0;i<nums.length;i++){
            System.out.println(nums[i]);
        }
    }
}

5. break &continue

break

break在任何循环语句的主题部分，都可以用break控制循环语句的流程。
break用于强行退出循环，不执行循环中剩余的语句。
在switch 中使用break用于结束条件判断


public class MyBreak{
    public static void main(String []args){
        // break 结束循环
        // 程序执行，输出0-77，然后跳出循环，执行后面的语句
        for(int i=0;i<100;i++){
            if(i==78){
                break;
            }
            System.out.println(i);
        }
        System.out.println("Finish");
    }
}

continue

continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，继续进行循环条件的判断。


public class MyContinue{
    public static void main(String []args){
        // continue 结束单次循环
        // 程序执行，遇到13的倍数则跳过这次循环，进行下一次的判断
        for(int i=0;i<100;i++){
            if(i%13==0){
                System.out.println();
                continue;
            }
            System.out.print(i+"\t");
        }
        System.out.println("Finish");
    }
}

6.练习

打印一个三角形


public class Triangle{
    public static void main(String []args){
        // 打印一个三角形
        for(int i = 0;i<5;i++){
            for(int j=5;j>i;j--){
                System.out.print(" ");
            }
            for(int m=0;m<=i;m++){
                System.out.print("*");
            }
            for(int n=0;n<i;n++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}