Java基本语法总结【超详细】

置顶 eikiz

已于 2024-02-24 16:10:34 修改

阅读量7.1k

点赞数 19

分类专栏： java基础文章标签： java

于 2021-04-10 21:30:11 首次发布

本文链接：https://blog.csdn.net/Emilyzyq/article/details/115469180

版权

java基础专栏收录该内容

6 篇文章 2 订阅

订阅专栏

一.第一个Java程序

//第一个Java程序
class Hello{
	public static void main(String[] args){ //arguments:参数，这里可以改变
	//public static void main(String[] a){
	//public static void main(String a[]){
		System.out.println("Hello,World!");
		System.out,println(); //换行的作用
		System.out.print("Hello,World!");
	}
}

class Person{
	
}

class Animal{
	
}

1.1 对第一个Java程序的总结：

java程序编写-编译-运行的过程：

编写：我们将编写的java代码保存在以“.java”结尾的源文件。
编译：使用javac.exe命令编译我们的java源文件,生成字节码文件。格式：- javac 源文件名.java。
运行：使用java.exe命令解释运行我们的字节码文件。格式：java 类名。

在一个java源文件中可以声明多个class.但是，只能最多有一个类声明为public，而且要求声明为public的类的类名必须与源文件名一致。
程序的入口是mian()方法。格式是固定的。可以改变的地方有两处，见上方代码：第一个Java程序。
输出语句：

System.out,println() ：先输出数据，后换行.
System.out,print() ：只输出数据，不换行.

每个执行语句都以";"结束。
编译过程：编译后，会生成一个或多个字节码文件。（类定义的个数等于生成字节码文件的个数）字节码文件的文件名与java源文件在的类名相同。

1.2 java规范的三种注释的方法：

单行注释
多行注释
文档注释

代码示例：

/**
文档注释
@author zyq
@version v1.0
这是我的第一个java程序，非常开心！
*/
public class HelloJava{
	/*
	多行注释：如下的main方法是程序的入口！
	main方法的格式是固定的！
	*/
	
	/**
	如下 的方法是mian()，作用：程序的入口。
	*/
	
	public static void main(String[ ] args){
		//单行注释：如下语句表示输出到控制台
		System.out.println("Hello,World!");
		System.out.println("Hello,World!");
	}
}

二.标识符的使用

1.定义：

凡是自己可以起名字的地方都叫标识符。比如：类名，变量名，，方法名，接口名，包名等等。

2.标识符的命名规则：

【注】：如果不遵守如下规则，编译不通过！需要严格遵守！

由26个英文字母大小写，0-9 ，_或 $ 组成。
数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。
标识符不能包含空格。

3.Java中名称命名规范：

【注】：如果不遵守如下规则，编译运行都可以通过！建议遵守！

包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz （大驼峰）
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz （小驼峰）
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

4.两个注意：

【注意1】：在起名字时，为了提高阅读性，要尽量起相应意义的名字，“见名知意”。不要乱起

【注意2】：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。

代码示例：

(D2_IdentifierTest.java)

class IdentifierTest{
	public static void main(String[] args){
		int myNumber =1001;
		System.out.println(myNumber);
		
		/*
		不遵守规范的例子：
		int mynumber =1001;
		System.out.println(mynumber)
		*/
	}
}

class Hello1_${
	
}

/*
错误示范：
class 1Hello{  //以数字开头
	
}

class static{  //使用关键字
	
}

class static public { //包含空格
	
}

*/
class staticpublic{  //关键字可以两个拼一起，但是不遵循命名规范
	
}

class Static{
	
}

三.变量 & 数据类型.

3.1 Java定义数据类型.

3.1.1 变量按照数据类型来分：

基本数据类型：

整形： byte \ short \int \long
浮点型：float \double
字符型：char
布尔型：boolean

引用数据类型：

类（class）
接口（Identiface）
数组（array）

3.1.2 变量按照在类中声明的位置来分：

成员变量
局部变量

代码示例：

（VariableTest1.java）

public class VariableTest1{
	public static void main(String[] args){
		//1.整型：byte(1字节=8bit)  \short(2字节)  \ int(4字节) \long(8字节)
		//（1）byte范围：-128~127
		//
		byte b1 = 12;
		byte b2 = -128;
		//b2 = -128;  //编译不通过，超出范围
		System.out.println(b1);
		System.out.println(b2);
		//（2）声明long类型变量，必须以“1”或“L”结尾，但最后输出结果中不带"L"
		//(3)通常：定义整型变量时，使用int 型
		
		short s1 = 128;
		int i1 = 1234;
		long l1 =3414243535L;
		System.out.println(l1);
		
		//2.浮点型： float(4字节)  、  double(8字节)
		//(1)浮点型，表示带小数点的数值
		//（2）float表示数值的范围比long大
		//(3)通常，定义浮点型变量时，使用double型。
		
		double d1 = 123.3;
		System.out.println(d1 + 1);
		//(1)定义float类型变量时，变量要以“F”或“f”结尾
		float f1 = 12.3F;
		System.out.println(f1);
		
		//3.字符型：char(1字节 = 2字节)
		//（1）定义char型变量，通常使用一对 ‘’ ， 内部只能写一个字符
		char c1 = 'a';
		//编译不通过
		//c1 = 'AB'   //有两个字符，不行
		System.out.println(c1);
		
		char c2 = '1';
		char c3 = '中';
		System.out.println(c2);
		System.out.println(c3);
			
		//(3)表示方式： 1.声明一个字符   2.转义字符  3.直接使用  Unicode 值来表示字符型常量
		char c5 = '\n';   //换行符
		c5 = '\t';    //制表符，想当于 Tab键
		System.out.print("hello" + c5);
		System.out.println("world");
		
		char c6 = '\u0043' ;
		System.out.println(c6);
			
		//4.布尔型：boolean
		//只能取两个值之一：ture  ,false.
		//常常在条件判断，循环结构中使用
		
		boolean bb1 = true;
		System.out.println(bb1);
		
		boolean isMarried = true;
		if(isMarried){
			System.out.println("你不能参加\"单身\"party了！\\n很遗憾！");
		}else{
			System.out.println("你可以多谈谈女朋友！");	
		}
	}
}

3.2 基本数据类型：

3.2.1 基本数据类型的介绍：

整形
byte(1字节=8bit) \short(2字节) \ int(4字节) \long(8字节)
① byte范围：-128~127
② 声明long类型变量，必须以“1”或“L”结尾，但最后输出结果中不带"L"。
③ 通常：定义整型变量时，使用int型。
浮点型
float(4字节) 、 double(8字节)
① 浮点型，表示带小数点的数值。
② float表示数值的范围比long大。
③ 通常，定义浮点型变量时，使用double型。
④ 定义float类型变量时，变量要以“F”或“f”结尾。
字符型
char(1字节 = 2字节)
① 定义char型变量，通常使用一对 ‘’ ，内部只能写一个字符.
② 表示方式：声明一个字符 / 转义字符 / 直接使用 Unicode 值来表示字符型常量。
布尔型
boolean
① 只能取两个值之一：ture ,false。
② 常常在条件判断，循环结构中使用。

3.2.2 char类型的一些补充

char类型补充代码示例：

（D3_ReviewTest.java）

class ReviewTest{
	public static void main(String[] args){
		char c1 = 'a';
		char c2 = 97;   //指a的ASCII码97，在开发中非常少见
		
		System.out.println(c2);
		
		char c3 = 5;
		char c4 = '5';
		
		int i1 = (int)c4;
		System.out.println(i1);//输出53  ，即字符‘5’的ASCII码为53.
		}
}

3.2.3 基本数据类型之间的运算规则：

【前提】：这里讨论的只是7种基本数据类型之间的运算，不包含boolean类型的。

自动类型提升：
结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
说明：此时的容量大小指的是：表示数的范围的大和小。不是指所占的内存空间（占的字节）的大与小。比如：float容量要大于long的容量，但是float所占字节4，比long（8字节）小。

byte，short，char —》 int—》 long—》float—》 double
（后面不可以添加String,得单独说）

特别的：当byte,char.short三种类型的变量做运算时，结果为int型。

强制类型转换：

自动类型提升运算的逆运算。
大容量------》小容量
需要使用强转符：（）
【注意点】：强制类型转换，可能导致精度损失。

【自动类型提升】代码示例：

（D2_VriableTest2.java）

public class VariableTest2{
	public static void main(String[] args){
		byte b1 = 2;
		int i1 = 129;
		
		//编译不通过
		//byte b2 = b1 + i1;
		int i2 = b1 + i1;
		
		long l1 = b1 + i1;
	
		System.out.println(i2);
		
		float f = b1 + i1;
		System.out.println(f);
		
		short s1 = 123;
		double d1 = s1;
		System.out.println(d1);  // 输出123.0

		//****************特别的*********************
		char c1 = 'a'；//97
		int i3 = 10;
		int i4 = c1 + i3;
		System.out.println(i4);
		
		short s2 = 10;
		//char c2  = c1 + s2;  // 编译不通过
		//short c2  = c1 + s2;  // 编译不通过
		
		byte b2 = 10;
		//char c3 = c1 + b2; //编译不通过。
		
		//short c3  = b2 + s2;  // 编译不通过
		
		short s4 = b1 + b2;  // 编译不通过
	}
}

【强制类型转换】代码示例：

（D2_VaribleTset3.java）

public class VariableTest3{
	public static void main(String[] args){

		//输出12，截断操作，此处强制转换有损失精度
		double d1 = 12.9;
		int i1 = (int)d1;
		System.out.println(i1);
		
		
		//输出12
		double d2 = 12.3;
		int i2 = (int)d2;
		System.out.println(i2);
		
		//此处强制转换没有精度损失
		long l1 = 123;
		short s2 = (short)l1;
		
		//输出-128，此处有精度损失
		int i3 = 128;
		byte b  = (byte)i3;
		System.out.println(b);
	}
}

两个编码情况代码示例：

（D2_VaribleTest4.java）

public class VariableTest4{
	public static void main(String[] args){
		
		//编码情况1：
		//此时忘记在 12312后面加“L”,编译未出错，原因是，此时把12312看作整形，然后自动类型提升转换成为long型
		long 1  = 12312;
		System.out.println(1);
		
		//编译失败：过大的整数
		//long l1  = 21312434567836212344;
		long l1 = 21312434567836212344L;
		
		//*************
		//编译失败，float类型一定要加“F”
		//float f1 = 12.3;
			
		//2.编译情况2：
		//整形常量，默认类为int型
		//浮点型常量，默认类型为double型
		byte b = 12;
		//byte b1 = b + 1; //编译失败
		
		//float f1 = b1 +12.3;//编译失败
	}
}

3.3 变量的使用。

java定义变量的格式：

数据类型变量名 = 变量值；

说明：
（1）变量必须先声明，赋值后，才可以使用.

（2）变量都定义在其作用域内。在类的作用域内，它是有效的。换句话说，出了作用域后，就失效了。
大括号即为其作用域！

（3）同一个作用域内，不可以声明两个同名的变量

代码示例：

（D2_VariableTest.java）

class VariableTest{
	public static void main(String[] args){
		//变量的定义
		int myAge = 12  //把变量的声明与赋值放在一起
		//变量的使用
		System.out.println(myAge);
		
		//编译错误：使用myNnumber前并未定义过myNumber，从而会报错
		//System.out.println(myNumber);
		
		//变量 的声明：
		int myNumber;
		
		//编译i错误：会报错：未初始化myNumber,即使用myNnumber前并未赋值过myNumber
		//System.out.println(myNumber);
		
		//变量的赋值：
		myNumber = 1001;
		System.out.println(myNumber);
		
		//不可以在同一个作用域内定义同名变量
		//int myAge = 22;
		
		//会报错，因为 变量myClass出了作用域
		//System.out.println(myClass);
	}
	
	public void method(){
		int myClass = 1;
	}
}

//class VariableTest{} //逆向思维，反证法，在不知道正不正确的情况下，假设是正确的，看是否会出现问题。

3.3 String 类型变量的使用.

String属于引用数据类型，翻译为字符串。
声明String类型变量时，使用一对“”。
String可以和8种基本数据类型变量做运算。且运算只能是连接运算： + 。
运算的结果仍然是String类型，判断是加法运算还是连接运算的方法：

如果加号左右两边至少有一个String类型，则是连接运算；
如果加号两边都不是String类型，则是加法运算。

代码示例：

（D2_StringTest.java）

class StringTest{
	public static void main(String[] args){
		
		String s1 = "Hello World!";
		System.out.println(s1);
		
		String s2 = "a";
		String s3 = "";//可以什么都不放
		
		//char c = ‘’；//编译不通过，放多了不行，放少了也不行
		
		//*******************************************
		int number = 1001;
		String numberStr = "学号：";
		String info = numberStr + number;// + ：连接运算,即拼在一起
		System.out.println(info);
		
		boolean b1 = true;
		String info1  = info + b1;// + ：连接运算,即拼在一起
		System.out.println(info1);
		
//***************************************
		//2个练习：判断 + 是起连接作用还是加法作用，只要开始出现String类型，则后面的 +  起连接的作用
				
		//练习1 ：
		char c = 'a'; //97  A:65
		int num = 10;
		String str = "hello";
		System.out.println(c + num + str); //107hello
		System.out.println(c + str +num );  // ahello10
		System.out.println(c + (num + str));  //a10hello
		System.out.println((c + num) + str); //107hello
		System.out.println(str  + num  + c); //helllo10a

		//练习2：
		//想要输出  *  *
		System.out.println("*  *");  //成功输出
		System.out.println('*' + '\t' +'*'); //输出93
		System.out.println('*' + "\t"  + '*');  //成功输出
		System.out.println('*' + '\t' + "*"); //输出51*
		System.out.println('*' + ('\t' + "*"));  //成功输出
		
		//************
		String str6 = 3.5f + ""; 
		System.out.println(str6);  //输出 “3.5”
		
		//*****************
		
		//String str1 = 123;//编译不通过
		String str8 = 123 + "";
		System.out.println(str8); //输出“123”
		
		//int num1 = str1;
		//int num1 = (int)str1; //编译不通过
		
		int num1 = Integer.parseInt(str8);
		System.out.println(num1);
	}
}

四.计算机中不同进制的使用说明.

对于整数，有四种表示方式：

二进制(binary)：0,1 ，满2进1.以0b或0B开头。
十进制(decimal)：0-9 ，满10进1。
八进制(octal)：0-7 ，满8进1. 以数字0开头表示。
十六进制(hex)：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
如：0x21AF +1= 0X21B0

代码示例：

（D2_BinaryTest.java）

class BinaryTest{
	public static void main(String[] args){
		
		int num1 = 0b110;
		int num2 = 110;
		int num3 = 0127;
		//int num = 0128;  //编译不通过
		int num4 = 0x110A;
		
		System.out.println("num1 = " + num1);
		System.out.println("num1 = " + num2);
		System.out.println("num1 = " + num3);
		System.out.println("num1 = " + num4);
	}
}

五. 运算符.

5.1 算术运算符.

+(加) -(减） + -
*(乘) / (除)
%（取余）
（前）++ (后)++ （前）-- (后)-- +

算数运算符的代码示例：

（D3_AriTset.java）

public class AriTest{
	
	public static void main(String[] args){
		
		//除号：  / 
		int num1 = 12;
		int num2 = 5;
		int result1 = num1 / num2;
		System.out.println(result1);   // 输出2
		
		int result2 = num1 / num2 * num2;
		System.out.println(result2); //输出10
		
		double result3 = num1 / num2;
		System.out.println(result3);  //2.0
		
		double result4 = num1 / num2 + 0.0;  //输出2.0
		double result5 = num1 / (num2 + 0.0);  //输出2.4
		double result6 = (double)num1 / num2 ; // 输出2.4
		double result6 = (double)(num1 / num2) ; // 输出2.0
		System.out.println(result5);
		System.out.println(result6);
		
		// %:取余运算
		//结果的符号与被模数 的符号相同,%号前面的是被模数
		//开发中，经常使用 % 来判断能否被除尽的情况。
		int m1 = 12;
		int n1 = 5;
		System.out.pirntln("m1 % n1 =" + m1 % n1);
		
		int m2 = -12;
		int n2 = 5;
		System.out.pirntln("m2 % n2 =" + m2 % n2);
		
		int m3 = 12;
		int n3 = -5;
		System.out.pirntln("m3 % n3 =" + m3 % n3);
		
		int m4 = -12;
		int n4 = -5;
		System.out.pirntln("m4 % n4 =" + m4 % n4);
		
		//（前）++  ：先自增1.然后再运算
		//（后）++  ：先运算，后自增1
		int a1 = 10;
		int b1 = ++a1;
		System.out.println("a1 =" + a1 + ",b1 = " + b1);
		// 输出，a1 = 11,b1 = 11
		
		int a2 = 10;
		int b2 = a2++;
		System.out.println("a2 =" + a2 + ",b2 = " + b2);
		// 输出，a1 = 11,b1 = 10
		
		int a3 = 10;
		++a3;  //或者 a3++,此时二者没有区别
		int b3 = a3;
		
		//注意点：
		short s1 = 10;
		//s1 = s1 + 1;  //编译失败
		//s1 = (short)(s1 + 1);  //正确编译
		s1++;  // 自增1 推荐该写法，比上一行的写法好
		//自增1 不会改变本身变量的数据类型
		System.out.println(s1);
		
		//问题：
		byte bb1 = 127;
		bb1++;
		System.out.pirntln("bb1 = " + bb1);
		
		//（前）--: 先自减1，后运算
		//（后）-- ;先运算，后自减1
		
		int a4 = 10;
		int b4 = --a4; //int b4 = a4--;
		System.out.pirntln("a4 + " + a4 + ",b4 = " + b4);
	}
}

5.1.1算数运算符的练习

题目：
随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
格式如下：数字xxx的情况如下：个位数：十位数：百位数：

例如：数字153的情况如下：个位数：3 十位数：5 百位数：1

5.1.1.1 练习参考代码：

（D3_AriExer.java）

class AriExer{
	
	public static void main(String[] args){
	
		int num = 187;
		
		int bai = num / 100;
		int shi = num % 100 / 10; // 或者 int shi = num / 10 % 10 ;
		int ge = num % 10;
		
		System.out.println("百位为：" + bai);
		System.out.println("十位为：" + shi);
		System.out.println("个位为：" + ge );	
	}	
}

5.2 赋值运算符.

=
+=
-=
*=
/=
%=

赋值运算符的代码示例：

（D3_SetValueTest.java）

class SetValueTest{
	public static void main(String[] args){
		
		//赋值符号： =
		int i1 = 10;
		int j1 = 10;
		
		int i2,j2;
		//连续赋值
		i2 = j2 = 10;
		
		int i3 = 10,j3 = 20;
		
		//********************
		int num1 = 10;
		num1 += 2;  //num1 = num1 + 2;
		System.out.println(num1);  //输出为12
		
		int num2 = 12;
		num2 %= 5;  // num2 = num2 % 5;
		System.out.println(num2);
		
		//注意：num1 += 2;   num1 = num1 + 2;  两者有些小区别
		short s1 = 10;
		//s1 = s1 + 2; //编译不通过
		s1 += 2;  //不会改变变量本身的数据类型
		System.out.println(s1);
		
		//开发中，如果希望变量实现 +2 的操作，有几种方法？
		//（前提：int num = 10;）
		//方式1： num = num + 2;
		//方式2： num += 2;(推荐)	

		//开发中，如果希望变量实现 +1 的操作，有几种方法？
		//（前提：int num = 10;）
		//方式1： num = num + 1;
		//方式2： num += 1;	
		//方式3： num++; 或者  ++num;   （推荐方法3）
		
	//练习1：
		int i = 1;
		i *= 0.1;
		System.out.println(i);//
		i++;
		System.out.println(i);//  i= 1
			
		//练习2：
		int m = 2;
		int k = 3;
		k *= m++; 
		System.out.println("m=" + m);  //m =3
		System.out.println("k=" + k);  //k = 6

		//练习3：
		int n = 10;
		n += (n++) + (++n);  // n1 = n1 + (n1++) + (++n);
		System.out.println(n); ///输出 32	
	}
}

5.3 比较运算符

==
!=
>
<
>=
<=
instanceof ：双目运算符，用来测试一个对象是否为一个类的实例

结论：

比较运算符的结果是boolean类型.
区分 == 和 = .

比较运算符的代码示例：

（D3_CompareTest.java）

class CompareTest{
	public static void main(String[] args){
		
		int i = 10;
		int j = 20;
		
		System.out.println("i == j"); //false
		System.out.println("i = j"); //20
		
		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b2 == b1);  //false
		System.out.println(b2 = b1);  // true

		//*************************
		//区分好==和=的区别
		
		//输出结果为假
		boolean b1 = false;
		if(b1==true)
			System.out.println("结果为真");
		else
			System.out.println("结果为假");
		
		//输出结果为真
		boolean b1 = false;
		if(b1=true) // 把b1赋值为 true
			System.out.println("结果为真");
		else
			System.out.println("结果为假");
	}
}

5.4 逻辑运算符

&
&&
|
||
！
^

说明：逻辑运算符操作的都是boolean类型的变量（与后面位运算符里的与或非之间的区别）

逻辑运算符的代码示例：

（D3_LogicTest.java）

class LogicTest{
	
	public static void main(String[] args){
		 
		//区分 & 与 &&
		/*
		1.相同点：  （1）&与&& 的运算结果相同
					（2）当符号左边是true时，二者都会执行符号右边的运算
					
		2.不同点：当符号左边 是false时，&继续执行右边的运算，&&不再执行符号右边的运算。
		3.开发中，推荐短路 &&
		*/
		
		//******************此时没有区别
		boolean b1 = true;
		int num1 = 10;
		if(b1 & (num1++ > 0)){
			System.out.println("我现在在北京");
			
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num1 = " + num1);
		
		
		boolean b2 = true;
		int num2 = 10;
		if(b2 && (num2++ > 0)){
			System.out.println("我现在在北京");
			
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num2 = " + num2);
		
		
		//***************此时有区别
		boolean b3 = true;
		b3 = false;
		int num3 = 10;
		if(b3 & (num3++ > 0)){
			System.out.println("我现在在北京");
			
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num3 = " + num3);
		
		//&&情况，出现短路，b4已经出现false，所以不再判断&&后面那个
		boolean b4 = true;
		b4 = false;
		int num4 = 10;
		if(b4 & (num4++ > 0)){
			System.out.println("我现在在北京");
			
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num4 = " + num4);
				
		//区分： | 与 ||
		/*
		1.相同点：  （1）|与|| 的运算结果相同
					（2）当符号左边是false时，二者都会执行符号右边的运算
					
		2.不同点：当符号左边 是true时，|继续执行右边的运算，||不再执行符号右边的运算。
		3.开发中，推荐使用  短路||
		*/
		
		//************此时无区别
		boolean b5 = true;
		b5 = false;
		int num5 = 10;
		if(b5 | (num5++ > 0)){
			System.out.println("我现在在北京");
			
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num5 = " + num5);
		
		
		boolean b6 = true;
		b6 = false;
		int num6 = 10;
		if(b6 || (num6++ > 0)){
			System.out.println("我现在在北京");
			
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num6 = " + num6);
		
		//*****************此时有区别
		
		boolean b7 = true;
		b7 = true;
		int num7 = 10;
		if(b7| (num7++ > 0)){
			System.out.println("我现在在北京");
			
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num7 = " + num7);
		
		boolean b8 = true;
		b8 = true;
		int num8 = 10;
		if(b8|| (num8++ > 0)){
			System.out.println("我现在在北京");
			
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num8 = " + num8);
	}
}

5.5 位运算符（了解即可）

结论：
1.位运算符操作的都是整型的数据
2. << & >>

<<:在一定范围内，每向左移1位，相当于 *2。
>>:在一定范围内，每向右移1 位，相当于 /2。

经典面试题：最高效方式的计算 2*8？
2 << 3 或 8 << 1.

位运算符代码示例：

(D3_BitTest.java)

class BitTest{
	
	public static void main(String[] args){
		int i = 21;
		i = -21;
		System.out.println("i << 2 :" + (i << 2));
		System.out.println("i << 3 ；" + (i << 3));
		System.out.println("i << 27 : " +(i << 27));
		
		int m = 12;
		int n = 5;
		System.out.println("m &  n:" + (m & n));
		System.out.println("m | n : " + (m | n));
		System.out.println("m ^ n : "  + (m ^ n));
		
		//练习：交换两个变量的值
		int num1 = 10;
		int num2 = 20;
		System.out.println("num1 = " + num1 + ",num2 = " + num2);
		
		//方式1：定义临时变量的方式
		// int temp = num1;
		// num1 = num2;
		// num2 = temp;
		
		//方式2：
		//好处：不用定义临时变量
		//弊端：相加操作可能超出存储范围； 有局限性，只适用于数值类型；
		
		num1 = num1 + num2;
		num2 = num1 - num2;
		num1 = num1 - num2;
		
		//方式三：使用位运算符(了解)
		//只适用于数值类型；
		num1 = num1 ^ num2;
		num2 = num1 ^ num2;
		num1 = num1 ^ num2;
		
		System.out.println("num1 =" + num1 + ", num2 =" + num2);
	}
}

5.6 三元（目）运算符

结构： （条件表达式）？表达式1 ：表达式2
说明：

条件表达式的结果为boolean类型
根据条件表达式真或假，决定执行表达式1，还是表达式2.
- 如果表达式为true,则执行表达式1；
- 如果表达式为false,则执行表达式2.
表达式1 和表达式2 虽然不要求是同一类型，但是要能够转化成为同一个类型
三元运算符可以嵌套使用

凡是可以使用三元运算符的地方，都可以改写成 if-elsle;
反过来，可以用 if-else 来写的，不一定可以用三元运算符。
如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：更简洁，执行效率高。

三元运算符代码示例：

（D3 _SanYuanTest.java）

class SanYuanTest{
	
	public static void main(String[] args){
		
		//获取两个整数的较大值
		int m = 12;
		int n = 5;
		
		//变量max的类型取决于表达式1  和 表达式2 统一起来的类型
		int max = (m > n)? m:n;
		System.out.println(max);
		
		double num = (m > n)? 2 : 1.0;
		
		//(m > n) ? 2 : "n大"; //编译错误
		
		//****************************
		n = 12;
		// String maxStr = (m > n)? "m大":((m == n)? "m和n相等" ："n大");
		// System.out.println(maxStr);
		String maxStr = (m > n)? "m大" : ((m == n)? "m和n相等" : "n大");
		System.out.println(maxStr);
		
		//获取三个数的最大值
		int n1 = 12;
		int n2 = 30;
		int n3 = -43;
		
		int max1 = (n1 > n2)? n1 : n2;
		int max2 = (max1 > n3)?max1 :n3;
		System.out.println("三个数中的最大值为：" + max2);
		
		//不建议这样写，可读性差
		// int max3 = (((n1 > n2)? n1 : n2 ) > n3)?((n1 > n2)? n1 : n2):n3);
		// System.out.println("三个数中的最大值为：" + max3);
		
		int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
		System.out.println("三个数中的最大值为：" + max3);
		
		//改写成 if-else:
		if(m > n){
			System.out.println(m);
		}else{
			System.out.println(n);
		}
	}
}

六.流程控制.

6.1 三种基本流程结构.

顺序结构：程序从上到下逐行地执行，中间没有任何判断和跳转。
分支结构：根据条件，选择性地执行某段代码。
有if…else和switch-case两种分支语句。
循环结构：根据循环条件，重复性的执行某段代码。
有while、do…while、for三种循环语句。
【注】：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

6.2 分支结构

6.2.1 if-else结构(条件判断语句)

6.2.1.1 if-else的三种结构：

//第一种：
if(条件表达式){
	
}

//第二种：
if(条件表达式){
	执行表达式1
}else{
	执行表达式2
}

//第三种：多选一
if(条件表达式){
	执行表达式1
}else if{
	执行表达式2
}else if{
	执行表达式3
}
....
else{
	执行表达式n
}

if-else结构代码示例：

（D3_IfTest.java）

class IfTest{
	
	public static void main(String[] args){
		
		//举例1
		int heartBeats = 79;
		if(heartBeats < 60 || heartBeats > 100){
			System.out.println("需要做进一步检查！");
			
		}
		
		System.out.println("检查结束！");

		//举例2
		int age = 23;
		if(age < 18 ){
			System.out.println("你可以看动画片");	
		}else{
			System.out.println("你可以看爱情片");
		}
		
		//举例3：
		if(age < 0){
			System.out.println("您输入的数据非法");			
		}else if(age < 18){
			System.out.println("青少年时期");	
		}else if(age < 35){
			System.out.println("青壮年时期");	
		}else if(age < 60){
			System.out.println("中年时期");	
		}else if(age <120){
			System.out.println("老年时期");
		}else{
			System.out.println("你可以成仙了！");	
		}
	}
}

6.2.1.2 [补充]使用Scanner类从键盘获取不同类型的变量。

具体实现按步骤：

导包：import java.util.Scanner;
Scanner 的实例化：Scanner scan = new Scanner(System.in);
调用Scanner类的相关方法（next()/nextXxx()），来获取指定类型的变量

【注意】：

需要根据相应的方法。来输入指定类型的值。

如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchException 导致程序终止。

Scanner类的使用代码示例：

（D4_ScannerTset.java）

//Step1:导包：import java.util.Scanner;
import java.util.Scanner;

class ScannerTest{
	public static void main(String[] args){
		
		//Step2:Scanner 的实例化：
		Scanner scan = new Scanner(System.in);
		
		//Step3:调用Scanner类的相关方法
		System.out.println("请输入您的姓名：");//让用户有更好的体验，知道在命令行处要输入什么
		String name = scan.next();
		System.out.println(name);
		
		System.out.println("请输入您的芳龄：");
		int age = scan.nextInt();
		System.out.println(age);
		
		System.out.println("请输入您的体重：");
		double weight = scan.nextDouble();
		System.out.println(weight);
		
		System.out.println("您是否相中了我呢？（true/false）");
		boolean isLove = scan.nextBoolean();
		System.out.println(isLove);
		
		//对于char型的获取，Scanner没有提供相关的方法。只能获取一个字符串。
		System.out.println("请输入您的性别：（男/女）");
		String gender = scan.next();  //"男"
		char genderChar = gender.charAt(0);//获取索引为0位置上的字符
		System.out.println(genderChar);
	}
}

6.2.1.3 if-else结构练习题

题1：

题目：
岳小彭参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆BMW；
成绩为(80，99]时，奖励一台iphone xs max；
当成绩为[60,80]时，奖励一个 iPad；
其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断

说明：
1.else结构是可选的，可以不加在程序中
2.针对于条件表达式：
》如果多个条件表达式之间是互斥关系（或没有交集关系），哪个判断和执行语句声明在上面还是下面，没有区别。
》如果多个条件表达式之间有交集，则需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
》如果多个条件表达式之间有包含关系，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行。

题1参考代码：

（D4_IfTest.java）

import java.util.Scanner;
class IfTest{
	
	public static void main(String[] args){
		
		Scanner scan = new Scanner(System.in);
	
		
		System.out.println("请输入越小彭的期末成绩：（0-100）");
		int score = scan.nextInt();
		
		if(score == 100){
			System.out.println("奖励一辆BMW");
		}else if(score > 80 && score <= 99){
			System.out.println("奖励一台iphone xsx max");
		}else if(score >= 60 && score <= 80){
			System.out.println("什么奖励也没有");
		}
	}
}

题2：

编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
对它们进行排序(使用 if-else if-else),并且从小到大输出。

说明：
1.if-else结构是可以互相嵌套的。
2.如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略。但是不建议大家省略。

题2参考代码：

（D4_IfTest2.java）

import java.util.Scanner;
class IfTest2{
	
	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入第一个整数：");
		int num1 = scan.nextInt();
		
		System.out.println("请输入第二个整数：");
		int num2 = scan.nextInt();
		
		System.out.println("请输入第三个整数：");
		int num3 = scan.nextInt();
		
		if(num1 > num2){
			if(num3 > num1){
				System.out.println(num2 + "," + num1 + "," + num3);
				
			}else if(num3 <= num2){
				System.out.println(num3 + "," + num2 + "," + num1);
			}else{
				System.out.println(num2 + "," + "num3" + "," + num2);
			}
		}else{  //以下的省略3个{}，如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略。但是不建议大家省略。
			if(num3 >= num2)
				System.out.println(num1 + "," + num2 + "," + num3);
			else if(num3 <= num1)
				System.out.println(num3 + "," + num1 + "," + num2);
			else
				System.out.println(num1 + "," + num3 + "," + num2 );
		}
	}
}

题3：

3道小练习：
3.1 输出“zyq” & 输出"x2 is 4"
3.2 狗的前两年每一年相当于人类的10.5岁，之后每增加一年就增加四岁。那么5岁的狗
相当于人类多少年龄呢？应该是：10.5 + 10.5 + 4 + 4 + 4 = 33岁。

编写一个程序，获取用户输入的狗的年龄，通过程序显示其相当于人类的年龄。如果用户输入负数，请显示一个提示信息

3.3 获取一个随机数：10 - 99

题3参考代码：

（D4_IfExer.java）

class IfTest{
	public static void main(String[] args){
		
		//******练习1********
		
		//*******输出“zyq”*************
		int x1 = 4;
		int y1 = 1;
		if (x1 > 2) {
			if (y1 > 2) 
				System.out.println(x1 + y1);
			System.out.println("atguigu");
		} else
			System.out.println("x1 is " + x1);
		
		//把所有括号去掉
		//*******输出“x2 is 4”*******************
		int x2 = 4;
		int y2 = 1;
		if (x2 > 2) 
			if (y2 > 2) 
				System.out.println(x2 + y2);
			   //System.out.println("atguigu");
		    else//就近原则
				System.out.println("x2 is " + x2);
				
		//******练习2*********
		//课后练习3：测算狗的年龄
		int dogAge = 6;
		if(dogAge >= 0 && dogAge <= 2 ){
			System.out.println("相当于人的年龄：" + dogAge * 10.5);
				
		}else if(dogAge > 2){
			System.out.println("相当于人的年龄：" + (2 * 0.5 + (dogAge - 2) * 4);			
		}else{
			System.out.println("狗狗还没出生呢！");
		}
			
		
		//******练习3*********
		//课后练习4：如何获取一个随机数：10 - 99
		int value = (int)(Math.random() * 90 + 10); //[0.0,1.0)  ---> [0.0,90.0)--->[10,99]
		System.out.println(value);
		
		/*总结
		公式：要产生在 [a,b]里的随机数，有公式：
		(int)(Math.random() * (b - a + 1) + a )
		或
		(int)(Math.random() * (b - a + 1) ) + a 
		注意：错误示范：(int)Math.random() * (b - a + 1) + a ，产生的数永远是 a
		*/
	}
}

题4:

题目：

大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出
一定的条件：高：180cm以上；富：财富1千万以上；帅：是。

如果这三个条件同时满足，则：“我一定要嫁给他!!!” ? 如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则：“不嫁！”

题4代码实现：

（D4_IfExer.java）

import java.util.Scanner;

class IfExer1{
	public static void main(String[] args){
	
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入你的身高：（cm）");
		int height = scan.nextInt();
		System.out.println("请输入你的财富：（千万）");
		double wealth = scan.nextDouble();
		
		
		/*
		方式1：
		System.out.println("请输入你是否帅：（true/false）");
		boolean isHandsome = scan.nextBoolean();
		
		if(height >= 180 && wealth >= 1 && isHandsome == true){
			System.out.println("我一定要嫁给他！！!");
		}else if(height >= 180 || wealth >= 1 || isHandsome){
			System.out.println("嫁吧，比上不足比下有余。");
		}else{
			System.out.println("不嫁！");
		}
		*/
		
		//方式2：
		System.out.println("请输入你是否帅：（是/否）");
		String isHandsome = scan.next();
		
		if(height >= 180 && wealth >= 1 && isHandsome.equals("是")){
			System.out.println("我一定要嫁给他！！!");
		}else if(height >= 180 || wealth >= 1 || isHandsome.equals("是")){
			System.out.println("嫁吧，比上不足比下有余。");
		}else{
			System.out.println("不嫁！");
		}
	}
}

6.2.2 switch-case：

6.2.2.1 switch-case的结构:

//格式
switch(表达式){
case 常量1：
	执行语句1;
	//break;
	
case 常量2：
	执行语句2;
	//break;
	
...

defult:
	执行语句n;
	//break;
}

说明：
（1）根据Switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应的case结构中，调用其执行语句.
- 当调用完执行语句后，则仍然向下继续执行其他case结构在的执行语句，直到遇到break关键字或者switch-caese结构末尾为止结束。
（2）break可以使用在Switch-case结构中，表示一旦执行到此关键字，就跳出Switch-case结构。
（3）switch结构中的表达式，只能是如下6种数据类型之一：
- byte,short,char,int,枚举类型（JDK5.0新增），String类型（JDK7.0新增）
- 浮点型，布尔类型不可以用在这种情况下
（4）case之后只能声明常量，不能声明范围.
（5）break关键字是可选的；即在switch-case语句中，break语句可加可不加，不过，绝大部分都是要加的.

（6）default:类似理解为if-else中的else语句（相当于备胎，默认值）,default结构也是可选的，而且位置是灵活的.

6.2.2.2 switch-case代码示例：

（D4_SwitchCaseTest.java）

class SwitchCaseTest{
	
	public static void main(String[] args){
		
		int number = 2;
		switch(number){
			
		case 0:
			System.out.println("zero");
			break;
			
		case 1:
			System.out.println("one");
			break;
			
		case 2:
			System.out.println("two");
			break;
			
		case 3:
			System.out.println("three");
			break;
			
		default:
			System.out.println("other");
			
		}
		
		//******错误情况一（编译不通过）*************
		//表达式用了布尔类型
		/*
		boolean isHandsome = true;
		switch(isHandsome){
		
		case true:
			System.out.println("我好帅錒~~");
			break;
		case false:
			System.out.println("我好丑錒~~");
			
		default:
			System.out.println("输入有误！！");
			
		}
		*/
		
		//*****************************
		//表达式为String类型：
		String season = "summer";
		switch (season) {
		case "spring":
			System.out.println("春暖花开");
			break;
		case "summer":
			System.out.println("夏日炎炎");
			break;
		case "autumn":
			System.out.println("秋高气爽");
			break;
		case "winter":
			System.out.println("冬雪皑皑");
			break;
		default:
			System.out.println("季节输入有误");
			break; 
		}
		
		//********错误情况二（编译不通过）****************
		/*    case后面是常量，不能声明范围
		int age = 10;
		switch(age){
		case age > 18:
			System.out.println("成年了");
			break;
		default:
			System.out.println("未成年");
			
		}
		*/
	}
}

6.2.2.2 switch-case结构的练习题

题1：

题目:
对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。
说明：如果switch-case结构中的多个case的执行语句相同，则可以考虑精选合并。

题1参考代码：

(D4_SwitchCaseTest1.java)

class SwitchCaseTest1{
	
	public static void main(String[] args){
		
		/*
		int score = 78;
		switch(score){
		case 0:
		
		case 1:
		
		case 2：
		
		....
		
		case 100:
		
		}
		*/
		
		/*
		int score = 78;
		if(score >= 60){
			
		}else{
			
		}
		*/
		
		int score = 78;
		switch(score / 10){
		case 0:
			System.out.pirntln("不及格");
			break;
		case 1:
			System.out.pirntln("不及格");
			break;
		case 2:
			System.out.pirntln("不及格");
			break;
		case 3:
			System.out.pirntln("不及格");
			break;
		case 4:
			System.out.pirntln("不及格");
			break;
		case 5:
			System.out.pirntln("不及格");
			break;
		case 6:
			System.out.pirntln("及格");
			break;
		case 7:
			System.out.pirntln("及格");
			break;
		case 8:
			System.out.pirntln("及格");
			break;
		case 9:
			System.out.pirntln("及格");
			break;
		case 10:
			System.out.pirntln("及格");
			break;
			
		//对上面代码的简化,相同语句合并
		int score = 78;
		switch(score / 10){
		case 0:
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
			System.out.pirntln("不及格");
			break;
		case 6:
		case 7:
		case 8:
		case 9:
		case 10:
			System.out.pirntln("及格");
			break;
		}
		
		//更简洁的代码：更优的解决方案
		
		switch(score / 60){
			
		case 0:
			System.out.println("不及格");
			break;
			
		case 1:
			System.out.pirntln("及格");
			break;
		}
	}
}

题2：

题目：
编写程序：从键盘上输入2019年的“month”和“day”，要求通过程序
输出输入的日期为2019年的第几天。

思路分析：
判断2月15号是当年的第几天
2 15： 31 + 15
5 7: 31 + 28 + 31 + 30 + 7
…

【本题说明】：break在switch-case 语句中是可选的。

题2参考代码：

(D4_SwitchCaseTest2.java)

import java.util.Scanner;
class SwitchCaseTest2{
	
	public static void main(String[] args){
		
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入2019年的month");
		int month = scan.nextInt();
		
		System.out.println("请输入2019年的day");
		int day = scan.nextInt();
		
		
		//定义一个变量来保存总天数
		int sumDays = 0;
		
		//该做法冗余
		/*
		switch(month){
		case 1: 
			sumDays = day;
			break;
		case 2：
			sumDays = 31 + day;
			
		case 3:
			sumDays = 31 + 28 + day;
		...
		
		}
		*/	
		//倒着写
		//为数不多break不用写的情况
		switch(month){
		case 12:
			sumDays += 30;
		case 11:
			sumDays += 31;
		case 10:
			sumDays += 30;
			
		case 9:
			sumDays += 31;
		case 8:
			sumDays += 31;
		case 7:
			sumDays += 30;
		case 6:
			sumDays += 31;
		case 5:
			sumDays += 30;
		case 4:
			sumDays += 31;
		case 3:
			sumDays += 28;
		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}
		System.out.println("2019年" + month + "月" + day + "日是当年的第" + sumDays + "天");
	}
}

题3：

题目：
从键盘分别输入年、月、日，判断这一天是当年的第几天
注：判断一年是否是闰年的标准：
1）可以被4整除，但不可被100整除
或
2）可以被400整除

【本题说明:】

凡是可以使用Switch-case 的结构，都可以转化为if-else;反之则不成立。
我们写分支结构时，当发现既可以使用switch-case结构（同时，switch中表达式的取值不太多），又可以使用if-else时，我们优先选择switch-case结构。
----------原因：switch-case的执行效率稍高。

题3参考代码：

(D4_SwitchCaseExer.java)

import java.util.Scanner;
class SwitchCaseExer{
	
	public static void main(String[] args){
		
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入year");
		int year = scan.nextInt();
		
		System.out.println("请输入month");
		int month = scan.nextInt();
		
		System.out.println("请输入day");
		int day = scan.nextInt();
		
		//定义一个变量来保存总天数
		int sumDays = 0;
		
		switch(month){
		case 12:
			sumDays += 30;
		case 11:
			sumDays += 31;
		case 10:
			sumDays += 30;
			
		case 9:
			sumDays += 31;
		case 8:
			sumDays += 31;
		case 7:
			sumDays += 30;
		case 6:
			sumDays += 31;
		case 5:
			sumDays += 30;
		case 4:
			sumDays += 31;
		case 3:
			//sumDays += 28;  //有所变化之处
			//判断year是否是闰年
			if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0){
				sumDays += 29;
			}else{
				sumDays += 28;
			}
				
		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}
		System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天");
	}
}

6.2 循环结构

循环结构的四要素
（1）初始化条件
（2）循环条件 —》必须是boolean类型
（3）循环体、（需要反复循环的结构）
（4）迭代条件

6.2.1 For循环

6.2.1.1 for循环的结构

for循环结构：
for((1);(2);(4)){
(3)
}

执行过程：
（1）–》（2）----》（3）—》（4）—》（2）----》（3）----》（4）----》。。。----》（2）

for循环代码示例：

(D4_ForTest.java)

class ForTest{
	
	public static void main(String[] args){
	
		//打出5个Hello World!
		
		for(int i = 1;i <= 5; i++){ // i:1,2,3,4,5
			
			System.out.println("Hello World!");
			
		}
		//i:在for循环内有效，出了for循环就失效了
		//System.out.println(i);//编译不通过

		//练习：
		int num = 1;
		for(System.out.println('a');num <= 3;System.out.println('c'),num++){
			System.out.println('b');
		}
		//输出结果为： abcbcbc
		
		System.out.println();

		//例题：遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
		//此处仍然可以定义i,因为前面定义的i仅在前面的for循环中起效
		int sum = 0; //记录所有偶数的和
		int count = 0; //记录所有偶数的个数
		for(int i = 1; i <= 100; i++ ){
			if(i % 2 == 0){
				System.out.println(i);
				sum += i;
				count++;
			}
			//System.out.println("总和为：" + sum);不可以在此处写，要在for循环外写
			
		}
		System.out.println("总和为：" + sum);
		System.out.println("偶数个数为：" + count);
	}
}

for循环练习题：

题1：

题目：
编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行
上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印
输出“baz”。

题1参考代码：

(D4_ForTest1.java)

class ForTest1{
	public static void main(String[] args){
		
		for(int i = 1;i <= 150;i++){		
			System.out.println(i + "  ");
			
			if( i % 3 == 0){
				System.out.print("foo");
			}
			if(i % 5 == 0){
				System.out.print("biz");
			}
			if(i % 7 == 0){
				System.out.print("baz");
			}
			
			//换行
			System.out.println();
		}
	}
}

题2：

题目：
输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。

【本题说明】：break关键字的使用

题2参考代码：

(D5_ForTest.java)

import java.util.Scanner;
class ForTest{
	
	public static void main(String[] args){
		
		Scanner scan = new Scanner (System.in);
		
		System.out.println("请输入第一个正整数：");
		int m = scan.nextInt();
		
		System.out.println("请输入第二个正整数：");
		int n = scan.nextInt();
		
		
		//获取最大公约数
		//1.获取两个数中的较小值
		int min = (m <= n) ? m:n;
		//2.遍历
		for(int i = min;i>=1;i--){
			if(m % i == 0 && n % i ==0){
				System.out.println("最大公约数为："  + i);
				break;
			}
		}
		
		//获取最小公倍数
		//1.获取两个数的较大值
		int max =  (m >= n)? m:n;
		//2.遍历
		for(int i = max; i <= m * n;i++){
			if(i % m == 0 && i % n ==0){
				System.out.println("最小公倍数：" + i);
				break;
			}
		}
	}
}

6.2.2 While循环

6.2.2.1 while循环的结构：

while循环结构：
①
while(②){
③；
④；//要是④没了，则可能出现死循环
}

执行过程：
①-②-③-④-②-③-④-。。。-②（②为false时，终止）

说明：

写while循环时，千万不要丢了迭代条件。一旦丢了，就有可能出现死循环。
我们在写程序时，要避免出现死循环。、
for循环和while循环是可以相互转换！
有点小区别：for循环和while循环的初始化条件部分的作用范围不同。
while 的①出了循环后还是可以调用。
for 的 ①出了循环后就不起效了。
【注意】算法：有限性。

while循环代码示例：

(D5_WhileTest.java)

class WhileTest{
	
	public static void main(String[] args){
		
		//遍历100以内的所有偶数
		int i = 1;
		while(i <= 100){
			if(i % 2 == 0){
				System.out.println(i);
			}
			
		i++;
		}
		
		//这个 i 出了while循环后，仍然可以调用。
		System.out.println(i); //101	
	}
}

6.2.3 do-while循环

6.2.3.1 do-while循环结构：

结构：
①
do{
③；
④；
}while(②);

执行过程：
①-③-④- ②-③-④-。。。-②

说明：
1.do-while循环至少会执行一次循环体
2.开发中，使用for和while更多一些。较少使用do-while.

do-while循环结构代码示例：

(D5_DoWhileTest.java)

class DoWhileTest{
	
	public static void main(String[] args){
		
		//遍历100以内的偶数,并计算所有偶数的和记偶数的个数
		int num = 1;
		int sum = 0;//记录总和
		int count = 0;//记录个数
		do{
			if(num % 2 == 0){
				System.out.println(num);
				sum += num;
				count++;
			}
			num++;
		}while(num <= 100);
		
		System.out.println("总和为：" + sum);
		System.out.println("个数为：" + count);
		
		
		//*********do-while循环至少会执行一次循环体********************
		//若都会执行多次，则，while和do-while没有什么区别
		int number1 = 10;
		while(number1 > 10){
			System.out.println("hello:while");
			number1--;
		}
		
		int number2 = 10;
		do{
			System.out.pirntln("hello:do-while");
			number2--;
		}while(number2 > 10);
	}
}

6.2.4 嵌套循环

嵌套循环的使用：

嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环
外层循环：循环结构B
内层循环：循环结构A
说明：
①内层循环结构遍历一遍，只相当于外层循环体执行了一次
②假设外层循环需要执行m次，内层循环需要执行n次,此时内层循环一个执行了 m * n 次
技巧：
外层循环控制行数；内层循环控制列数

For-While 代码示例：

题目：
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入
为0时结束程序。

【本题说明】：
1.不再循环条件部分限制次数的结构：for(;;)或while(true)
2.结束循环有几种方式？
方式1：循环条件部分返回false
方式二：在循环体中，执行break

参考代码：

(D5_ForWhileTest.java)

import java.util.Scanner;

class ForWhileTest{
	
	public static void main(String[] args){
		
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入任意多个整数：");

		int positiveNumber = 0;
		int negativeNumber = 0;
		
		//*********做法一**************8
		//在无法确定循环次数时，循环条件写个true即可
		while(true){
			int number = scan.nextInt();
			
			//判断number的正负情况
			if(number > 0){
				positiveNumber++;
			}else if(number < 0){
				negativeNumber++;
			}else{
				//一旦执行break,跳出循环
				break;
			}
		}
		
		
		System.out.println("输入整数个数为：" + positiveNumber);
		System.out.println("输入负数个数为：" + negativeNumber);
		
		
		//*********做法二*****************
		//在无法确定循环次数时，循环条件写个(;;)即可
		for(;;){
			int number = scan.nextInt();
			
			//判断number的正负情况
			if(number > 0){
				positiveNumber++;
			}else if(number < 0){
				negativeNumber++;
			}else{
				//一旦执行break,跳出循环
				break;
			}
		}
		
		System.out.println("输入整数个数为：" + positiveNumber);
		System.out.println("输入负数个数为：" + negativeNumber);
		
	}
}

For-For循环代码示例：

(D5_ForForTest.java)

class ForForTest{
	public static void main(String[] args){
		
		//想要输出“ ****** “
		//System.out.print("******");
		for(int i = 1;i <= 6;i++){
			System.out.print('*');
		}
		
		System.out.println("\n");
		
		/*想要输出
		******
		******
		******
		******
		******
		*/
		
		for(int j = 1;j <= 4;j++){
			for(int i = 1; i <= 6;i++){
				System.out.print('*');
			}
			System.out.println();
		}
		
		/*想要输出              i(行号)    j(*的个数)
		*                           1          1
		**                          2          2
		***                         3          3
		****                        4          4 
		*****                       5          5
		*/
		
		for(int i = 1;i <= 5;i++){ //控制行数
			for(int j = 1; j <= i; j++){ //控制列数
				System.out.print("*");
			}
			System.out.println();
		}
		
		/*想要输出             i(行号)    j(*的个数)  规律：i + j =5
		****                      1          4
		***                       2          3
		**                        3          2
		*                         4          1                          5          5
		*/
		for(int i = 1;i <= 4;i++){ //控制行数
			for(int j = 1; j <= 5 - i; j++){ //控制列数
				System.out.print("*");
			}
			System.out.println();
		}
		
		/*输出
		
		*
		**
		***
		****
		*****
		****
		***
		**
		*
	
		*/
		//略，上述代码两个拼一起即可
		
		/*输出
		
		*/
	}
}

嵌套循环的练习题：

题1：

题目：
输出九九乘法表
提示：
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
…
9 * 1 = 9 。。。。。9 * 9 =81

题1参考代码：

（D5_NineNineTable.java）

class NineNineTable{
	public static void main(String[] args){
		for(int i = 1;i <= 9; i++){
			for(int j = 1;j <= i; j++){
				System.out.print(i + "*" + j + "=" + (i * j) + "\t" );
				
			}
			System.out.println();
		}
	}
}

题2：

题目：
100000以内所有质数的输出
质数：素数，只能被1和它本身整除的自然数。
-------》方法：从2开始，到（这个数-1）结束为止，都不能被这个数本身整除。
注：最小的质数为2.

题2参考代码：

(D5_PrimeNumberTest.java)

class PrimeNumberTest{
	
	public static void main(String[] args){
		
		//获取当前时间距离1970-01-01 00：00：00 的毫秒数
		long start = System.currentTimeMillis();
		
		for(int i = 2;i <= 100000; i++){  //遍历100000以内的自然数
			
			boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
			
			
			//优化二：主要对本身是质数的自然数起作用，对非质数的数也起作用，但是没有break的作用大
			
			for(int j = 2;j <= Math.sqrt(i);j++){
			//for(int j = 2; j < i;j++){//j:被i去除
			
				if(i % j ==0){ //i被j除尽
					isFlag = false;
					break; //优化一：只对本身非质数的自然数是有效的
				}
			}
			
		
		
			//
			if(isFlag == true){
				System.out.println(i);
			}
			
			//重置isFlag
			//isFlag = true;
			
			
		}
		//获取当前时间距离1970-01-01 00：00：00 的毫秒数
		long end = System.currentTimeMillis();
		
		System.out.println("所花费的时间为：" + ( end - start));
		//未优化前用时：20105ms  -优化一：break:2585  - 优化二：1014
	
	}
}

6.2.5 break和continue关键字的使用

关键字	使用范围	循环中的使用范围(不同点)	相同点
break	switch-case结构和循环结构	跳出包裹此关键字最近的一层循环	关键字后面不能声明执行语句
comtinue	循环结构	结束指定标识的一层循环结构的当次循环

代码示例：

(D5_BreakContinueTest.java)

class BreakContinueTest{
	public static void main(String[] args){
		
		for(int i = 1;i <= 10; i++){
			
			if(i % 4 == 0){
				//break; // 输出结果：123
				continue; //输出：12356789
			}
			
			System.out.println(i);
			
		}
		System.out.println("\n");
		
		//*****************************
		
		label:for(int i = 1;i <= 4; i++){
			for(int j = 1;j <= 10;j++){
				if(j % 4 == 0){
					//break; //默认跳出包裹此关键字最近的一层循环。
					//continue;
					
					//break label;//结束指定标识符的一层循环结构
					continue label; //结束指定标识的一层循环结构的当次循环
					
				}
				System.out.println(j);			
			}
			System.out.println();
		}
	}
}