java基础语法(上)

关键字、标识符、注释、常量、进制、转换、数据类型
1:关键字(掌握)
(1)被Java语言赋予特定含义的单词

     (2)特点：

              组成关键字的字母全部小写。

     (3)注意事项：

              A:goto和const作为保留字存在。

              B:类似于EditPlus这样的高级记事本,针对关键字有特殊颜色标记

2:标识符(掌握)
(1)标识符概述

就是给类，接口，方法，变量等起名字的字符序列

     (2)组成规则：

              A:英文大小写字母

              B:数字

              C:$和_

     (3)注意事项：

              A:不能以数字开头

              B:不能是java中的关键字

              C:java语言严格区分大小写

     (4)常见的命名规则(见名知意-看见名字知道意思)

              A:包 其实就是文件夹，用于把相同的类名进行区分.(因为我们在同一个路径下不可能去建立2个一模一样的类名)

全部小写(单级包、多级包)

                      单级包：小写

                               举例：liuyi,com

                      多级包：小写，并用.隔开

                               举例：cn.itcast,com.baidu                            

              B:类或者接口

                      一个单词：首字母大写

                               举例：Student,Demo

                      多个单词：每个单词首字母大写

                               举例：HelloWorld,StudentName

              C:方法或者变量

                      一个单词：首字母小写

                               举例：name,main

                      多个单词：从第二个单词开始，每个单词首字母大写

                               举例：studentAge,showAllNames()

              D:常量

                      全部大写

                      一个单词：大写

                               举例：PI

                      多个单词：每个首字母都大写，并用_隔开

                               举例：STUDENT_MAX_AGE

3:注释(掌握)
(1)用于解释说明程序的文字，注释至少占代码的三分之一

     (2)Java中注释分类格式：

              A:单行注释     //注释文字

              B:多行注释     /*注释文字*/

                      注意：多行注释不可以嵌套使用，单行注释却可以。

              C:文档注释(后面讲) /** 注释文字*/

                      被javadoc工具解析生成一个说明书，面向对象部分讲解。

     (3)把HelloWorld案例加入注释写出来。

              后面我们要写一个程序的过程。

              需求：我准备写一个java程序,把"HelloWorld"这句话输出在控制台



              分析:

                       A:要写一个java程序,必须定义类.

                       B:我们把数据能够输出，说明我们的程序是可以独立运行的，而程序要独立运行，必须要定义main方法.

                      C:要想把数据输出在控制台,必须使用输出语句

    

           实现:

                       A:java语言提供了一个关键字:class用来定义类,后面跟的是类名.

                       B:main方法的格式是固定的：public static void main(String[] args)

C:输出语句的格式是固定的;

                      System.out.println("HelloWorld");

                      "HelloWorld"这个内容是可以改变的

代码体现：

//这是我的HelloWorld案例

class HelloWorld {

     /*

              为了程序能够独立运行,定义main方法

              main方法是程序的入口

              被jvm自动调用

     */

     public static void main(String[] args){

              //为了把数据显示在控制台,我们就使用了输出语句

              System.out.println("HelloWorld");

     }

}

     (4)注释的作用

              A:解释说明程序，提高了代码的阅读性。

              B:可以帮助我们调试程序。

                      后面我们会讲解一个更高端的一个调试工具

注释是一个程序员必须要具有的良好编程习惯。初学者编写程序可以养成习惯：先写注释再写代码。将自己的思想通过注释先整理出来，再用代码去体现。

因为代码仅仅是思想的一种体现形式而已。

4:常量(掌握)
(1)在程序执行的过程中，其值不可以发生改变的量

     (2)Java中常量分类：

              A:字面值常量

              B:自定义常量(final)，例如final int x = 10;

     (3)字面值常量

              A:字符串常量,用双引号括起来的内容.例如: "HelloWorld"

              B:整数常量,所有整数.例如:         12,23

              C:小数常量,所有小数,例如:         12.345

              D:字符常量,用单括号括起来的内容.例如:        'a','A','0'

              E:布尔常量,较为特有,只有  true,false

              F:空常量,null(后面讲)

     (4)在Java中针对整数常量提供了四种表现形式

              A:二进制 由0，1组成。以0b开头。

              B:八进制 由0，1，...7组成。以0开头。

              C:十进制 由0，1，...9组成。整数默认是十进制。

              D:十六进制    由0，1，...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。

5:进制转换(了解)
Java针对整数常量提供了4种表现形式——二进制、八进制、十进制、十六进制

(1)进制概述（什么是进制）

进制：就是进位制，是人们规定的一种进位方法。 对于任何一种进制——X进制，就表示某一位置上的数运算时是逢X进一位。二进制就是逢二进一，八进制是逢八进一，十进制是逢十进一，十六进制是逢十六进一。

       例如一周有七天,七进制；一年有十二个月,十二进制

A:十进制的由来

       十进制的由来是因为人类有十个手指

B:二进制的由来

       其实二进制来源于中国,请看史料记载

       18世纪德国数理哲学大师莱布尼兹从他的传教士朋友鲍威特寄给他的拉丁文译本《易经》中，读到了八卦的组成结构，惊奇地发现其基本素数（0）（1），即《易经》的阴爻 - -和阳爻—，其进位制就是二进制，并认为这是世界上数学进制中最先进的。20世纪被称作第三次科技革命的重要标志之一的计算机的发明与应用，其运算模式正是二进制。它不但证明了莱布尼兹的原理是正确的，同时也证明了《易经》数理学是很了不起的。

     任何数据在计算机中都是以二进制的形式存在的。二进制早期由电信号开关演变而来。

计算机的电子元件的状态：开和关。那么，我们表达数据的时候，也是通过数字1和0分别表示开和关的状态来表示的。由这样的1，0组成的数据就是二进制数据。

字节及其换算

如果我们表达的数据仅仅用者两种状态，那么能够表达的数据是比较少的。为了能够表达更多的数据（英文字母、数字、标点符号等），国际化标准组织就规定：用8个这样的

信号来表示一个数据，这个数据的单位叫：字节（byte）。

其中1byte = 8bit,1k = 1024 byte,1m = 1024k,1g = 1024m,1t = 1024g

引申:买的500g的硬盘没有500g这是为什么呢?出现容量差异的根本原因在于硬件厂家标称容量计数采用的是10进制.50010001000*1000/1024/1024/1024≈465g

C:八进制的由来

        二进制表达数据的表现形式过长，将二进制的数据,从右边开始,每三位用一位表示,最左边不够的时候,补0.这三位可以取到的最大值就是7.超过7就进位了，这就是八进制。

D:十六进制的由来

       但是对于过长的二进制变成八进制还是较长，所以出现的用4个二进制位表示一位的情况，四个二进制位最大是15，这就是十六进制。

E:不同进制表现同一个数据的形式特点

       进制越大，表现形式越短

(2) 不同进制的数据组成

二进制 ——由0,1组成。以0b或者0B开头

八进制 ——由0,1,…7组成。以0开头

十进制 ——由0,1,…9组成。整数默认是十进制的

十六进制 ——由0,1,…9,a,b,c,d,e,f(大小写均可)。以0x或者0X开头

(3)进制转换-其他进制到十进制

系数：就是每一个位上的数值

基数：x进制的基数就是x

权：针对每一个位上的数据，从右，并且从0开始编号，对应的编号就是该数据的权。

例如12345 =10000 + 2000+ 300 + 40 + 5

              =1*10^4 + 2*10^3 + 3*10^2 + 4*10^1 + 5*10^0

                    =10000 + 2000+ 300 + 40 + 5

                   =12345

结果：系数*基数^权次幂之和。

(4)进制转换-十进制到其他进制

              除基取余，直到商为0，余数反转。

12345(10)→12345(10)

60(10)→111100(2)

60(10)→74(8)

60(10)→3C(12)

(5)进制转换的快速转换法

A:十进制和二进制的快速转换

8421码,8421码是中国大陆的叫法，8421码是BCD代码中最常用的一种。

它表达的意思是每一个二进制位上的数据都是代表一个固定数值，

只需要把对应的1位置的十进制数值加起来，得到的结果就是它所代表的十进制数码。

说明:(1)1010100,这里从右往左,从0开始编号,编号第2位的1,第4位的1,第6位的1,分别对应的是4,16,64,那么1010100 = 64 + 16 + 4 = 84.

(2)100,不足128,于是100-64=36,36-32=4,4-4=0,因此得出组成整数100的3个2的次方数因子分别是64、32、4，100 = 64 + 32 + 4→01100100(2)

8421码要将2的次方数记得比较清楚,才方便二进制和十进制之间的快速转换.

B:二进制到八进制，十六进制的转换

(1) 二进制到十进制,十进制到八或者十六进制(以十进制为桥梁)

(2) 拆分组合法

6.有符号数据表示法
在计算机内，有符号数有3种表示法：原码、反码和补码。所有数据的运算都是采用数据对应的二进制的补码来进行的。

原码

就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。

反码

正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。

补码

正数的补码与其原码相同；负数的补码是在其反码的末位加1。

7.变量(掌握)
变量概述

在程序执行的过程中，其值是可以在一定范围内发生改变的量

理解：如同数学中的未知数

变量的组成规则:

     A:必须对其进行限定.

                      如何限定呢?用数据类型(java是强类型语言)

     B:我们在运算的时候,不可能是拿着这个空间去运算,我们真正运算时使用的是该空间中的值,我们就给该空间起了一个名字——变量名。

     C：即使你有数据类型了，你有变量名了，但是如果没有值，这个空间是一个垃圾空间，没有任何意义，需要初始化值。

变量定义格式

A:数据类型 变量名 = 初始化值;

B:数据类型 变量名;

     变量名 = 初始化值;

注意：格式是固定的，记住格式，以不变应万变

使用变量的时候,要注意的问题:

A:作用域

         变量定义在那个大括号内,它就在这个大括号内有效.

         并且在同一个大括号内,不能同时定义同名的变量.

B:初始化值

         没有初始化值的变量,不能直接使用.

         你只要在使用前给值就行,不一定非要在定义的时候立即给值.

         推荐在定义的时候就给值,这样不容易忘记

        

         回顾 定义变量的格式:

                  a.数据类型 变量名;

                  b.数据类型 变量名;

                    变量名 = 初始化值;

C:在一行上建议只定义一个变量

         可以定义多个,但是不建议.

8数据类型(掌握)
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间.

(1)Java是一种强类型语言，针对每种数据都提供了对应的数据类型。

(2)分类：

     A:基本数据类型：4类8种

     B:引用数据类型：类，接口，数组(后面讲)。

(3)基本数据类型

     A:整数              占用字节数

       byte                       1

       short            2

       int                         4

       long                       8

     B:浮点数

       float                      4

       double                  8

     C:字符

       char                       2

     D:布尔

       boolean                1

                     

     注意：

              整数默认是int类型，浮点数默认是double。

              长整数要加L或者l。建议使用L

              单精度的浮点数要加F或者f。建议使用F

9. 数据类型的转换:
   (1)boolean类型不参与转换

(2)默认转换

A: 从小到大的转换

B:byte,short,char-int-long-float-double

C:byte,short,char相互之间不转换,他们参与运算首先转换为int类型

例如:

byte a = 3;

int b = 4;

byte c = a + b;//有问题

int d = a + b;//没有问题

(3)强制转换

A:从大的数据类型,到小的数据类型

B:可能会有精度的损失,一般不建议这样使用.

C:格式:

  目标数据类型 变量 = (目标数据类型) (被转换的数据);

例如:

byte a = 3;

           int b = 4;

      byte c = (byte)(a + b);    //用强制类型转换改进

(4)思考题和面试题

A:下面两种方式有区别吗?

           float f1 = (float)12.345;// f1其实是通过一个double类型转换过来的。

           float f2 = 12.345f;// 而f2本身就是一个float类型

B: 下面的程序有问题吗，如果有，在哪里呢?

           byte b1=3,b2=4,b;

           b=b1+b2; //error,这个是类型提升,所以会有问题

           b=3+4; //常量,先把结果计算出来,然后看是否在byte的范围内,如果在就不报错

           哪句是编译失败的呢？为什么呢？



           b = b1 + b2;是有问题的。

           因为变量相加，会首先看类型问题，最终把结果赋值的也会考虑类型问题。

           常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错。

C:下面的操作结果是什么呢?

                   byte b = (byte)130;

System.out.println(b);//-126

我们要想知道结果是什么，就应该知道是如何进行计算的。

           而我们又知道计算机中数据的运算都是补码进行的。

           而要得到补码，首先要计算出数据的二进制。

          

           A:获取130这个数据的二进制。

                    00000000 00000000 00000000 10000010

                   这是130的原码，也是反码，还是补码。

           B:做截取操作，截成byte类型的了。

                   10000010

                   这个结果是补码。

           C:已知补码求原码。

                                     符号位             数值位

                   补码：    1                        0000010

                  

                   反码：    1                        0000001

                  

                   原码：    1                        1111110

D:字符参与运算

           是查找ASCII里面的值

                   'a'             97

                   'A'             65

                   '0'             48

                  

           System.out.println('a');//a

           System.out.println('a' + 1);//98

E:字符串参与运算

           这里其实是字符串的连接

           字符串数据和其他数据做+，结果是字符串类型。

           这里的+不是加法运算，而是字符串连接符。

           System.out.println("hello"+'a'+1); //helloa1

           System.out.println('a'+1+"hello"); //98hello

           System.out.println("5+5="+5+5); //5+5=55

           System.out.println(5+5+"=5+5"); //10=5+5

10:运算符(掌握)
(1)算术运算符

              A:+,-,*,/,%,++,--

              B:+的用法

                      a:加法

                      b:正号

                      c:字符串连接符

              C:/和%的区别

                      数据做除法操作的时候，/取得是商，%取得是余数

              D:++和--的用法

                      a:他们的作用是自增或者自减

                      b:使用

                               **单独使用

                                        放在操作数据的前面和后面效果一样。

                                        a++或者++a效果一样。

                               **参与操作使用

                                        放在操作数的前面：先自增或者自减，再参与操作

                                                 int a = 10;

                                                 int b = ++a;

                                        放在操作数的后面：先参与操作，再自增或者自减

                                                 int a = 10;

                                                 int b = a++;

(2)赋值运算符

              A:=,+=,-=,*=,/=,%=等

              B:=叫做赋值运算符，也是最基本的赋值运算符

                      int x = 10; 把10赋值给int类型的变量x。

              C:扩展的赋值运算符的特点

                      隐含了自动强制转换。

                     

                      面试题：

                               short s = 1, s = s + 1;

              short s = 1,s += 1;

              上面两个代码有没有问题,如果有,哪里有问题



              为什么第2个没有问题呢?

              扩展的赋值运算符其实隐含了一个强制类型转换.



              s += 1;

              不是等价于 s = s + 1;

              而不是等价于 s = (s的数据类型)(s+1);     

(3)比较运算符

              A:==,!=,>,>=,<,<=

              B:无论运算符两端简单还是复杂最终结果是boolean类型。

              C:千万不要把==写成了=

     (4)逻辑运算符

              A:&,|,^,!,&&,||

              B:逻辑运算符用于连接boolean类型的式子

              C:结论

&逻辑与:有false则false

              |逻辑或:有true则true

              ^逻辑异或:相同为false,不同为true

                      举例:情侣关系.男男,男女,女男,女女

              !逻辑非:非false则true,非true则false.

                      特点:偶数个不改变本身.























                      &:有false则false

                      |:有true则true

                      ^:相同则false，不同则true。

                               情侣关系。

                      !:非true则false，非false则true

                     

                      &&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。

                      ||:结果和|是一样的，只不过有短路效果。左边是true，右边不执行。

     (5)位运算符(了解)

              A:^的特殊用法

                      一个数据针对另一个数据位异或两次，该数不变



              int a = 10;

              int b = 20;



              System.out.println(a ^ b ^ b);//10

              System.out.println(a ^ b ^ a);//20



              B:面试题

                      a:请实现两个变量的交换

                               **采用第三方变量

                               **用位异或运算符

                                        左边a,b,a

                                        右边a^b

                      b:请用最有效率的方式计算出2乘以8的结果

                               2<<3

System.out.println(3 & 4);//0

              System.out.println(3 | 4);//7

              System.out.println(3 ^ 4);//7

              System.out.println(~3);//-4

分析：因为是位运算，所以我们必须先把数据换算成二进制。

     3的二进制：11

              00000000 00000000 00000000 00000011

     4的二进制：100

              00000000 00000000 00000000 00000100

    

     &位与运算：有0则0。

              00000000 00000000 00000000 00000011

        &00000000 00000000 00000000 00000100

              -----------------------------------

              00000000 00000000 00000000 00000000

              结果是：0

             

     |位或运算：有1则1。

              00000000 00000000 00000000 00000011

        |00000000 00000000 00000000 00000100

              -----------------------------------

              00000000 00000000 00000000 00000111

              结果是：7

             

     ^位异或运算：相同则0，不同则1。

              00000000 00000000 00000000 00000011

        &00000000 00000000 00000000 00000100

              -----------------------------------

              00000000 00000000 00000000 00000111

              结果是：7

             

     ~按位取反运算符：0变1，1变0

              00000000 00000000 00000000 00000011

        ~11111111 11111111 11111111 11111100 (补码)

       

        补码：11111111 11111111 11111111 11111100

        反码：11111111 11111111 11111111 11111011

        原码：10000000 00000000 00000000 00000100

              结果是：-4

(6)三元运算符

              A:格式

                      比较表达式?表达式1:表达式2;

              B:执行流程：

                      首先计算比较表达式的值，看是true还是false。

                      如果是true，表达式1就是结果。

                      如果是false，表达式2就是结果。

              C:案例：

                      a:比较两个数据是否相等

                       

                      int m = 100;

                     int n = 200;

                               boolean flag = (m == n);

                      System.out.println(flag);

//不要画蛇添足

boolean flag = (m == n)? true: false;

                      b:获取两个数据中的最大值

                      int x = 100;

                      int y = 200;



                      int max = (x > y? x:y);

                      System.out.println("max:"+max);

             

                      c:获取三个数据中的最大值

                       

              int a = 10;

              int b = 30;

              int c = 20;



               方法1:分2步--代码要简单,清晰

               //A.先比较a,b的最大值

              //B.拿a,b的最大值再和c进行比较

              int temp = ((a > b)? a: b);

               

              int max1 = (temp > c? temp: c);

              System.out.println("max1:"+max1);



               方法2:一步搞定

               

              int max2 = (a > b)?((a > c)? a: c):((b > c)?b: c);// //int max2 = (a > b)?():();嵌套

              System.out.println("max2:"+max2);

11:键盘录入(掌握)
(1)实际开发中，数据是变化的，为了提高程序的灵活性，我们加入键盘录入数据。

     (2)如何实现呢?目前就记住

              A:导包

                      import java.util.Scanner;

                      位置：放在class定义的上边

              B:创建对象

                      Scanner sc = new Scanner(System.in);

              C:获取数据

                      int x = sc.nextInt();

     (3)把三元运算符的案例加入键盘录入改进。

12:流程控制语句
在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。

(1)顺序结构 从上往下，依次执行

(2)选择结构 按照不同的选择，执行不同的代码

              执行具体的逻辑运算进行判断,逻辑运算的结果有2个,所以产生选择,按照

     不同的选择执行不同的代码.     

Java提供了2种选择结构语句,if语句和switch语句

(3)循环结构 做一些重复的代码

13:if语句(掌握)
(1)三种格式

              A:格式1

                      if(比较表达式) {

                               语句体;

                      }

                     

                      执行流程：

                               先计算比较表达式的值，看其返回值是true还是false

                               如果是true，就执行语句体

                               如果是false，就不执行语句体

             

              B:格式2

                      if(比较表达式) {

                               语句体1;

                      }else {

                               语句体2;

                      }

                     

                      执行流程：

                               判断比较表达式的值，看是true还是false

                               如果是true，就执行语句体1

                               如果是false，就执行语句体2

                              

              C:格式3

                      if(比较表达式1) {

                               语句体1;

                      }else if(比较表达式2){

                               语句体2;

                      }

                      ...

                      else {

                               语句体n+1;

                      }

                     

                      执行流程：

                               判断比较表达式1的值，看是true还是false

                               如果是true，就执行语句体1

                               如果是false，就继续判断比较表达式2的值，看是true还是false

                               如果是true，就执行语句体2

                               如果是false，就继续判断比较表达式3的值，看是true还是false

                               ...

                               如果都不满足，就执行语句体n+1

     (2)注意事项

              A:比较表达式无论简单还是复杂，结果是boolean类型

              B:if语句控制的语句体如果是一条语句，是可以省略大括号的；如果是多条，不能省略。

                      建议：永远不要省略。

              C:一般来说，有左大括号，就没有分号，有分号，就没有左大括号。

              D:else后面如果没有if，是不会出现比较表达式的。

              E:三种if语句其实都是一个语句，只要有一个执行，其他的就不再执行。

      

     (3)三元运算符和if语句第二种格式的关系

              所有的三元运算符能够实现的，if语句的第二种格式都能实现。

              反之不成立。

             

              如果if语句第二种格式控制的语句体是输出语句，就不可以。

              因为三元运算符是一个运算符，必须要有一个结果返回，不能是一个输出语句。

14:switch语句(掌握)
(1)格式：

              switch(表达式) {

                      case 值1:

                               语句体1;

                               break;

                      case 值2:

                               语句体2;

                               break;

                      ...

                      default:

                               语句体n+1;

                               break;

              }

             

              格式解释说明：

                      switch:说明这是switch语句。

                      表达式:这个地方的取值是有限定的,可以是byte,short,int,char

                               JDK5以后可以是枚举

                               JDK7以后可以是字符串

                      case:后面跟的是要和表达式进行比较的值

                      语句体:要执行的代码

                      break:表示程序到这里中断，跳出switch语句

                      default:如果所有的情况都不匹配,就执行这里,相当于if语句中的else

     (2)面试题

              switch语句的表达式可以是byte吗?可以是long吗?可以是String吗?

                      可以,不可以,JDK7以后可以

     (3)执行流程:

              A:首先计算表达式的值

              B:和每一个case进行匹配，一旦有对应的值,就执行对应的语句体，看到break就结束。

              C:如果没有匹配，就执行default的语句体n+1。

     (4)注意事项:

              A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的

              B:default可以省略吗?

                      可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。

                      特殊情况：

                               case就可以把值固定。

                               A,B,C,D

              C:break可以省略吗?

                      可以省略，但是结果可能不是我们想要的。

                      会出现一个现象：case穿透。

                      最终我们建议不要省略

              D:default一定要在最后吗?

                      不是，可以在任意位置。但是建议在最后。

              E:switch语句的结束条件

                      a:遇到break就结束了

                      b:执行到末尾就结束了

     (5)案例：

              A:键盘录入一个数字(1-7),输出对应的星期几。

              B:单项选择题

              C:键盘录入一个字符串的问题

                      String s = sc.nextLine();

              D:根据给定的月份,输出对应的季节

     (6)if语句和switch语句各自的场景

              A:if

                      针对boolean类型的判断,switch是不行的(byte,short,int,char)

                      针对一个范围的判断

                      针对几个常量的判断

              B:switch

                      针对几个常量的判断

15:循环语句(掌握)
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

     (1)有三种:for,while,do...while

     (2)for循环语句

              A:格式

                      for(初始化语句;判断条件语句;控制条件语句){

                               循环体语句;

                      }

循环语句的组成

初始化语句：

一条或者多条语句，这些语句完成一些初始化操作。

判断条件语句：

这是一个boolean 表达式，这个表达式能决定是否执行循环体。

循环体语句：

这个部分是循环体语句，也就是我们要多次做的事情。

控制条件语句：

这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束。

                      执行流程：

                               a:执行初始化语句

                               b:执行判断条件语句

                                        如果这里是true，就继续

                                        如果这里是false，循环就结束

                               c:执行循环体语句

                               d:执行控制条件语句

                               e:回到b

              B:注意事项

                      a:判断条件语句无论简单还是复杂，结果是boolean类型

                      b:循环体语句如果是一条，可以省略大括号，但是不建议

                      c:有分号就没有左大括号，有左大括号就没有分号

               

     (3)while循环

              A:基本格式

                      while(判断条件语句) {

                               循环体语句;

                      }

                     

                      扩展格式：

                      初始化语句;

                      while(判断条件语句){

                               循环体语句;

                               控制条件语句;

                      }

                      通过这个格式，我们就可以看到其实和for循环是差不多的, while循环可以和for循环等价转换。

             

              for(初始化语句;判断条件语句;控制条件语句) {

                      循环体语句;

              }

                       

              B:while的练习

                      把for语句的练习用while改进

              C:for和while的区别





              使用区别：如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用for循环。

                        因为变量及早的从内存中消失，可以提高内存的使用效率。

                                

              其实还有一种场景的理解:

                      如果是一个范围的，用for循环非常明确(范围判断)。

                      如果是不明确要做多少次，用while循环较为合适(次数不明确)。

                                

                       

               

     (4)do...while循环

              A:基本格式

                      do {

                               循环体语句;

                      }while(判断条件语句);

                     

                      扩展格式：

                      初始化语句;

                       do {

                               循环体语句;

                               控制条件语句;

                      }while(判断条件语句);

                     

                      通过查看格式，我们就可以看出其实三种循环的格式可以是统一的。

              B:三种循环的区别

                      a:do...while循环至少执行一次循环体

                      b:for和while循环必须先判断条件是否是true，然后才能决定是否执行循环体语句

那么,我们一般使用哪种循环呢?

优先考虑for,其次考虑while,最后考虑do…while

     (5)循环使用的注意事项(死循环)

              A:一定要注意修改控制条件,否则容易出现死循环。

              B:最简单的死循环格式

                      a:while(true){...}

                     

                      b:for(;;){}

16:控制跳转语句(掌握)
(1)break:中断的意思

              A:用在循环和switch语句中，离开上面2个应用场景无意义。

              B:作用

                      a:跳出单层循环



               1)for (int x=0;x<10 ;x++ ) {

                       if (x == 2) {

                                break;

                       }

                       System.out.println("HelloWorld");

               }

//结果是只打印2个HelloWorld

2. for (int x=0;x<3 ;x++ ) {

                       for (int y=0;y<4 ;y++ ) {
   
                                if(y == 2){
   
                                        break;
   
                                }
   
                                System.out.print("*");
   
                       }
   
                       System.out.println();
   
               }
   

// 原本是打印3行4列的星星,变成打印3行2列的星星.

                      b:跳出多层循环，需要标签语句的配合(使用的比较少)

带标签的语句,格式：

                               标签名: 语句

wc:for(int x=0; x<3; x++) {

                      nc:for(int y=0; y<4; y++) {

                               if(y == 2) {

                                        break wc;

                               }

                               System.out.print("*");

                      }

                      System.out.println();

              }//仅仅打印一行的2颗星

     (2)continue:继续

              A:用在循环语句中，离开此应用场景无意义。

              B:作用

                      a:跳出单层循环的一次，可以继续下一次

              C: 一个代码说明continue和break的区别

                      for(int x = 0;x<6;x++){

                      if(x == 3){

                               break;

                      }

                      System.out.println(x);//打印0,1,2

             

                      for(int x = 0;x<6;x++){

                      if(x == 3){

                               continue;

                      }

                      System.out.println(x);//打印出0,1,2,4,5

               

               

     (3)return:返回

              A:用于结束方法的，后面还会在继续讲解和使用。

              B:一旦遇到return,程序就不会再继续往后执行。