史上最强java基本语法讲解|附练习题（超详细版本

蔓嘉

已于 2023-10-08 19:18:04 修改

阅读量125

点赞数 5

分类专栏： java基础文章标签： java 开发语言

于 2023-09-28 19:57:23 首次发布

本文链接：https://blog.csdn.net/m0_55483876/article/details/133378300

版权

java基础专栏收录该内容

9 篇文章 0 订阅

订阅专栏

下一篇持续更新中…（如有错误 ,欢迎指正！！）

书接上回，在上一篇我讲解了第一个java程序HelloWorld的编译、运行和在这个过程中你可能会遇到的问题。希望通过昨天的学习，你已经能够独立完成：

搭建Java的开发环境
理解Java的加载与执行
编写HelloWorld程序，编译并运行
掌握环境变量path的原理以及如何配置

今天这一篇我将为你讲解，如何配置环境变量classpath以及它的作用原理、对HelloWorld程序进行初步解释以及java语言基础语法。（知识点超详细，附有练习题，回顾个别知识点的同学可以直接通过目录跳转，废话不多说，长篇预警！！！！！）

续上一篇

1. 配置环境变量classpath

在运行HelloWorld时，你有没有遇见这样的问题？
在这里插入图片描述
要解决这个问题，首先我们要明白：DOS命令窗口执行java HelloWorld的执行原理：

java.exe命令会启动jvm
JVM启动之后会启动类加载器ClassLoader
ClassLoader会在硬盘上某个位置搜索HelloWorld.class字节码文件
找到该文件则执行
找不到该文件则报错

问题：ClassLoader是在哪个位置上搜索HelloWorld.class字节码文件的？

默认情况下，Classloader从当前路径下加载xxx.class字节码文件。
当然，也可以让ClassLoader去某个指定的路径下加载字节码文件，这时需要配置环境变量classpath
- classpath环境变量属于Java语言中的环境变量，不属于Windows操作系统。【path环境变量属于操作系统】）
- classpath是给ClassLoader类加载器指路的，你可以设置这样的环境变量：classpath=D:\java project\TEST把“ .class ”所在路径添加进去
- 这样，打开DOS命令窗口在任意位置，都可以执行;java HelloWorld
- classpath环境变量没有配置的话，类加载器默认从当前路径下找字节码文件；当classpath环境变量配置为某个指定的路径之后，类加载器只去指定的路径当中加载字节码文件。
- 当然，classpath也可以这样配置：" classpath=. "。以后就得运行前切换到.class路径下，需要加载别的.class文件，在后面加一个“ ; ”再加上就可以了。

注意：
路径中“. .”表示上级目录
路径中“.”表示当前目录

配置classpath环境变量后你可以去重新运行你的HelloWorld，怎么样？成功了没？（手动狗头

2. java源程序的注释

-单行注释

 //单行注释，只注释当前行

-多行注释

	/*
    多行注释
	多行注释
	多行注释
	多行注释
	多行注释
	多行注释
	多行注释
    */

-javadoc注释

 /**
	* javadoc注释
	* javadoc注释
	* javadoc注释
	* javadoc注释
	* javadoc注释
	* javadoc注释
	* javadoc注释
	*/

注意：这种注释是比较专业的注释，该注释信息会被javadoc.exe工具解析提取并生成帮助文档。
在这里插入图片描述

3. 对HelloWorld源程序初步解释

//public表示公开的
//class表示定义一个类
//HelloWorld表示一个类名
public class HelloWorld{//表示定义一个公开的类，起名HelloWorld

	//类体中不允许直接编写Java语句【除声明变量之外】
	//System.out.println("Hello World!");

	//类体【记住】

	/*
         public表示公开的
		 static表示静态的
		 void表示空
		 main表示方法名是main
		 (string[] args)是一个main方法的形式参数列表 

		 需要记住的是：
		 以下的方法是一个程序的"主方法"，是程序的执行入口
		 是sun公司规定的，固定编写方式。
	*/
    public static void main(String[] args){//表示定义一个公开的静态的主方法

		//方法体
		//方法体
		//方法体
		//方法体
		//方法体
		//方法体

		//java语句【Java语句以“;”终止，分号必须是半角分号】
		//先记住：以下这样代码的作用是向控制台输出一段字符串
		//以下的双引号必须是半角的双引号【是Java语法的一部分】
		//Java中所有的“字符串”都使用双引号括起来
		System.out.println("Hello World!");

		//再向控制台输出消息
		System.out.println("Hello Jessica!");

		//输出中文
		System.out.println("你好，杰西卡！");

		//输出中文【以下，程序员两边的双引号是全角的，
		//这里的双引号不是Java语法的一部分，这里的全角的双引号只是一个普通的字符串】
		System.out.println("我是一个“程序员”");

		//大括号成对写，防止忘
		//记得缩进
    }
}

4. public class和class的区别：

class B
{
	public static void main(String[] args){
		System.out.println("B's main method invoke!");
	}
}
class X
{
	public static void main(String[] args){
		System.out.println("X's main method invoke!");
	}
}
class Y
{
	public static void main(String[] args){
		System.out.println("Y's main method invoke!");
	}
}
class Z
{
	public static void main(String[] args){
		System.out.println("Z's main method invoke!");
	}
}
public class K
{
	public static void main(String[] args){
		System.out.println("K's main method invoke!");
	}
}

*一个Java源文件当中可以定义多个class

*一个Java源文件当中public的class不是必须的

*一个class会定义生成一个xxx.class字节码文件

*一个Java源文件当中定义公开的类的话，只能有一个，并且该类名称必须和Java源文件名称一致

*每一个class当中都可以编写main方法，都可以设定程序的入口：

   想执行B.class中的main方法：java B
   想执行X.class中的main方法：java X

*注意：当在命令窗口中执行java Hello，那么要求Hello.class当中必须有主方法。没有主方法会出现运行阶段的错误：
在这里插入图片描述

本篇：java基础语法

1. 标识符

类、方法、变量、常量、枚举、接口等，在Java源程序中，凡是程序员有权利自己命名的单词都是标识符。
标识符在EditPlus编辑器当中以黑色字体高亮显示
标志符的命名规则
【不按照这个规则来，编译器会报错，这是语法】
1. 一个合法的标识符只能由“数字、字母、下划线_、美元符号$”组成，不能含有其他符号
2. 不能数字开头
3. 严格区分大小写
4. 关键字不能做标识符
5. 理论上无长度限制,但是最好不要太长
标识符的命名规范？
【只是一种规范，不属于语法，不遵守规范编译器不会报错】
1. 见名知意
2. 驼峰命名方式
  1. 大驼峰法【首字母大写，后面每个单词首字母大写】–>类名、接口名、文件名
  2. 小驼峰法【首字母小写，后面每个单词首字母大写】–>变量名、方法名
  3. 全部大写：常量名
  4. 全部小写：包名

2. 关键字

关键字是由语言本身定义好的，不能挪作他用。
关键字在EditPlus工具中颜色是蓝色高亮
关键字在Java语言当中全部小写

常见的关键字有哪些？
public
class
static
void
if
for
while
do
default
byte
short
int
long
float
double
boolean
char
private
protected
switch
true
false
throw
throws
try
catch
…

提醒：关键字不需要单独拿出来记忆，编写程序的过程中记忆

3. 字面值

不同的数据类型有不同的定义语法和可以对其进行的操作，数据类型对应的具体的值就是字面值，＂helloworld＂是字符串类型的字面值，false是布尔类型的字面值【新手可以理解为：一眼看上去就知道这个数类型、大小的值】

字面值是Java源程序的组成部分之一。包括标识符和关键字都是Java源程序的组成部分。
字面值就是数据，而数据在现实世界中是分门别类的，所以数据在计算机编程语言当中也是有类型的：【数据类型】
-10、100 整数型字面值
-3.14 浮点型字面值
-true\false 布尔型字面值
-“abc”“中国人” 字符串型字面值
-‘A’‘人’ 字符型字面值
注意：
- Java语言中所有的字符串型字面值必须使用半角双引号括起来
- Java语言中所有的字符型字面值必须使用半角单引号括起来

public class ConstTest01
{
	public static void main(String[] args){
	System.out.println("abc");

	System.out.println("你最近过得怎么样？");

	System.out.println(10);

	System.out.println(false);

	System.out.println('A');

	System.out.println(3.14)

	System.out.println("3.14")

	//编译报错;因为单引号中只能存放单个字符，属于字符型字面值
	//System.out.println('ABC')
	}
}

4. 数据类型

不同的数据有不同的类型，不同的数据类型底层会分配不同大小的空间，数据类型的作用是指导JVM在运行程序时该给数据分配多大的内存空间。

分类：

1.a. 基本数据类型【四大类八小种】：

第一类：整数型
byte,short,int,long
第二类：浮点型
float,double
第三类：布尔型
boolean
第四类：字符型
char

ps：字符串"abc"不属于基本数据类型，属于“引用型数据类型”，字符属于基本数据类型：
* 字符串使用双引号"abc"
* 字符使用单引号’a’

2. 八种基本数据类型各自占用空间大小：

	基本数据类型			占用空间大小【单位：字节】
	-----------------------------------------------------
	byte							1
	short							2	
	int								4			
	long							8
	float							4
	double							8		
	boolean							1
	char							2

A.二进制

计算机在任何情况下都只能识别二进制。例如：只认识010101010101010…【现代的计算机底层采用交流电的方式，接通和断开就两种状态，计算机只识别1或0，其他不认识】

二进制是数据的一种表示形式。十进制表示满十进一原则。二进制表示满二进一原则。

十进制转换成二进制：短除法

二进制转换成十进制：2 4 8 16 32 64 128…【实在算不明白开计算器（手动狗头】

  	例如：十进制
  		0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  	例如：二进制
  		0 1 10 11 100 101 110 111 1000 1001......
  		0 1  2  3  4   5   6   7   8    9 .......

B.字节（byte）：

		1 byte = 8 bit 【1个字节 = 8个比特位】1个比特位表示一个二进制：1/0
		1 KB = 1024 byte
		1 MB = 1024 KB
		1 GB = 1024 MB
		1 TB = 1024 GB

		1TB = 1024 * 1024 * 1024 * 1024 * 8

3. 八种数据类型的取值范围:

A.关于Java中的数字类型

数字都是有正负之分的，所以在数字的二进制当中有一个二进制位被称为“符号位”。这个“符号位”在所有二进制位的最左边，0表示正数，1表示负数。

整数型当中的byte类型，占用1个字节，所以byte类型的数据占用8个比特位。

		* byte类型最大值：01111111
		【
			00000000 00000000 00000000 10000000（二进制）
				减去1的结果是
			00000000 00000000 00000000 01111111（二进制）
		】
		* byte类型最大值：2的7次方 - 1，结果是：127
		* byte类型最小值：-128【具体怎么用二进制表示，这个和原码、反码、补码有关】

		* byte类型的取值范围：[ -128 ~127 ]

		* byte类型可以表示256个不同的数字【256个不同的二进制】

B. 字符编码

八种基本数据类型当中byte,short,int,long,float,double,boolean这7种数据类型计算机在表示的时候比较容易，因为底层都是数字，十进制的数字和二进制之间存在一种固定的转换规则。
但是char类型表示的是现实世界中的文字，文字和计算机二进制之间 “ 默认” 情况下是不存在任何转换关系的。为了让计算机可以表示现实世界当中的文字，需要人为干涉，人负责提前制定好“文字”和“二进制”之间的对照关系。这种转换关系就是：字符编码。

计算机最初只支持英文，最先出现的字符编码是：ASCII码

‘a’–>97【01100001】
‘A’–>65
‘0’–>48

‘a’–(按照ASCII解码)–>01100001
01100001—（按照ASCII编码）–>‘a’

编码和解码的时候采用同一套字典/对照表，不会出现乱码；当解码和编码的时候采用的不是同一套对照表，会出现乱码问题。

随着计算机的发展，后来出现了一种编码方式，是国际化标准组织ISO制定的，
这种编码方式支持西欧语言，向上兼容ASCII码，仍然不支持中文。这种编码方式
是:ISO-8859-1,又称为latin-1

  	* 随着计算机向亚洲发展，计算机开始支持中文、日文、韩文等国家文字，其中支持
  	简体中文的编码方式：
  		GB2312 < GBK < GB18030

  	* 支持繁体中文：大五码<big5>

  	* 后来出现了一种编码方式统一了全球所有的文字，容量较大，这种编码方式叫做：**unicode编码**
  	
  	unicode编码方式有多种具体的实现：
  		-UTF-8
  		-UTF-16
  		-UTF-32
  		......

Java语言源代码采用的是Unicode编码方式，所以“标识符”可以用中文。现在在实际开发中，一般使用UTF-8编码方式比较多。【统一编码方式】

C. 八种数据类型的取值范围:

		类型				取值范围
		--------------------------------
		byte				[-128~127]
		short				[-32768~32767]
		int					[-2147483648~2147483647]
		long
		float
		double
		boolean				[true/false]	
		char				[0~65535]

		注意：short和char所表示的种类总数是一样的，只不过char可以表示更大的正整数。因为char没有负数。

//以下Java程序主要讲解的是数据类型之：char程序
public class DataTypeTest01
{
	public static void main(String[] args){
	
		//定义一个char类型的变量，起名c，同时赋值字符'a'
		char c = 'a';
		System.out.println(c);

		//一个中文占用2个字节，char类型正好是2个字节
		//所以Java中的char类型变量可以存储一个中文字符
		char x = '国';
		System.out.println(x);

		//编译错误
		//ab是字符串不能使用单引号括起来
		//char y = 'ab';

		//"a"是字符串类型
		//k变量是char类型
		//类型不兼容，编译错误
		//char k = "a"

		//声明
		char e;

		//赋值
		e = 'e';
		System.out.println(e);

		//再次赋值
		e = 'f';
		System.out.println(e);
	}
}

4. 八种数据类型的默认值

	数据类型						默认值
	-------------------------------------------------
	byte,short,int,long				0
	float,double					0.0
	boolean							false【在c语言中，true是1，false是0】
	char							\u0000	

八种基本数据类型的默认值是一切向0看齐。

public class DataTypeTest02
{	
	//这里的static必须加，别问为什么！
	static int k = 1000;

	//变量还是遵守这个语法：必须先声明，再赋值，才能访问。
	//成员变量没有手动赋值，系统会自动赋值【局部变量不会】
	static int f;//成员变量

	public static void main(String[] args){
	
		/*
		int i;//局部变量
		System.out.println(i);
		*/

		System.out.println(k);
		System.out.println(f);
	}
}

1.b. 引用数据类型【后边讲】

			-类
			-接口
			-数组
			.....

1.a.1. char 类型（转义字符：\）

转义字符出现在特殊字符之前会将特殊字符转换成普通字符。
\n 换行符
\t 制表符
\ 普通的反斜杠
’ 普通的单引号
" 普通的双引号

public class DataTypeTest03
{
	public static void main(String[] args){
	
		//普通的n字符
		char c1 = 'n';
		System.out.println(c1);

		//依照目前所学知识，以下程序无法编译通过，因为显然是一个字符串，不能使用单引号括起来
		//但是经过编译，发现编译通过了，这说明以下并不是一个字符串，而是一个字符
		//这是一个“换行符”，属于char类型的数据
		//反斜杠在Java语言当中具有转义功能
		char c2 = '\n';

		System.out.println(c2);

		/*
		System.out.println("Hello");
		System.out.println("World!");
		*/

		//System.out.print()和System.out.println()的区别:
		//println输出之后换行，print表示输出，但是不换行
		/*
		System.out.print("Hello");
		System.out.println("World!");
		*/

		System.out.print('A');
		System.out.print(c2);
		System.out.println('B');
		
		//普通的t字符
		char x = 't';
		System.out.println(x);

		//制表符tab
		char y = '\t';
		System.out.print('A');
		System.out.print(y);
		System.out.println('B');

		//要求在控制台上输出“反斜杠字符”
		//反斜杠将后面的单引号转译成不具备特殊含义的普通单引号字符
		//左边的单引号缺少了结束的单引号字符，编译报错
		/*
		char k = '\';
		System.out.println(k);
		*/
		
		//解释：第一个反斜杠具有转义功能，将后面的反斜杠转义为普通的反斜杠字符
		//结论：在java中两个反斜杠代表一个普通的反斜杠字符
		char k = '\\';
		System.out.println(k);
	
		//在控制台上输出一个普通的单引号字符
		//java中不允许这样编程，编译报错
		//char a = '''

		//以下编译报错，第一个单引号和第二个单引号配对儿，最后的单引号找不到另一半！
		//char a = '''
		//System.out.println(a);

		//反斜杠具有转义功能，将第二个单引号转换成普通的单引号字符，第一个单引号和最后单引号配对
		char a = '\'';
		System.out.println(a);

		char f = '"';
		System.out.println(f);

		System.out.println("HelloWorld!");
		System.out.println("“HelloWorld!”");
		
		//编译错误
		//System.out.println(""HelloWorld!"");
		//纠正
		System.out.println("\"HelloWOrld!\"");

		
		char m = '中';
		System.out.println(m);

		//JDK中自带的native2ascii.exe命令，可以将文字转换成unicode编码形式
		//怎么使用这个命令？
		//在命令行中输入native2ascii，回车，然后输入文字之后回车即可得到unicode编码
		char n = '\u4e2d';//'中'对应的unicode编码是4e2d
		System.out.println(n);

		//编译错误
		//char g = '4e2d';
		//编译错误
		//char g = 'u4e2d';
		//通过：反斜杠u联合起来后面的一串数字是某个文字的unicode编码
		char g = '\u4e2d';
		System.out.println(g);


		System.out.println("=======");


		//g = '\u456a';
		//g = '\u256a';
		//g = '\u456b';
		//System.out.println(g);

		//char类型的默认值
		char c10 = '\u0000';
		System.out.println(c10);
		
	}
}

/*

	十进制：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
	二进制：0 1 10 11 100 101 ...
	十六进制:0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20
	八进制：0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 20

*/

1.a.2. 整数型

	数据类型			占用空间			默认值			取值范围
	----------------------------------------------------------------------
	byte				1					0				[-128 ~ 127]
	short				2					0				[-32768 ~ 32767]
	int					4					0				[-2147483648 ~ 2147483647]
	long				8					0L

Java语言中的“整数型字面值”被默认当作int类型来处理。要让这个“整数型字面值”被当作long类型来处理的话，需要在“整数型字面值”后面添加l或L，建议使用大写的L

Java语言中的整数型字面值有三种表示方式：
第一种表示方式：十进制【是一种缺省默认的方式】*常用
第二种表示方式：八进制【在编写八进制整数型字面值的时候需要以0开始】
第三种表示方式：十六进制【在编写十六进制整数型字面值的时候需要以0x开始】

public class DataTypeTest04
{
	public static void main(String[] args){
	
		int a = 10;
		int b = 010;//整数型字面值以0开头的，后面那一串数字就是八进制
		int c = 0x10;//整数型字面值以0x开头的，后面那一串数字就是十六进制

		System.out.println(a);//10
		System.out.println(b);//8
		System.out.println(c);//16

		System.out.println(a + b + c);//34

		//123这个整数型字面值是int类型
		//i变量声明的时候也是int类型
		//int类型的123赋值给int类型的变量i，不存在类型转换
		int i = 123;
		System.out.println(i);

		//456整数型字面值被当作int类型，占用4个字节
		//x变量在声明的时候是long类型，占用8个字节
		//int类型的字面值456赋值给long类型的变量x，存在类型转换
		//int类型转换成long类型
		//int类型是小容量
		//long类型是大容量
		//小容量可以自动转换成大容量，称为自动转换机制。
		long x = 456;
		System.out.println(x);

		//2147483647字面值是int类型，占用4个字节
		//y是long类型，占用8个字节，自动类型转换
		long y = 2147483647;
		System.out.println(y);

		//编译错误：过大的整数：2147483648
		//2147483648被当作int类型4个字节来处理，但是这个字面值超出int类型范围
		//long z = 2147483648;

		//解决错误
		//2147483648字面值一上来就当作long类型来处理，在字面值后面加L
		//2147483648L是8个字节的long类型
		//z是long类型变量，以下程序不存在类型转换。
		long z = 2147483648L;
		System.out.println(z);
	
	}
}

1.a.3. 浮点型

float 单精度【4个字节】 / double 双精度【8个字节，精度较高】

double的精度太低【相对来说的】，不适合做财务软件。财务软件涉及到钱的问题，要求精度较高，所以sun在基础SE类库当中为程序员准备了精度更高的类型，只不过这种类型是一种引用数据类型，不属于基本数据类型，它是：java.math.BigDecimal

其实java程序中sun提供了一套庞大的类库，Java程序员是基于这套基础的类库来进行开发的。所以要知道java的SE类库的字节码在哪，要知道java的SE类库的源码在哪（看到这里的同学可以自行去下载jdk的文件夹里查找）

		* SE类库字节码：D:\java course\javaSE course\03下载\jdk8\jre\lib\rt.jar
		* SE类库源码：D:\java course\javaSE course\03下载\jdk8\src.zip

例如：String.java和String.class
(String[ ] args)中的String使用的就是String.class字节码文件

在Java语言中，所有的浮点型字面值【3.0】，默认被当作double类型来处理，要想该字面值当作float类型来处理，需要在字面值后面添加F/f

	注意：	
		double和float在计算机内部二进制存储的时候存储的都是近似值。
		在现实世界中有一些数字是无限循环的，例如：3.333333....
		计算机的资源是有限的，用有限的资源存储无限的数据只能存储近似值

public class DataTypeTest06
{
	public static void main(String[] args){
	
		//3.0是double类型的字面值
		//d是double类型的变量
		//不存在类型转换
		double d = 3.0;
		System.out.println(d);

		//5.1是double类型的字面值
		//f是float类型变量
		//大容量转换成小容量需要加强制类型转换符吗，所以以下程序编译错误。
		//float f = 5.1;

		//解决方案：
		//第一种方式：强制类型转换符
		//float f = (float)5.1;
		
		//第二种方式：没有类型转换
		float f = 5.1f;
	}
}

1.a.4.布尔型Boolean

在java语言当中Boolean类型只有两个值：true、false，没有其他值。不像c语言当中，0和1可以表示假和真。在底层存储的时候boolean类型占用1个字节，因为实际存储的时候false底层是0，true底层是1。
布尔类型在实际开发当中非常重要，经常使用在逻辑运算和条件控制语句当中。


public class DataTypeTest07
{
	public static void main(String[] args){
	
	//编译错误：不兼容的类型
	//boolean flag = 1;

	//boolean loginSuccess = false;
	boolean loginSuccess = true;

		//if语句以后讲【条件控制语句】
		if(loginSuccess)
		{
			System.out.println("恭喜你，登陆成功");
		}else{
			System.out.println("对不起，用户名不存在或者密码错误！");
		}	
	}
}

5. 基本数据类型之间的互相转换规则

八种基本数据类型当中除布尔类型之外剩下的7种类型之间都可以相互转换.eg:char c = 97;
小容量向大容量转换，称为自动类型转换，容量从小到大排序：
byte < short < int < long < float < double < char

注：任何浮点类型不管占用多少个字节，都比整数型容量大。char和short可表示的种类数量相同，但是char可以取更大的正整数
大容量转换成小容量，叫做强制类型转换，需要加强类型转换符，程序才能编译通过，但是在运行阶段可能会损失精度，所以谨慎使用。
当整数字面值没有超出byte、short、char的取值范围，可以直接赋值给byte,short,char类型的变量
byte、short、char混合运算的时候，各自先转换成int类型再做运算
多种数据类型混合运算，先转换成容量最大的那种类型再做运算

//右侧先计算再赋值，右侧计算结果是int类型
double dd = 10 / 3;
System.out.println(dd);//3.0

dd = 10.0/3;
System.out.println(dd);//3.33333333335

long g = 10;
//编译期只检查语法，不进行运算，JVM参与时进行运算。
//出现精度损失问题，以下问题主要是优先级问题
//将g转换成int，然后再将int类型的g转换成byte，
//最后byte类型的g和3运算，那么它的运算结果类型就是int，所以int赋值给byte就出现了精度损失
//byte h = (byte)(int)g/3;
byte h = 3;//可编译通过，3没有超出byte类型取值范围
byte h = (byte)(int)(g/3);//可以

short i = 10;
byte j = 5;
//错误，short和byte类型运算，首先会转换成int类型再运算
//所以运算结果为int，int赋值给short会出现精度丢失的问题
//short = i + j;

//可以将运算结果强制转换成short
//short = (short)(i + j);

char l = 'a';
System.out.println(l);//a
System.out.println((byte)l);//97，也就是a的ascii值

5. 变量

A. 变量的基本概念

什么是变量？
变量本质上来说是内存中的一块空间，这块空间包含三部分：数据类型、名称、字面值【数据】，变量是内存中存储数据的最基本的单元。
变量要求：
变量中存储的具体的“数据”【字面值】必须和变量的“数据类型”一致，当不一致的时候编译报错。
声明 / 定义变量的语法格式：数据类型+空格+变量名
变量在一行上可以声明多个

int a,b,c;

变量名只要是合法的标志符就行。规范要求：首字母小写，后面每个单词首字母大写
变量声明之后赋值的语法格式：变量名 = 字面值
声明和赋值可以放到一起完成。

int i = 10;

>目前我们还没有学习数据类型，但是提前告诉大家有一种数据类型是整数型叫做int

变量赋值之后，可以重新赋值，变量的值可变化：
有了变量的概念之后，内存空间得到了重复的使用：

int i = 10;
			System.out.println(i);
			...
			....
			System.out.println(i);

通常访问一个变量包括两种访问形式：
* 第一种：读取变量中保存的具体数据 get/获取
* 第二种：修改变量中保存的具体数据 set/设置

i = 20;  //set

			System.out.println(i);  //get

变量先声明然后赋值再访问

在方法体中的java代码，是遵守自上而下的顺序依次逐行执行。
第一行;
第二行;
第三行;
* 特点：第二行的代码必须完整的结束之后，第三行程序才能执行。

public class VariableTest01
{
	public static void main(String[] args){
	
	//声明一个int类型的变量，起名i
	int i;
	//编译报错：变量i并没有初始化
	//System.out.println(i);

	//给i变量赋值，i变量在这里完成初始化，内存开辟
	i = 100;
	System.out.println(i);

	//i再次重新赋值
	i = 200;
	System.out.println(i);

	//一行上可以同时声明多个变量
	//a和b尚未初始化，c赋值300
	int a,b,c = 300;

	//编译错误
	//System.out.println(a);

	//编译错误
	//System.out.println(b);

	System.out.println(c);

B. 变量的作用域

变量的作用域就是变量的作用范围。在变量的作用范围之内是可以被访问的，只要出了这个范围，该变量就无法访问了。【新手可以理解为：出了大括号就不认识了】

在同一个“作用域”当中，变量名不能重名，但是变量可以重新赋值；在不同的作用域当中，变量名是可以相同的。

public class VarTest03
{
	//注意：这里的static不要去掉
	static int k = 90;


	public static void main(String[] args){
		
		//变量i的作用域是main方法
		//在整个main方法当中是有效的、可见的，可以访问的
		int i = 100;
	
		System.out.println(i);//可以

		System.out.println(k);//可以

		//以下会编写一个for循环语句
		//这个for循环后面的控制语句的时候详细讲解
		for(int a=0;a<10;a++){
		//a变量的作用域是整个for循环，for循环结束之后，a变量的内存就释放了
		
		}

		//这里无法访问a变量
		//System.out.println(a);

		int j;//作用域是main方法
		
		for(j=0;j<0;j++){
		
		System.out.println(j);//访问的是main方法中的变量j		
		}
	}
	public static void doSome(){

		//这里无法访问main方法中的变量i
		//已经出了i变量的作用域
		//System.out.println(i);
	
		//可以
		System.out.println(k);
		}
}

C. 变量的分类

变量根据变量声明的位置来分类：

局部变量：在方法体当中声明的变量叫做局部变量，局部变量在使用的前必须要赋值。
成员变量：在方法体外【类体之内】声明的变量叫做成员变量，成员变量系统会给默认值，具体根据数据类型判断，一般向零看齐。

public class VarTest04
{
	//成员变量
	int k = 200;

	//主方法：入口
	public static void main(String[] args){
	
		//i变量就是局部变量
		int i = 10;
		
		//Java遵循“就近原则”
		System.out.println(i);
	}

	//成员变量
	int i = 100;

	//类体中不能直接编写java语句【除声明变量之外】
	//System.out.println(i);

	//doSome方法
	public static void doSome(){
	
		//局部变量
		int i = 90;
	}
}

6. 运算符

算术运算符

	+	求和
	-	相减
	*	乘积
	/	商
	%	求余数【取模】

	++	自加1
	--	自减1

一个表达式当中有多个运算符，运算符有优先级，不确定加小括号，优先级得到提升。新手可不专门记忆运算符的优先级。

public class OperatorTest01
{
	public static void main(String[] args){
	
		int i = 10;
		int j = 3;

		System.out.println(i + j);//13
		System.out.println(i - j);//7
		System.out.println(i * j);//30
		System.out.println(i / j);//3
		System.out.println(i % j);//1
	
		//以下以++为例，--运算符自学！
		//关于++运算符【自加1】
		int k = 10;

		//运算符可以出现在变量后面【单目运算符】
		k ++；

		System.out.println(k);//11

		int y = 10;

		//++运算符可以出现在变量前面【单目运算符】
		++ y;

		System.out.println(y);//11

		//小结：
		//++运算符可以先出现在变量前，也可以出现在变量后，无论是变量前还是变量后
		//只要++运算结束，该变量中的值一定会自加1


		//++出现在变量后
		//规则：先做赋值运算，再对变量中保存的值进行自加1
		int a = 100;
		int b = a ++;
		System.out.println(a);//101
		System.out.println(b);//100

		//++出现在变量前
		int m = 20;
		int n = ++ m;
		System.out.println(m);//21
		System.out.println(n);//21
		}
	}

关系运算符

A. 关系运算符的运算结果一定是布尔类型：true/false

	>			大于
	>=			大于等于
	<			小于
	<=			小于等于
	==			等于
	!=			不等于

	=			是赋值运算符
	== 			是关系运算符

B. 关系运算符的运算原理
int a = 10;
int b = 10;
a > b 比较的时候，比较的是a中保存的10这个值和b中保存的10的这个值之间的大小比较
a == b也是如此

逻辑运算符

& 逻辑与：只有两个操作数都是真，结果才是真
| 逻辑或
! 逻辑非
^ 逻辑异或：两输入值不相同时,结果为真

&& 短路与
|| 短路或

逻辑运算fu要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型
短路与 / 或和逻辑与 / 或最终的运算结果是相同的，只不过短路与 / 或存在短路现象
第一个表达式执行结果是true，会发生短路或；第一个表达式执行结果是false，会发生短路与。
从某个角度来看，短路与更智能。由于后面表达式可能不执行所以执行效率更高。这种方式在实际的开发中使用较多。短路与比逻辑与使用的多。短路与更常用。但是，在某些特殊的业务逻辑当中，要求运算符两边的算子必须全部执行，此时必须使用逻辑与，不能使用短路与，使用短路与可能导致右边的表达式不执行。

public class OperatorTest03
{
	public static void main(String[] args){
		
		//运算符优先级不确定加小括号
		System.out.println(5 > 3 & 5 > 2);//true
		System.out.println(5 > 3 & 5 > 6);//false
		System.out.println(5 > 3 | 5 > 6);//true

		System.out.println(true & false);//false
		System.out.println(true & true);//true
		System.out.println(false & false);//false

		System.out.println(true | false);//true
		System.out.println(false | false);//false
		
		System.out.println(!false);//true
		System.out.println(!true);//false

		System.out.println(true ^ false);//true
		System.out.println(false ^ false);//false
		System.out.println(true ^ true);//false

		/*
			//逻辑与和短路与
			int x = 10;
			int y = 8;
			//逻辑与
			System.out.println(x < y & ++x < y);
			System.out.println(x); //11		
		*/
		
		//逻辑与和短路与
		int x = 10;
		int y = 8;
		//短路与
		//x < y 结果是false，整个表达式结果已经确定是false
		//只有后面的表达式没有再执行，这种现象被称为短路现象
		//短路与才会有短路现象，逻辑与是不会存在短路现象的
		System.out.println( x < y && ++x < y);
		System.out.println(x);//10
		}
}

赋值类运算符

基本的赋值运算符
=
扩展的赋值运算符
+=
-=
*=
/=
%=

赋值类的运算符优先级：先执行等号右边的表达式，然后将执行结果赋值给左边的变量

注意以下代码：

 byte i = 10;
 i += 5;等同于：i = (byte)(i + 5);

 int k = 10;
 k += 5;等同于：k = (int)(k + 5)l;

 long x = 10L;
 int y = 20;
 y += x;等同于：y = (int)(y + x);

重要结论：
扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是byte类型，无论怎么进行追加或追减，最终该变量的数据类型还是byte类型。

public class OperatorTest01
{
	public static void main(String[] args){
	
		//基本的赋值运算符
		int i = 10;

		System.out.println(i);//10

		i = i + 5;
		
		System.out.println(i);//15

		//扩展的赋值运算符【+=运算符可以翻译为“追加、累加”】

		i += 5;//等同于i = i + 5;

		System.out.println(i);//20

		i -= 5;//等同于i = i - 5;

		System.out.println(i);//15

		i *= 2;//等同于i = i * 2;

		System.out.println(i);//30

		i /= 4;//等同于i = i /4;

		System.out.println(i);//7

		i %= 2;//等同于i = i % 2;

		System.out.println(i);//1

		//------------------------------------

		//10没有超出byte取值范围，可以直接赋值
		byte b = 10;
		//b = 15;//可以，编译通过，15没有超出byte取值范围
		//编译错误，为什么？
		//编译器只检查语法，不运行程序，编译器发现b + 5的类型是int类型，b变量的数据类型是byte
		//大容量向小容量转换需要加强制类型转换符，所以以下程序编译报错
		//b = b + 5;
		//纠正错误
		b = (byte)(b + 5);
		System.out.println(b);//15

		byte x = 10;
		x += 5;//等同于：x = (byte)(x + 5);其实并不等同于x = x + 5;
		System.out.println(x);//15

		byte z = 0;
		z += 128;//等同于：z = (byte)(z + 128);
		System.out.println(z);//-128【损失精度】

		z += 10000;//等同于：z = (byte)(z + 10000);
		System.out.println(z);//-112

	}
}

字符串连接运算符 “ + ”

+运算符在java语言中有两个作用：
* 加法运算，求和
* 字符串的连接运算
当“+”运算符两边的数据都是数字的话，一定是进行加法运算
当“+”运算符两边的数据只要有一个数据是字符串，一定会进行字符串连接运算，并且，连接运损之后的结果还是一个字符串类型。

数字 + 数字 --> 数字【求和】

数字 + “字符串” --> “字符串”【字符串连接】
在一个表达式当中可以出现多个“+”，在没有添加括号的前提之下，遵循自左向右的顺序依次运算。

public class OperatorTest02
{
	public static void main(String[] args){
	
		System.out.println(10 + 20);//30，这里的加号是求和
		System.out.println(10 + 20 + 30);//60，这里的加号也是求和
		System.out.println(10 + 20 + "30");//3030，自左向右的顺序依次运算，第一个加号是求和，第二个加号是字符串连接
		System.out.println(10 + (20 + "30"));//102030
		
		int a = 10;
		int b = 20;

		//要求在控制台上输出"10 + 20 = 30"
		System.out.println("10 + 20 = 30");

		//注意：要求以动态的方式输出
		System.out.println("10 + 20 = " + a + b);//"10 + 20 = 1020"
		System.out.println("10 + 20 = " + (a + b));//"10 + 20 = 30"
		System.out.println("a + 20 = " + (a + b));//"a + 20 = 30"
		System.out.println(a + " + b = " + (a + b));//"10 + b = 30"
		System.out.println(a + " + " + b + " = " + (a + b));//"10 + 20 = 30"
		
		a = 100;
		b = 200;
		System.out.println(a + " + " + b + " = " + (a + b));

		//引用类型String
		//String是SUN在javase当中提供的字符串类型
		//String.class字节码文件
		
		//int是基本数据类型，s是变量名，10是int类型的字面值
		int i = 10;

		//String是引用数据类型，s是变量名，"abc"是String类型的字面值
		//String s = "abc"
		String s = "abc";

		String username = "zhangsan";

		System.out.println("登录成功，欢迎" + username + "回来");
	}
}

三元运算符

语法规则：布尔表达式 ? 表达式1 : 表达式2
当布尔表达式的结果是true的时候，选择表达式1作为整个表达式的执行结果；当布尔表达式的结果是false的时候，选择表达式2作为整个表达式的执行结果。

public class OperatorTest03
{
	public static void main(String[] args){
	
	//编译错误，不是一个完整的Java语句
	//10；

	//编译错误，不是一个完整的Java语句
	//'男'

	//布尔类型的变量
	boolean sex = false;

	//分析以下程序是否可以编译通过？
	//编译错误，不是一个完整的Java语句，这只是一个值
	//sex ? '男' : '女';

	char c = sex ? '男' : '女';
	System.out.println(c);

	//语法错误，编译报错，结果可能是String，也可能是char，但是前边不能用char来接收数据。
	//类型不兼容
	//char c1 = sex ? "男" : '女';

	//编译错误，类型不兼容
	/*
	sex = false;
	char c1 = sex ? "男" : '女';
	*/
	//这个方法的括号里面什么类型的数据都可以写
	System.out.println(10);
	System.out.println("10");
	System.out.println('1');


	//可以
	System.out.println(sex ? '男' : "女");

	String s = sex ? "男的" : "女的";
	System.out.println(s);
	}
}

7. 控制语句

1. 选择结构

A. if / if…else

if语句又被称为分支语句/条件控制语句：

第一种：
				if(布尔表达式){
					java语句;
					java语句;
					java语句;
					java语句;
					java语句;
					......
				}
				
第二种：
				if(布尔表达式){
					java语句;
					java语句;
					......
				}else{
					java语句;
					java语句;
					......
				}
				
第三种：
				if(布尔表达式){
					java语句;
					java语句;
					......
				}else if(布尔表达式){
					java语句;
					java语句;
					......
				}else if(布尔表达式){
					java语句;
					java语句;
					......
				}else if(布尔表达式){
					java语句;
					java语句;
					......
				
}......

第四种：
				if(布尔表达式){
					java语句;
					java语句;
					......
				}else if(布尔表达式){
					java语句;
					java语句;
					......
				}else if(布尔表达式){
					java语句;
					java语句;
					......
				}else if(布尔表达式){
					java语句;
					java语句;
					......
				}else{
					java语句;
					java语句;
					......
				}

重点：对于Java中的if语句来说，只要有一个分支执行，整个if语句全部结束。
注意：以上的第二种编写方式和第四种编写方式都带有else分支，这两种方式可以100%保证会有分支执行。
“所有的控制语句if for”都是可以嵌套使用的，只要合理嵌套就行
嵌套使用的时候，代码格式要保证完美。【该缩进的时候必须缩进，大部分情况下使用大括号包围的需要缩进】

if(){
	if(){
		if(){
			if(){
				}
			}
		}
	}

if语句的分支中只有一条java语句的话，大括号可以省略不写
if( true / false ){ 一条Java语句; }
if(true) 一条java语句;
这种方式不推荐使用，别人这么写能看懂就行
举个栗子:

public class IfTest04
{
	public static void main(String[] args){
		
		boolean sex = true;
		if(sex){
			System.out.println("男");
		}else{
			System.out.println("女");
		}

		sex = false;

		if (sex)System.out.println("男"); else System.out.println("女");
		
		//-------------------------------------------------------

		if (sex)
		{
			System.out.println("男");
			System.out.println("呵呵");
		}
		else
			System.out.println("女");

		//以上程序编译错误出现在26行，26行以上没有语法错误。
	}
}

练习题1 ：

（仅供初学者练习改语法使用）

public class IfTest01
{
	public static void main(String[] args){
	
		//需求：所在位置的五公里范围之内有肯德基的话，去KFC吃午饭
		//公里数
		double distance = 1.0;//单位：KM

		//判断语句
		if(distance < 5)
		{
			System.out.println("去KFC吃午饭");
		}

		/*
			需求：
			假设系统给定一个考生的成绩，成绩可能带有小数点
			根据学生的成绩判断该学生的成绩等级：
				[90-100] A
				[80-90)  B
				[70-80)  C
				[60-70)  D
				[0-60)   E

			以上的逻辑判断采用if语句完成，应该怎么写？
		*/

		//double score = 56;
		
		//见名知意原则：应该统一把 x 换成 grade。
		double score = 101;
		String x = "对不起，您输入的成绩不合法";
		if(score < 0 || score > 100){
			x = "对不起，您输入的成绩不合法" ;
		}
		else if(score >= 90){
			x = "你的分数是A" ;//能够判断到这里说明成绩一定是[0-100]
		}
		else if(score >= 80){
			x = "你的分数是B"; 
		}
		else if (score >= 70){
			x = "你的分数是C"; 
		}
		else if (score >= 60){
			x = "你的分数是D"; 
		}else{
			x = "对不起，您的分数不及价格" ;
		}
		System.out.println(x);
	}
}

练习题2 ：

/*
	需求：
		假设系统给定一个人的年龄，根据年龄来判断这个人处于生命的哪个阶段，年龄必须在[0-150]
		[0-5] 幼儿
		[6-10] 少儿
		[11-18] 青少年
		[19-35] 青年
		[36-55] 中年
		[56-150] 老年
*/
public class IfTest02
{
	public static void main(String[] args){

		//1、接收键盘输入：年龄【输入的时候必须输入数字】
		java.util.Scanner s = new java.util.Scanner(System.in);
		//让光标不换行闪动
		//System.out.println("请输入您的年龄");
		System.out.print("请输入您的年龄：");//输出提示信息，要不然用户根本不知道这里要干嘛！
		int age = s.nextInt();//停下来等待用户的输入，输入之后自动接收，赋值给age变量
		//System.out.println("age = " + age);

		//2、根据需求进行业务逻辑判断

		String str = "老年";//先给一个默认值
		if (age < 0 || age > 150){
			str = "您提供的年龄不合法，年龄值需要在[0-150]之间";
		}
		else if (age <= 5)
		{
			str = "您处于幼儿阶段";
		}
		else if (age <= 10)
		{
			str = "您处于少年阶段";
		}
		else if (age <= 18)
		{
			str = "您处于青少年阶段";
		}
		else if (age <= 35)
		{
			str = "您处于青年阶段";
		}
			else if (age <= 55)
		{
			str = "您处于中年阶段";
		}
		else if (age <= 150)
		{
			str = "您处于老年阶段";
		}
		System.out.println(str);
	}
}

练习题3 ：

/*
	需求：

		判断当前的天气
			当外边下雨的时候：
				带雨伞：
					判断性别：
						当性别为男：带一把黑伞
						当性别为女：带一把花伞

			当外边是晴天的时候：
				判断天气的温度;
					当温度在30度以上：
						当性别为男：戴墨镜
						当性别为女：擦防晒霜

		提示：
			1、一定会用到嵌套
			2、天气状况、温度、性别都需要从键盘输入

				天气状况：1表示下雨，0表示晴天
				温度直接使用数字即可
				性别：1表示男，0表示女
*/
public class IfTest03
{
	public static void main(String[] args){
		
		//接收
		java.util.Scanner s = new java.util.Scanner(System.in);
		
		//简单说明
		System.out.println("欢迎使用本系统，您通过本系统可以完成一些简单的判断");
		System.out.println("说明1：1表示下雨，0表示晴天");
		System.out.println("说明2：1表示男，0表示女");
		System.out.println("说明3：温度为数字");

		//接收性别
		System.out.print("请输入您的性别：");
		int sex = s.nextInt();

		//接收天气情况
		System.out.print("请输入当前天气情况：");
		int weather = s.nextInt();

		//判断天气情况
		//下雨天
		if (weather == 1)
		{			
			if (sex == 1)
			{
				System.out.println("带一把大黑伞");
			}else if(sex == 0){
				System.out.println("带一把小花伞");
			}else{
				System.out.println("对不起，您的性别是怎么回事？");
			}
		//晴天
		}else if(weather == 0){
			//接收温度
			System.out.println("请输入当前温度：");
			int tem = s.nextInt();
			if (tem > 30)
			{			
				if (sex == 1)
				{
					System.out.println("戴墨镜");
				}else if(sex == 0){
					System.out.println("涂防晒霜");
				}else{
					System.out.println("对不起，您的性别是怎么回事？");
				}		
			}
		}else{
					System.out.println("对不起，您输入的天气不存在！");
				}					
	}
}

B. switch

switch语句的语法结构：

 	一个比较完整的switch语句应该这样编写：

 		switch(int或String类型的字面值或变量){
 			case int 或 String类型的字面值或变量：
 				java语句;
 				java语句;
 				java语句;
 				...
 				break;
 			case int 或 String类型的字面值或变量：
 				java语句;
 				java语句;
 				java语句;
 				...
 				break;
 			case int 或 String类型的字面值或变量：
 				java语句;
 				java语句;
 				java语句;
 				...
 				break;
 			case int 或 String类型的字面值或变量：
 				java语句;
 				java语句;
 				java语句;
 				...
 				break;
 			...
 			default:
 				java语句;
 				...					
 		}

switch语句的执行原理：
switch后面小括号当中的“数据”和case后面的“数据”进行一一匹配，匹配成功的分支执行。

按照自上而下的顺序依次匹配
匹配成功的分支执行，分支当中最后有“break;”语句的话，整个switch语句终止。
匹配成功的分支执行，分支当中没有“break;”语句的话，直接进入下一个分支执行（不进行匹配），
这种现象被称为case穿透现象。【提供break;语句可以避免穿透】
这种分支都没有匹配成功，当有default的语句的话，会执行default分支当中的程序
switch后面和case后面只能是int或String类型的数据，不能探测其他类型。

当然byte,short,char也可以直接写到switch和case后面，因为他们可以进行自动类型转换。byte,short,char可以自动转换成int类型。
JDK6的，switch和case后面只能探测int类型
JDK7之后包括7版本在内，引入新特性，switch关键字和case关键字后面可以探测出int或String类型的数据。

case可以合并

	int i = 10;

			switch(i){
				case 1 : case 2 : case 3 : case 10;
					System.out.println("Test Code!");
			}

举堆栗子：

public class SwitchTest01
{
	public static void main(String[] args){
		
		/*
		long a = 10L;
		int b = a;//损失精度，编译报错
		*/

		/*
		long x = 100L;
		switch(x){}//损失精度，编译报错
		*/

		//解决编译错误
		long x = 100L;
		switch((int)x){}

		byte b = 10;
		switch(b){};

		char c = 'A';
		switch(c){};

		char cc = 97;
		switch(cc){};

		//编译报错
		//switch(true){}

		String username = "zhangsan";
		switch (username){}

多敲练习

//接收用户的输入
		//1 表示星期一
		//2 表示星期二
		//...
		//7 表示星期日

		java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.print("请输入数字：");
		int num = s.nextInt();
		switch (num)
		{
		case 1 :
			System.out.println("星期一");
			break;
		case 2 :
			System.out.println("星期二");
			break;
		case 3 :
			System.out.println("星期三");
			break;
		case 4 :
			System.out.println("星期四");
			break;
		case 5 :
			System.out.println("星期五");
			break;
		case 6 :
			System.out.println("星期六");
			break;
		case 7 :
			System.out.println("星期日");
			break;
		default :
			System.out.println("对不起，您输入的数字非法！");
		
		}

Switch确实可以探测String类型

public class SwitchTest02
{
	public static void main(String[] args){
		java.util.Scanner s = new java.util.Scanner(System.in);

		System.out.print("今天星期几？");

		String dayOfWeek = s.next();

		switch(dayOfWeek){
			
			case "星期一":
				System.out.println(1);
				break;
			case "星期二":
				System.out.println(2);
				break;
			case "星期三":
				System.out.println(3);
				break;
			case "星期四":
				System.out.println(4);
				break;
			case "星期五":
				System.out.println(5);
				break;
			case "星期六":
				System.out.println(6);
				break;
			case "星期日":
				System.out.println(7);
				break;	
			default :
					System.out.println("对不起，你输入的数据非法！");
		}
	}
}

练习题 1 ：

/*
	实现计算器当中的
		+
		-
		*
		/
		%

	实现思路：
		1、选择所有数据从键盘输入
		2、使用switch语句进行判断
		3、需要从控制台输入三次：
			* 第一个数字
			* 运算符
			* 第二个数字

		最终在控制台上是这样的一个场景;
			欢迎使用简单计算器系统：
			请输入第一个数字：10
			请输入运算符：+
			请输入第二个数字：20
			运算结果：10 + 20 = 30

*/

public class SwitchTest04
{
	public static void main(String[] args){
		java.util.Scanner s = new java.util.Scanner(System.in);

		System.out.println("欢迎使用简单计算器系统！");

		System.out.print("请输入第一个数字：");
		int num1 = s.nextInt();

		System.out.print("请输入运算符：");
		String operator = s.next();

		System.out.print("请输入第二个数字：");
		int num2 = s.nextInt();

		int result = 0;
		switch (operator)
		{
		case "+" :
			result = num1 + num2;
			break;
		case "-" :
			result = num1 - num2;
			break;
		case "*" :
			result = num1 * num2;
			break;
		case "/" :
			result = num1 / num2;
			break;
		case "%" :
			result = num1 % num2;
			break;
		}
		System.out.println("运算结果：" + num1 + operator + num2 + "=" + result);
	}
}

练习题 2 ：

/*
	假设系统给定考生成绩，请判断该考生的成绩等级：

		1、有效成绩范围：[0-100]

		2、考试成绩可能带有小数

		3、考试成绩和等级之间的对照关系：
			[90-100]	A
			[80-90)		B
			[70-80)		C
			[60-70)		D
			[0-60)		E

		4、以上需求必须采用switch语句完成，不能采用if。

		窍门：(int)(成绩 / 10)
		0
		1
		2
		3
		4
		5
		6
		7
		8
		9
		10
*/
public class SwitchTest05
{
	public static void main(String[] args){

		//考生成绩
		double score = 85.5;
		
		//转换int
		int grade = (int)(score / 10);

		switch (grade)
		{
		case 9: case 10:
			System.out.println("A");
			break;
		case 8:
			System.out.println("B");
			break;
		case 7:
			System.out.println("C");
			break;
		case 6:
			System.out.println("D");
			break;
		default :
			System.out.println("E");
		}
	}
}

2. 循环结构

循环结构：
在程序当中总有一些需要反复的/重复的执行的代码，假设没有循环结构，那么这段需要重复执行的代码自然是需要重复编写的。代码无法得到重复使用。所以多数编程语言都是支持循环结构的。将来把需要反复执行的代码片段放到“循环体”，再联合“计数器”，共同控制这段需要反复执行的代码。
基本上所有编程语言支持的循环包括三种：

for 循环
while 循环
do…while循环

A.for

语法结构：

			for( 初始化表达式 ; 布尔表达式 ; 更新表达式 ){
				//是需要重复执行的代码片段【循环体：由java语句构成】
			}

for循环执行过程 / 执行原理

初始化表达式、布尔表达式、更新表达式都不是必须的！（；；）是必须要的
初始化表达式最先执行，并且在整个for循环当中只执行一次布尔表达式必须是true/false，不能是其他值
for的执行过程：

* 先执行初始化表达式，并且该表达式只执行一次

			* 判断布尔表达式的结果是 true 还是 false 
				
				- 布尔表达式 true

					* 执行循环体
					
					* 执行更新表达式

					* 判断布尔类型表达式的结果是 true 还是 false
						
						- true
						...

						- false
						...

				- 布尔表达式 false
					
					* 循环结束

举堆栗子：

public class ForTest01
{
	public static void main(String[] args){
		
		/*
		//需求：输出数字1-10
		System.out.println(1);
		System.out.println(2);
		System.out.println(3);
		System.out.println();
		System.out.println(4);
		System.out.println(5);
		System.out.println(6);
		System.out.println(7);
		System.out.println(8);
		System.out.println(9);
		System.out.println(10);
		*/

		//使用循环结构来代替以上所有反复执行的代码块
		//使用循环语句可以让代码量变少

		//将以上代码修改为for循环
		for (int i = 1 ; i <= 10 ; i = i + 1)
		{
			System.out.println(i);
			
		}
		for (int i = 1 ; i <= 10 ; i += 1)
		{
			System.out.println(i);
		}
		for (int i = 1 ; i <= 10 ; i++ )
		{
			System.out.println(i);
		}
		//死循环
		//ctrl c结束死循环
		for (; ; )
		{
			System.out.println("死循环");
		}
		
	}
}

1. i 变量的作用域

public class ForTest02
{
	public static void main(String[] args){
		
		//以下的for循环当中"i"变量的作用域是仅限于当前for循环内部使用
		for (int i = 0 ; i < 10 ; i++ )
		{
			System.out.println(" i ---> " + i );
		}

		//以下的for循环当中"i"变量的作用域是仅限于当前for循环内部使用
		for (int i = 0 ; i <= 10 ; i++ )
		{
			System.out.println(" i ---> " + i );
		}
		//这个i变量可以在main方法的作用域当中访问吗？无法访问
		//System.out.println("i = " + i);//编译错误

		//main方法作用域当中的变量，只要main方法没有结束，这里的i就能用
		int i = 0;

		for (; i < 10 ;  i++ )
		{
			System.out.println(" i = " + i);
		}

		//这里可以访问main方法作用域当中的i变量
		System.out.println("i ===>" + i);
		

		int j;

		for ( j = 1 ; j < 10 ; j++ )
		{
			System.out.println(" j--> " + j);
		}
		System.out.println(j);
	}
}

小练习：

public class ForTest03
{
	public static void main(String[] args){
	
	//输出1~10中所有的奇数
	for (int i = 1;i<=10 ;i+=2 )
	{
		System.out.println("i--->" + i);//1 3 5 7 9 
	}

	//输出1~10中所有的偶数
	for (int i = 2;i<=10 ;i+=2 )
	{
		System.out.println("i--->" + i);//2 4 6 8 
	}
	
	for (int i = 10;i > 0 ;i-- )
	{
		System.out.println("i===>" + i);//10 9 8 7 6 5 4 3 2 1 
	}
	for (int i = 100;i>=50 ;i-=10 )
	{
		System.out.println("i====>" + i);//100 90 80 70 60 50

	}
	for (int i = 0;i<10 ; )
	{
		i++;
		System.out.println("计数器===>" + i);//1 2 3 4 5 6 7 8 9 10
	}
	for (int i = 0;i<10 ; )
	{
		System.out.println("计数器===>" + i);//0 1 2 3 4 5 6 7 8 9
		i++;
	}

	}
}

2. 循环语句和条件语句嵌套使用（附例）

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

	//找出1~100所有的奇数
	//第一种方案：从1开始，每次递增2，这样每一个数字一定是奇数
	for (int i = 1;i<=100 ;i+=2 )
	{
		System.out.println("i--->" + i);
	}

	//第二种方案：从1开始，每次递增1，每一个数据都进行判断，判断标准是该数字对2求余数
	for (int i = 1;i<=100 ;i+=1 )
	{
		int x = i % 2;
		if (x != 0)
		{
			System.out.println("i--->" + i);
		}
	}
		//以上两种方案，优先选择第一种方案，代码少，循环次数少，效率较高

	}
}

练习题 1 ：

/*
	在前一个程序的基础之上，计算1~100所有奇数的和
		1 + 3 + 5 + 7 + 9 + ...... +99 累加

	运算符 += 就是专门完成追加的。

*/
public class ForTest05
{
	public static void main(String[] args){

		int sum = 0;//定义一个盒子，sum存的是最终求和结果，不能把sum定义到循环体里，每次执行都会把求和结果归零
	
		for (int i = 1;i<=99 ;i+=2 )
		{
				sum += i; 
		}
		System.out.println("sum = " + sum);//输出语句也不能放到循环体里，以上循环全部结束之后，最终输出求和结果
	
	}
}

3. for循环嵌套for循环

public class ForTest06
{
	public static void main(String[] args){
		for (int i = 1;i<=10 ;i++ )//共循环10次
		{
			//循环体中可以编写其他控制语句
			//控制语句可以嵌套使用
			//控制语句可以是：if\if..else\switch\for\while\do..while
			
			if ()
			{
				for (; ; )
				{
					while ()
					{
						if ()
						{
							for (; ; )
							{
							}
						}
					}
				}
			}

			//最好不要想太多，即使循环体当中是一个for循环，不要将这个for特殊化，也只是一个普通的for循环
			//只不过是一段符合java语法的代码

			//内层循环，内层循环中的变量名和外层循环中的变量名不能重名
			/*
				for（int i = 100;;）{}
			*/

			//System.out.println("i--->" + i);

			//这里是循环体，无论这个循环体当中编写了什么样的代码，这堆代码也需要执行10遍

			for (int i = 0;i < 10 ;i++ )
			{
				for (int j = 0;j<3 ;j++ )
				{
					System.out.println("j--->" + j);//30遍012
				}
			}

		}
	}
}

练习题1、2 ：

public class ForTest07
{
	public static void main(String[] args){
	
	for (int i = 0;i<10 ;i++ )//循环10次
	{	
		System.out.println("Begin!");
		//这里的代码片段执行10遍
		for (int j = 0;j<1 ;j++ )//循环1次，输出0
		{
				System.out.println("j--->" + j);
		}
		System.out.println("Over");
	}
		/*
			Begin
			0
			Over
			Begin
			0
			Over
			Begin
			0
			Over
			Begin
			0
			Over
			Begin
			0
			Over
			Begin
			0
			Over
			Begin
			0
			Over
			Begin
			0
			Over
			Begin
			0
			Over
			Begin
			0
			Over

		*/


		for (int i = 1;i<=5 ;i++ )
		{
			System.out.println("开始");

			for (int j = 1;j<=5 ;j++ )
			{
				System.out.println(i * j);
			}
			System.out.println("结束");
		}
			/*
				开始
				（1*1）1
				（1*2）2
				（1*3）3
				（1*4）4
				（1*5）5
				结束
				开始
				（2*1）2
				（2*2）4
				（2*3）6
				（2*4）8
				（2*5）10
				结束
				开始
				（3*1）3
				（3*2）6
				（3*3）9
				（3*4）12
				（3*5）15
				结束
				开始
				（4*1）4
				（4*2）8
				（4*3）12
				（4*4）16
				（4*5）20
				结束
				开始
				（5*1）5
				（5*2）10
				（5*3）15
				（5*4）20
				（5*5）25
				结束

			*/
	}
}

练习题 3：

/*
	使用for循环输出九九乘法表：

	1*1=1
	2*1=1 2*2=4
	3*1=3 3*2=6 3*3=9
	............
	................
	9*1=9 ......................9*9=81
*/
public class ForTest08
{
	public static void main(String[] args){
		for (int i = 1;i<=9 ;i++ )//外层循环9次
		{
			//循环体当中的程序主要的任务是什么？
			//处理当前行，将当前行中所有的项目全部输出
			for (int x = 1;x<=i ;x++ )
			{
				System.out.print(i + "*" + x + "=" + i * x + " ");
				//空格
				//System.out.print(" ");
			}
			//换行
			System.out.println("");
			//System.out.print("\n");
		}
	}
}

B.while

语法结构：

while(布尔表达式){
	循环体;
}

while循环的执行原理：

先判断布尔表达式的结果：
	* true
		- 执行循环体
			* 判断布尔表达式的结果：
				* true
					- 执行循环体
						* 判断布尔表达式的结果
							...
				* false
					- 循环结束
	* false
		- 循环结束

while循环的循环次数：0 ~ n次【while的循环体可能执行次数为0】

public class WhileTest01{
	public static void main(String[] args){
		//死循环
		while(true){
			System.out.println("死循环");
		}
		//编译器检测到该程序永远都无法被执行，所以编译报错
		//System.out.println("HelloWorld!");

		int i = 10;
		int j = 3;
		while(i > j){
			System.out.println("你好！");
		}
		
		//编译错误
		/*
		while(10 > 3){
			System.out.println("你好！");
		}
		*/
		
		System.out.println("HelloWorld!");
	}
}

练习题 1：

//使用while循环输出1~10
public class WhileTest02{
	public static void main(String[] args){
		int i = 1;
		while(i <= 10){
			System.out.println(i);
			i++
		}
		System.out.println("end--->" + i);
		System.out.println(-----------------------);
		int j = 10;
		while(j > 0){
			System.out.println(j--);//10 9 8 7 6 5 4 3 2 1 
			System.out.println(j);//9 8 7 6 5 4 3 2 1 0
		}
		System.out.println("end--->" + j);//0
		System.out.println(----------------------------);
		int k = 10;
		while(k >= 0){
			System.out.println(--K);//9 8 7 6 5 4 3 2 1 0 -1
		}
		System.out.println("end k---->" + k);
	}
}

C.do…while

语法结构：

do{
	循环体;
}while(布尔表达式);

执行原理
do…while循环的循环体代码片段执行次数是：1 ~ n次【至少一次】
注意：do…while语句最后有一个“ ; ”别忘了

public class DoWhileTest01{
	public static void mian(String[] args){
		int i = 10;
		do{
			System.out.println(i);//有点先斩后奏的意思
		}while(i > 100);
		System.out.println(------------------------);
		while(i > 100){
			System.out.println("i--->" + i);//x
		}
		System.out.println(----------------------------);
		int a = 1;
		do{
			System.out.println(a);//1 2 3 4 5 6 7 8 9 10
			i++;
		}while(a <= 10);
	}
}

3. 控制循环语句

A. break

“ break ; ” 可以是一个单独的完整的java语句
可以使用在switch语句当中用来终止switch语句的执行
还可以用在循环语句当中用来终止循环的执行
break语句使用在for,while,do…while循环语句当中用来跳出循环，终止循环的进行。因为当程序循环到某个条件的时候，后续的循环没必要执行了，再执行也是耗费资源，所以可以终止循环，这样可以提高程序的执行效率。
在默认情况下：break语句终止的是离他最近的循环语句。当然也可以指定终止某个循环，需要给循环起名子，采用这种语法：break+空格+循环名称 ;

举个栗子：

public class BreakTest01{
	public static void main(String[] args){
		for(int i = 1;i <= 1;i++){
			if(i == 5){
				break;//终止的是当前的for循环
			}
			System.out.println("i--->" + i);//0 1 2 3 4
		}
		//这里的程序和以上的for循环无关
		System.out.println("HelloWorld!");

		for(int j = 0 ;j < 3;j++){
			for(int i = 0 ;i < 10;i++){
				if(i == 5){
					break;//当前的break语句终止的是内层for循环，因为这个for离它最近
						  //这里的break语句不会影响到外层for循环
						  	
		//给for循环起名for1
		for1:for(int j = 0 ;j < 3;j++){
					//给for循环起名for2
					for2:for(int i = 0 ;i < 10;i++){
						if(i == 5){
							break for1;//终止for1循环
				}
				System.out.println("i--->" + i);
			}
		}
	} 
}

B. continue

“ continue ; ” 可以是一个单独的完整的java语句
break和continue区别：

break表示循环不执行了
continue表示终止当前本次循环，直接进入下一次循环继续执行
【了解】语法：continue+空格+循环名称

public class ContinueTest01{
	public static void main(String[] args){
		for(int i = 0;i < 10;i++){
			if(i == 5){
				continue;
			}
			System.out.println("i--->" + i);//0 1 2 3 4 6 7 8 9 
		}
		System.out.println("HelloWorld!");

		for(int i = 0;i < 10;i++){
			if(i == 5){
				break;//只要这个语句执行，当前本次循环停止，直接进入下一次循环继续执行
			}
			System.out.println("i--->" + i);//0 1 2 3 4 
		}
		System.out.println("HelloWorld!");

		MyFor:for(int i = 0;i < 10;i++){
			if(i == 5){
				continue MyFor;
			}
			System.out.println("i--->" + i);
		}
		System.out.println("HelloWorld!");
		}	
	}