史上最强java基本语法讲解|附练习题（超详细版本
下一篇持续更新中…（如有错误 ,欢迎指正！！）
书接上回，在上一篇我讲解了第一个java程序HelloWorld的编译、运行和在这个过程中你可能会遇到的问题。希望通过昨天的学习，你已经能够独立完成：
- 搭建Java的开发环境
- 理解Java的加载与执行
- 编写HelloWorld程序，编译并运行
- 掌握环境变量path的原理以及如何配置
今天这一篇我将为你讲解，如何配置环境变量classpath以及它的作用原理、对HelloWorld程序进行初步解释以及java语言基础语法。（知识点超详细，附有练习题，回顾个别知识点的同学可以直接通过目录跳转，废话不多说，长篇预警！！！！！）
文章目录
- 续上一篇
- 1. 配置环境变量classpath
- 2. java源程序的注释
- 3. 对HelloWorld源程序初步解释
- 4. public class和class的区别：
- 本篇：java基础语法
- 1. 标识符
- 2. 关键字
- 3. 字面值
- 4. 数据类型
- 1.a. 基本数据类型【四大类八小种】：
- 2. 八种基本数据类型各自占用空间大小：
- A.二进制
- B.字节（byte）：
- 3. 八种数据类型的取值范围:
- A.关于Java中的数字类型
- B. 字符编码
- C. 八种数据类型的取值范围:
- 4. 八种数据类型的默认值
- 1.b. 引用数据类型【后边讲】
- 1.a.1. char 类型（转义字符：\）
- 1.a.2. 整数型
- 1.a.3. 浮点型
- 1.a.4.布尔型Boolean
- 5. 基本数据类型之间的互相转换规则
- 5. 变量
- A. 变量的基本概念
- B. 变量的作用域
- C. 变量的分类
- 6. 运算符
- 算术运算符
- 关系运算符
- 逻辑运算符
- 赋值类运算符
- 字符串连接运算符 “ + ”
- 三元运算符
- 7. 控制语句
- 1. 选择结构
- A. if / if..else
- 练习题1 ：
- 练习题2 ：
- 练习题3 ：
- B. switch
- 多敲练习
- 练习题 1 ：
- 练习题 2 ：
- 2. 循环结构
- A.for
- 1. i 变量的作用域
- 小练习：
- 2. 循环语句和条件语句嵌套使用（附例）
- 练习题 1 ：
- 3. for循环嵌套for循环
- 练习题1、2 ：
- 练习题 3：
- B.while
- 练习题 1：
- C.do..while
- 3. 控制循环语句
- A. break
- B. continue
续上一篇
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编辑器当中以黑色字体高亮显示
-
标志符的命名规则
【不按照这个规则来，编译器会报错，这是语法】- 一个合法的标识符只能由“数字、字母、下划线_、美元符号$”组成，不能含有其他符号
- 不能数字开头
- 严格区分大小写
- 关键字不能做标识符
- 理论上无长度限制,但是最好不要太长
-
标识符的命名规范？
【只是一种规范，不属于语法，不遵守规范编译器不会报错】- 见名知意
- 驼峰命名方式
- 大驼峰法【首字母大写，后面每个单词首字母大写】–>类名、接口名、文件名
- 小驼峰法【首字母小写，后面每个单词首字母大写】–>变量名、方法名
- 全部大写：常量名
- 全部小写：包名
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 1short 2 int 4 long 8float 4double 8 boolean 1char 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/01 KB = 1024 byte1 MB = 1024 KB1 GB = 1024 MB1 TB = 1024 GB1TB = 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* 支持繁体中文：大五码* 后来出现了一种编码方式统一了全球所有的文字，容量较大，这种编码方式叫做：**unicode编码**unicode编码方式有多种具体的实现：-UTF-8-UTF-16-UTF-32......
Java语言源代码采用的是Unicode编码方式，所以“标识符”可以用中文。现在在实际开发中，一般使用UTF-8编码方式比较多。【统一编码方式】
C. 八种数据类型的取值范围:
类型 取值范围--------------------------------byte [-128~127]short [-32768~32767]int [-2147483648~2147483647]longfloatdoubleboolean [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 0float,double 0.0boolean 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);//制表符tabchar 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编码是4e2dSystem.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);//10System.out.println(b);//8System.out.println(c);//16System.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.0dd = 10.0/3;
System.out.println(dd);//3.33333333335long 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; //setSystem.out.println(i); //get
- 变量先声明然后赋值再访问
在方法体中的java代码，是遵守自上而下的顺序依次逐行执行。
第一行;
第二行;
第三行;
* 特点：第二行的代码必须完整的结束之后，第三行程序才能执行。
public class VariableTest01
{public static void main(String[] args){//声明一个int类型的变量，起名iint i;//编译报错：变量i并没有初始化//System.out.println(i);//给i变量赋值，i变量在这里完成初始化，内存开辟i = 100;System.out.println(i);//i再次重新赋值i = 200;System.out.println(i);//一行上可以同时声明多个变量//a和b尚未初始化，c赋值300int 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);//13System.out.println(i - j);//7System.out.println(i * j);//30System.out.println(i / j);//3System.out.println(i % j);//1//以下以++为例，--运算符自学！//关于++运算符【自加1】int k = 10;//运算符可以出现在变量后面【单目运算符】k ++；System.out.println(k);//11int y = 10;//++运算符可以出现在变量前面【单目运算符】++ y;System.out.println(y);//11//小结：//++运算符可以先出现在变量前，也可以出现在变量后，无论是变量前还是变量后//只要++运算结束，该变量中的值一定会自加1//++出现在变量后//规则：先做赋值运算，再对变量中保存的值进行自加1int a = 100;int b = a ++;System.out.println(a);//101System.out.println(b);//100//++出现在变量前int m = 20;int n = ++ m;System.out.println(m);//21System.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);//trueSystem.out.println(5 > 3 & 5 > 6);//falseSystem.out.println(5 > 3 | 5 > 6);//trueSystem.out.println(true & false);//falseSystem.out.println(true & true);//trueSystem.out.println(false & false);//falseSystem.out.println(true | false);//trueSystem.out.println(false | false);//falseSystem.out.println(!false);//trueSystem.out.println(!true);//falseSystem.out.println(true ^ false);//trueSystem.out.println(false ^ false);//falseSystem.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);//10i = i + 5;System.out.println(i);//15//扩展的赋值运算符【+=运算符可以翻译为“追加、累加”】i += 5;//等同于i = i + 5;System.out.println(i);//20i -= 5;//等同于i = i - 5;System.out.println(i);//15i *= 2;//等同于i = i * 2;System.out.println(i);//30i /= 4;//等同于i = i /4;System.out.println(i);//7i %= 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);//15byte x = 10;x += 5;//等同于：x = (byte)(x + 5);其实并不等同于x = x + 5;System.out.println(x);//15byte 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"));//102030int 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("呵呵");}elseSystem.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) E4、以上需求必须采用switch语句完成，不能采用if。窍门：(int)(成绩 / 10)012345678910
*/
public class SwitchTest05
{public static void main(String[] args){//考生成绩double score = 85.5;//转换intint 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-10System.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 9i++;}}
}
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..whileif (){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");}/*Begin0OverBegin0OverBegin0OverBegin0OverBegin0OverBegin0OverBegin0OverBegin0OverBegin0OverBegin0Over*/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=12*1=1 2*2=43*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);//0System.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 10i++;}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循环起名for1for1:for(int j = 0 ;j < 3;j++){//给for循环起名for2for2: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!");} }
本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！