Java系列（二）__Java基本概念
任何程序的开始都是通过“Hello World”输出开始的。
范例：定义Hello.java程序
| public class Hello { public static void main(String args[]) { System.out.println("Hello World .") ; } } |
当程序编写完成之后，下面就可以采用如下的方式进行操作（基于命令行方式）：
· 编译程序：javac Hello.java，执行之后一个Hello.class的字节码文件，也是真正要执行的程序；
· 解释程序：java Hello，解释程序，在JVM上进行解释。
2.1、第一个程序的相关解释（重点）
第一个程序虽然简单，但是却包含了所有Java的核心运行过程，针对于每一步进行解释。
1、 定义类的部分：
| public class Hello { 类之中的代码； } |
类是在明天开始才要解释的概念，那么在Java之中所有的程序都要求以类为单元进行编写，对于类的定义有两种：
· public class 类名称：文件名称要与类名称保持一致，但是一般而言，在一个*.java文件里面只能够有一个public class定义；
· class 类名称：文件名称可以与类名称不同，但是生成的*.class名称是定义的类名称，在一个*.java文件里面可以同时使用class定义多个类，编译之后每一个类会自动生成各自的*.class文件；
在日后进行类名称定义的时候，有一个自己的命名规范：每一个单词的首字母必须大写，例如：HelloJavaDemo。
2、 主方法
主方法表示的是程序的起点，任何的程序都是由主方法开始执行的，在Java中的主方法组成比较长：
| public static void main(String args[]) { 编写代码，今天的代码都在此处编写； } |
一般主方法都习惯于将其放在使用public class定义的类之中，所以主方法所在的public class类，日后称为主类。
3、 系统输出
系统输出指的是将提示信息输出到标准输出设备 —— 显示器上，对于系统输出有两种方式：
| 输出之后增加换行： | System.out.println("内容") ; |
| 输出之后不增加换行： | System.out.print("内容") ; |
把以上的基本程序弄熟练了，基本上今天的Java程序的结构也就都固定了。
2.2、CLASSPATH初步分析（重点）
通过单词的含义就可以清楚的知道，CLASSPATH指的是类的保存路径。例如，现在在D:\testjava目录下存在有一个“Hello.class”文件存在，那么此时命令行所在的路径也是“d:\testjava”，所以可以直接使用“java Hello”这个类。但是如果说此时命令行的所在路径为“e:”，在e盘下并没有存在Hello.class文件。那么一旦执行了“java Hello”命令会出现如下的错误提示信息：
| 错误: 找不到或无法加载主类 Hello |
| Error：NotFoundClassError : Hello |
那么现在就希望即使所在的路径在e盘上，也可以加载到d:\testjava目录下的Hello.class文件，则可以通过设置CLASSPATH完成。
范例：设置CLASSPATH
| SET CLASSPATH=d:\testjava |
设置完成之后，那么再次执行“java Hello”命令。那么发现可以找到Hello.class文件，所以可以得出一个结论：每当使用java命令解释一个类的时候，会自动的通过CLASSPATH所设置的路径加载所需要的类。
但是如果在实际的工作之中这样到处乱设置CLASSPATH并不方便，最好的做法是从当前所在的路径下去加载所需要的类文件。那么往往会将CLASSPATH设置为“.”，表示从当前所在路径加载。
范例：设置从当前所在路径加载类
默认情况下所有的CLASSPATH都是通过当前所在路径进行加载的，但是在一些软件配置的时候，有可能会自动的帮你去修改CLASSPATH路径，那么此时就必须手工设置，但是上面的手工设置只适合于当前的命令行方式。如果要想针对于所有的命令行窗口，则可以建立一个新的环境属性。
面试题：请解释PATH和CLASSPATH的区别？
· PATH：是操作系统的程序配置路径，通过此路径配置可执行程序；
· CLASSPATH：是Java程序解释时所使用的路径，用户执行java命令的时候会自动的根据CLASSPATH所设置的路径进行类的加载，一般都将其设置为“.”表示从当前所在路径进行类加载。
2.3、标识符与关键字、注释（重点）
在定义类、变量名称、方法名称的时候对于命名是有组成要求的，在Java里面任何的一个标识符可以由字母、数字、_、$符号所组成，其中不能以数字开头，不能是Java的关键字（保留字），像Hello、JavaDemo，都属于合法的标识符。但是在定义标识符的时候个人原则：建议都以字母开头，由字母和数字组成，少用“_”，坚决不用“$”。
在以上所给出的49个关键字之中，有两个关键字只是介绍不讲解：native、volatile。
在给出的关键字之中，有三个严格来讲不属于关键字，只属于特殊含义的单词，例如：null、true、false；
Java里面有两个不使用的关键字：goto、const
在JDK 1.4之后增加了一个assert关键字，将在异常处理中使用；
在JDK 1.5之后增加了一个enum关键字。
除此之外任何的语言都会存在有注释的概念，所谓的注释指的是程序在编译的时候不会编译的程序部分，在Java里面有三类注释：
· 单行注释：// 注释；
· 多行注释：；
· 文档注释：，此类注释最后再使用。
2.4、Java数据类型划分（重点）
程序的数据类型指的是允许操作的数据形式，例如数据库之中可以操作字符串、数字、日期时间，那么程序也是一样的。在Java之中数据类型一共分为两大类：
· 基本数据类型（只包含具体的数据，不牵扯到内存的关联）：
|- 数值型：
|- 整型：byte、short、int、long； 默认值：0
|- 实型（浮点型）：float、double； 默认值：0.0
|- 字符型：char； 默认值：'\u0000'
|- 布尔型：boolean； 默认值：false
· 引用数据类型（指的内存的关联数据，类似于指针的概念）：类、数组、接口。 默认值：null
虽然每种数据类型存在有默认值，但是这些默认的概念也只是在明天之后才使用的，今天的内容都无法使用。今天的重点以基本数据类型为主。
通过以上的数据的保存大小可以发现，按照由小到大的保存顺序：byte < short < int < long < float < double，double可以保存最大的数据，使用double可以保存全宇宙之中最有意义的最大的数字。以上给出的几个基本类型，有个人总结的几个核心用法：
· 表示整数永恒使用int、表示小数永恒使用double；
· 在进行数据传输和字符转码的过程之中都使用byte；
· 表示日期时间或者是文件大小的时候都使用long；
· 表示逻辑关系的时候往往都使用boolean。
2.4.1、整型数据（byte、short、int、long）
整型数据是最为常用的一个数据类型，其不能保存小数数据，在Java之中，默认的一个整数就是int型数据类型。
范例：定义整型变量
| public class TestDemo { public static void main(String args[]) { // 10是一个整数，既然是整数就是int数据类型 // 10也称为常量，而num是一个变量 int num = 10 ; // int 变量 = int型常量 num = 20 ; // num的内容被改变了 System.out.println(num) ; } } |
本程序之中首先将一个数字10（是一个int型常量）赋予int型的变量num，而后修改了num变量的内容。
| 提示：关于不同版本JDK的问题（解释之前所谓的默认值暂时无法使用的问题） 那么在JDK 1.5之后，针对于变量的声明与赋值这两个操作上已经发生了变化。 范例：正确代码
| public class TestDemo { public static void main(String args[]) { int num ; // 定义一个int型变量，定义的时候没设置数值 num = 10 ; // 为变量设置内容 System.out.println(num) ; } } |
范例：错误代码
| public class TestDemo { public static void main(String args[]) { int num ; // 定义一个int型变量，定义的时候没设置数值 System.out.println(num) ; } } |
变量在使用前一定要设置默认值（不要去依靠系统提供的默认值），但是如果在JDK 1.4及其之前版本的话，连最早正确的代码也是错的（第一行是定义变量、第二行是为变量赋值，这个是错误的），所以最保险的做法是是在声明变量的同时就设置好内容（int num = 10）； |
既然是数值型的变量，那么变量定义之后也是可以进行数学计算的。
范例：进行数学计算
| public class TestDemo { public static void main(String args[]) { int numA = 10 ; int numB = 20 ; int result = numA + numB ; // int + int = int System.out.println(result) ; } } |
每种数据类型都有其自己的最大值和最小值范围，那么如果说超过了这个范围呢？
范例：观察超过数据范围的情况
| public class TestDemo { public static void main(String args[]) { int max = Integer.MAX_VALUE ; // 取得int的最大值 int min = Integer.MIN_VALUE ; // 取得int的最小值 System.out.println(max) ; // 最大值：2147483647 System.out.println(min) ; // 最小值：-2147483648 // int型 + int型 = int型 System.out.println(max + 1) ; // 最大值 + 1 = -2147483648（最小值） System.out.println(max + 2) ; // 最大值 + 1 = -2147483647（次最小值） // int型 - int型 = int型 System.out.println(min - 1) ; // 最小值 - 1 = 2147483647（最大值） } } |
发现数据是一个循环过程，最大值如果继续进行加法计算则变为了最小值，最小值如果继续进行了减法计算，将变为最大值，这一概念属于数据的溢出。
面对数据的溢出问题，如果要想解决，那么唯一的途径就是扩大使用的数据范围，比int保存范围大的数据类型是long，那么如果要想将int变为long，有两种方式：
方式一：在数字前加上一个“(long)”
| long x = (long) 10 ; // int变为long |
方式二：是在数字后加上一个字母“L”
| long x = 10L ; // int变为long |
范例：利用long数据类型解决数据的溢出问题
| public class TestDemo { public static void main(String args[]) { int max = Integer.MAX_VALUE ; // 取得int的最大值 int min = Integer.MIN_VALUE ; // 取得int的最小值 System.out.println(max) ; // 最大值：2147483647 System.out.println(min) ; // 最小值：-2147483648 // int型（自动向上变为long） + long型 = long型 System.out.println(max + 1L) ; // 2147483648 System.out.println(max + (long) 2) ; // 2147483649 // int型（自动向上变为long） - long型 = long型 System.out.println(min - 1L) ; // -2147483649 } } |
那么通过这样一个程序就可以得出一个结论：当范围小的数据类型与范围大的数据类型一起进行数学计算的时候，范围小的数据类型会自动的变为范围大的数据类型，当类型统一之后再进行数学计算。byte è short è int è long。
而在整型数据之中还存在有一种byte的类型，这个长度只有“-128 ~ 127”之间。
范例：观察byte操作
| public class TestDemo { public static void main(String args[]) { int num = 129 ; byte b = (byte) num ; // 范围大的数据变为范围小的数据，需要强制转换 System.out.println(b) ; } } |
范围大的数据类型如果要变为范围小的数据类型，一定要使用强制转换，但是这之中就有可能出现数字的错乱。
但是在使用byte的时候一点很有意思，byte作了一些特殊处理。
范例：观察原始操作
| public class TestDemo { public static void main(String args[]) { int num = 10 ; byte b = (byte) num ; // int变为byte System.out.println(b) ; } } |
范例：观察特殊的支持
| public class TestDemo { public static void main(String args[]) { byte b = 10 ; // int变为byte System.out.println(b) ; } } |
任何一个整数在Java之中都是一个int类型的常量，现在是将int型变为byte型。因为10正好在byte的范围之中，而如果不在byte范围之中的整型常量，那么依然需要执行强制转型。
2.4.2、实型数据（float、double）
在程序之中默认的小数类型就是double，double是范围最大的数据类型。
范例：观察double的使用
| public class TestDemo { public static void main(String args[]) { double num = 10.2 ; // 小数为double类型 System.out.println(num) ; // double型 * int型（变为double型） = double型 System.out.println(num * 2) ; } } |
但是如果要使用的是float，一定需要注意，要执行强制类型转换，那么转换的形式也有两种：
· 形式一：(float) 变量；
· 形式二：在数字之后使用字母“F”表示。
范例：声明float变量
| public class TestDemo { public static void main(String args[]) { float num = 10.2f ; // float * int = float System.out.println(num * 2) ; } } |
建议使用小数还是以double为主，不要去采用float了。
提醒：一定要注意的是，整型数据都是不包含小数点位的，而float和double是会包含小数位
范例：观察程序的问题
| public class TestDemo { public static void main(String args[]) { int numA = 10 ; int numB = 3 ; System.out.println(numA / numB) ;// 3 } } | public class TestDemo { public static void main(String args[]) { int numA = 10 ; int numB = 3 ; System.out.println(numA / (double)numB) ; // 3.3333333333333335 } } |
从Java开始一直到今天，一直都有一个bug：
| public class TestDemo { public static void main(String args[]) { System.out.println(3 * 10.1) ; // 30.299999999999997 } } |
double可以保存的数据是最大的，所以所有的数据类型：byte è int è long è double的顺序进行自动类型转换。
2.4.3、字符型数据（char）
所谓的字符数据指的是使用“'”声明的一个字符信息，例如：'A'就表示一个字符。字符使用char进行表示，而且char和int之间是可以进行互相转换的。
范例：观察char与int的转换
| public class TestDemo { public static void main(String args[]) { char c = 'z' ; // 字符变量 int num = c ; // 将char变为int型 System.out.println(num) ; } } |
通过一系列的转换操作，可以发现，字母和数值之间的转换是有一定的数据联系的：
· 大写字母（A ~ Z）：65 ~ 90；
· 小写字母（a ~ z）：97 ~ 122，大写和小写字母之间差了32个长度；
· 数字字母（0 ~ 9）：48 ~ 57；
细心的同学可以发现，以上的字符编码过程和在C语言之中学习到的字符结果是相同的，但是Java和C所采用的编码方式并不相同，Java使用的是UNICODE编码，这是一种十六进制的编码方式。但是考虑到开发者的使用习惯，所以UNICODE吸收了C语言之中的ASC II码的部分编码规则，这样的好处是可以方便的进行编程习惯的对接。
范例：直接操作数字就可以实现字母的改变
| public class TestDemo { public static void main(String args[]) { char c = 'A' ; // 字符变量 int num = c ; // 将char变为int型 num = num + 32 ; // 65 + 32 = 97，num为97 System.out.println(num) ; System.out.println((char) num) ; } } |
强调：但是一定要记，'0'和数字0是两个概念。判断某一个字符是否是数字
| public class TestDemo { public static void main(String args[]) { char c = '6' ; // 字符变量 if (c >= 48 && c <= 57) { System.out.println("是一个数字！") ; } if (c >= '0' && c <= '9') { System.out.println("是一个数字！") ; } } } |
而且由于UNICODE编码的存在，所以Java中的char数据类型是可以保存中文的。
| public class TestDemo { public static void main(String args[]) { char c = '刁' ; // 字符变量 int num = c ; System.out.println(num) ; } } |
但是如果要想保存中文，必须是在中文的语言环境下。
2.4.4、布尔型数据（boolean）
布尔是一个数学家的名字，对于boolean数据类型只有两种选择：true、false。一般而言，布尔数据类型往往都作为一些程序的控制逻辑使用。
范例：程序逻辑
| public class TestDemo { public static void main(String args[]) { boolean flag = 1 < 2 ; if (flag) { // 需要接收的是布尔，flag == true System.out.println("条件满足！") ; } } } |
在一些其它语言之中（不支持布尔型数据的）可能会使用0表示false，1表示true，但是Java里面的布尔是绝对不可能使用数字来表示的。
2.4.5、字符串类型：String（初步认识）
在学习Oracle的时候可以发现存在有字符串数据，但是在Java之中是没有提供一种类型可以直接表示字符串的，而要想表示出字符串，则可以利用String类完成。使用“"”声明的数据就表示一个字符串。
范例：定义字符串变量
| public class TestDemo { public static void main(String args[]) { String str = "Hello " ; // 双引号声明 str = str + "World " ; // “+”表示字符串连接 str += "!!!" ;// 表示字符串连接 System.out.println(str) ; } } |
现在就可以发现，在数学计算之中“+”表示的是加法计算，而在字符串之中“+”表示字符串连接操作。所以，这个时候就可能会存在如下一种问题。
| public class TestDemo { public static void main(String args[]) { int numA = 10 ; double numB = 20.1 ; String result = "计算结果：" + numA + numB ; System.out.println(result) ; } } |
| 计算结果：1020.1 |
在Java里面任何的数据类型，只要是与String进行了“+”连接操作，那么都表示所有的类型自动的变为String后进行连接操作。那么为了正确只能够使用“()”改变优先级。
现在可以发现程序里面“'”表示字符，“"”表示字符串，那么如果要想包含这样的信息就必须采用转义字符，有如下的转义字符：\n（换行）、\t（Tab）、\"（"）、\'（'）、\\（\）。
范例：转义字符
| public class TestDemo { public static void main(String args[]) { String result = "\t\"Hello \'World . \n你好！" ; System.out.println(result) ; } } |
转义字符只在Java学习之中有用处，其它的地方意义不大。而如果是强制性拼凑字符串操作也会使用到。
2.5、运算符（重点）
程序就是一系列的运算符：数学、关系、逻辑、位等等。但是对于运算符的使用，个人的建议是别太复杂。
范例：观察如下的BT题目
| public class TestDemo { public static void main(String args[]) { int numA = 10 ; int numB = 20 ; int result = numA -- + numB * ++ numA / numB ++ * numA -- + numA - numB + ++ numB ; System.out.println(result) ; // 120 } } |
以上的这种复杂的运算并不建议使用。
任何的时候聪明点的人都不背，都依靠“()”修改操作的优先级。但是在这里需要强调三类运算符：三目、逻辑、位。
2.5.1、三目运算符
三目是一种逻辑的赋值运算。其基本操作格式：
| 数据类型 变量 = 布尔表达式 ? 值1 : 值2 ; |
如果布尔表达式成立，将值1的数据赋予变量，否则将值2的数据赋予变量。
| public class TestDemo { public static void main(String args[]) { int numA = 10 ; int numB = 20 ; int result = numA > numB ? numA : numB ; System.out.println(result) ; // 20 } } | public class TestDemo { public static void main(String args[]) { int numA = 10 ; int numB = 20 ; int result = 0 ; if (numA > numB) { result = numA ; } else { result = numB ; } System.out.println(result) ; // 20 } } |
三目也可以利用判断语句实现，不过代码较长。
2.5.2、逻辑运算
逻辑运算主要有与、或、非三种，其中非的实现主要依靠“!”完成。但是最为麻烦的是与和或两个运算，因为各自都有两组实现。
1、 与操作：（&、&&）
范例：观察“&”问题
| public class TestDemo { public static void main(String args[]) { if (1 == 2 & 10 / 0 == 0) { System.out.println("条件满足！") ; } } } |
| Exception in thread "main" java.lang.ArithmeticException: / by zero at TestDemo.main(TestDemo.java:3) |
此时出现了程序的错误，那么就表示两个判断条件实际上都执行了，但是来分析一下与操作的特点，与操作必须保证所有的判断条件都为true，最终才是true，那么按照之前的判断来讲，前面已经有条件返回了false，那么后面不管有多少个true，结果一定是false，那么就没有必要继续向后判断了，则可以使用短路与“&&”。
范例：使用“&&”
| public class TestDemo { public static void main(String args[]) { if (1 == 2 && 10 / 0 == 0) { System.out.println("条件满足！") ; } } } |
此时后面的条件没有继续判断，属于短路操作。
2、 或操作：（|、||）
范例：观察普通或“|”使用
| public class TestDemo { public static void main(String args[]) { if (1 == 1 | 10 / 0 == 0) { System.out.println("条件满足！") ; } } } |
| Exception in thread "main" java.lang.ArithmeticException: / by zero at TestDemo.main(TestDemo.java:3) |
由于或操作是若干个条件有一个返回true，结果就是true，而在以上的程序之中，发现前面有条件返回了true，但是后面的判断依然执行了，这就是因为普通或会将所有的条件都判断执行，而现在使用短路或。
范例：使用短路或（||）
| public class TestDemo { public static void main(String args[]) { if (1 == 1 || 10 / 0 == 0) { System.out.println("条件满足！") ; } } } |
此时前面的条件返回了true，而不管后面会返回多少个false，最终的结果也一定是true。
结论：在任何情况下编写逻辑判断的时候都使用“&&”、“||”。
2.5.3、位操作（了解）
对于位运算应该算是科班出身的基础知识，而且如果要想掌握更多的位运算，只能去学习汇编语言。今天采用一个最简单的方式介绍一下位运算。
位运算的初步就是需要实现十进制和二进制数据之间的转换操作，转换原则：数字除2取余，最后按照倒序排列。
十进制： 11 è 00000000 00000000 00000000 00001011（二进制数据）
÷ 2
5 …… 1 ↑
÷ 2
2 …… 1 ↑
÷ 2
1 …… 0 ↑
÷ 2
0 …… 1 ↑
在Java里面提供的位运算：&、|、~、^、>>、<<、>>>。
范例：实现“&”操作
| public class TestDemo { public static void main(String args[]) { int numA = 17 ; int numB = 11 ; System.out.println(numA & numB) ; } } |
17的二进制： 00000000 00000000 00000000 00010001；
11的二进制： 00000000 00000000 00000000 00001011；
&操作： 00000000 00000000 00000000 00000001； è 十进制：1
范例：实现“|”操作
| public class TestDemo { public static void main(String args[]) { int numA = 17 ; int numB = 11 ; System.out.println(numA | numB) ; } } |
17的二进制： 00000000 00000000 00000000 00010001；
11的二进制： 00000000 00000000 00000000 00001011；
|操作： 00000000 00000000 00000000 00011011； è 十进制：27
面试题：请用最快的方式计算2的3次方
最笨拙的方法是：2 * 2* 2 = 8；
采用移位：2 << 2；
| public class TestDemo { public static void main(String args[]) { int num = 2 ; System.out.println(num << 2) ; } } |
面试题：请解释“&”和“&&”、“|”和“||”的区别？
· 在逻辑运算上与和或分别有两种：
|- 与操作：
|- 普通与“&”：所有的判断条件都要执行；
|- 短路与“&&”：如果前面有条件返回了false，那么后面的条件不再执行，最终结果就是false；
|- 或操作：
|- 普通或“|”：所有的判断条件都要执行；
|- 短路或“||”：如果前面有条件返回了true，那么后面条件不再判断，最终结果就是true。
· 位操作：
|- 位与操作“&”：只有在两位都为1的时候才返回1，如果有一位是0返回0；
|- 位或操作“|”：只有在两位都为0的时候才返回0，如果有一位是1返回1。
2.6、程序结构（重点）
程序结构有三种：顺序、分支、循环。
实际上所有的程序都会包含有顺序的范畴，按照代码的定义的先后顺序执行。
1、 分支语句：
分支语句一共分为两种类型：条件分支、开关语句。
| if语句： | if…else语句： | if…else if…else语句： |
| if(布尔表达式) { // 条件满足时执行 } | if(布尔表达式) { // 条件满足时执行 } else { // 条件不满足时执行 } | if(布尔表达式) { // 条件满足时执行 } else if (布尔表达式) { // 条件满足时执行 } ..... else { // 条件不满足时执行 } |
范例：分支语句的使用
| public class TestDemo { public static void main(String args[]) { int num = 2 ; if(num > 0) { System.out.println("条件满足!") ; } } } |
范例：分支语句使用
| public class TestDemo { public static void main(String args[]) { int age = 19 ; if(age <= 250) { System.out.println("是个人类的年龄！") ; } else { System.out.println("恭喜你成为了非人类！") ; } } } |
范例：多条件判断
| public class TestDemo { public static void main(String args[]) { int age = 19 ; if(age >= 0 && age <= 19) { System.out.println("你还年轻！") ; } else if (age >= 20 && age <= 100) { System.out.println("恭喜你可以继续吃地沟油了。") ; } else { System.out.println("恭喜你快追随金波而去了。") ; } } } |
if语句在工作之中一定是被广泛使用的，因为它可以接收一些判断条件在。但是在判断语句之中还存在有一种开关语句，而且开关语句在JDK 1.7之后又发生了一些变化。
| switch(变量 | 常量) { case 值 : 满足时执行 ; [break] ; case 值 : 满足时执行 ; [break] ; ... [default : 默认执行 ; [break]] } |
但是在switch之中最早只能够使用int或char型数据，随着版本的更新，从JDK 1.5之后支持了enum类型，而在JDK 1.7之后支持了字符串数据。
范例：观察switch语句的执行
| public class TestDemo { public static void main(String args[]) { int ch = 0 ; switch(ch) { case 1 : System.out.println("内容是1") ; break ; case 0 : System.out.println("内容是0") ; break ; case 2 : System.out.println("内容是2") ; break ; default : System.out.println("没有条件满足") ; break ; } } } |
在switch之中如果每一个case之后没有break语句，那么就会在第一个满足的case之后的所有语句都执行，一直到break或者是执行完毕。
范例：从JDK 1.7开始支持了字符串的直接判断
| public class TestDemo { public static void main(String args[]) { String ch = "HELLO" ; switch(ch) { case "HELLO" : System.out.println("内容是HELLO") ; break ; case "WORLD" : System.out.println("内容是WORLD") ; break ; case "HAHA" : System.out.println("内容是HAHA") ; break ; default : System.out.println("没有条件满足") ; break ; } } } |
这样的功能已经嚷了十年了，才出现了，出现了也没意义了。
而且一定要记住switch语句是不支持条件判断的，它只能够判断数据是否相同。
2、 循环语句：
循环操作指的是某段代码被重复执行的操作，对于循环主要有两类：while、for。
| while循环： | do…while循环： |
| // 循环初始化条件 while(循环结束条件判断) { // 执行语句 // 修改循环条件或者是循环次数的统计 } | // 循环初始化条件 do { // 执行语句 // 修改循环条件或者是循环次数的统计 } while(循环结束条件判断) ; |
while循环和do..while循环的最大区别在于：while是先判断后执行，而do..while是先执行一次后判断，即：如果有判断条件不满足，while一次都不执行，而do…while执行一次。开发之中都使用while，正常人都不使do…while。
范例：使用while循环统计 1 ~ 100的累加
| public class TestDemo { public static void main(String args[]) { int x = 1 ; // 循环的初始化条件 int sum = 0 ; // 保存循环的内容 while (x <= 100) { sum += x ; // 累加 x ++ ; // 修改循环变量 } System.out.println("累加结果：" + sum) ; } } |
范例：使用do…while循环统计
| public class TestDemo { public static void main(String args[]) { int x = 1 ; // 循环的初始化条件 int sum = 0 ; // 保存循环的内容 do { sum += x ; // 累加 x ++ ; // 修改循环变量 } while (x <= 100) ; System.out.println("累加结果：" + sum) ; } } |
除了while循环之外，还有一个for循环。语法如下：
| for (循环初始化条件 ； 循环结束条件判断 ； 循环条件变更) { // 语句 } |
| 循环初始化条件 for ( ; 循环结束条件判断 ;) { // 语句 循环条件变更 } |
范例：使用for循环实现累加操作
| public class TestDemo { public static void main(String args[]) { int sum = 0 ; // 保存循环的内容 for (int x = 1 ; x <= 100 ; x ++) { sum += x ; } System.out.println("累加结果：" + sum) ; } } |
提示：关于循环的选择问题（个人总结，99%适用）
· 如果在已经明确知道循环次数的情况下，一定使用for循环；
· 如果不知道循环次数，但是知道循环结束条件，一定使用while循环。
除了单独使用循环之外，循环操作也可以进行嵌套使用。
范例：输出一个乘法口诀表
| public class TestDemo { public static void main(String args[]) { for (int x = 1 ; x <= 9 ; x ++) { // 控制行 for (int y = 1 ; y <= x ; y ++) { // 控制列 System.out.print(x + "*" + y + "=" + x * y + "\t") ; } // 每行输出之后要换行 System.out.println() ; // 换行 } } } |
在实际的工作里面这样的复杂循环是不会出现的，你们使用最多的都是单层循环。
在进行循环操作里面还有两个小的控制语句：break、continue；
范例：使用break退出整个循环
| public class TestDemo { public static void main(String args[]) { for (int x = 0 ; x < 10 ; x ++) { if (x == 3) { break ; } System.out.print(x + "、") ; } } } |
范例：使用continue结束一次循环
| public class TestDemo { public static void main(String args[]) { for (int x = 0 ; x < 10 ; x ++) { if (x == 3) { continue ; } System.out.print(x + "、") ; } } } |
这种代码是概念，但是使用不多，而且这种控制语句一定要结合if语句才可以使用。
扫一扫
5434
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
