Java系列（二）__Java基本概念

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设置为“.”，表示从当前所在路径加载。

范例：设置从当前所在路径加载类

SET 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语句才可以使用。