Java 教程
注：String args[] 与 String[] args 都可以执行，但推荐使用 String[] args，这样可以避免歧义和误读。
执行命令解析：
以上我们使用了两个命令 javac 和 java。
javac
后面跟着的是java文件的文件名，例如 HelloWorld.java。 该命令用于将 java 源文件编译为 class 字节码文件，如：** javac HelloWorld.java。**
运行javac命令后，如果成功编译没有错误的话，会出现一个 HelloWorld.class 的文件。
java 后面跟着的是java文件中的类名,例如 HelloWorld 就是类名，如: java HelloWorld。
注意：java命令后面不要加.class。
public static void main(String[] args) {
System.out.println(args[0]);
}
- String[] args 可以看出来它是一个数组。
- 此处注意，main 是一个程序的入口，一个 java 程序运行必须而且有且仅有一个 main 方法。
- args[0] 是你传入的第一个参数，args[1]是传入的第二个参数，以此类推。
Java 简介
在正式学习java并安装配置开发环境之前，有必要了解一些有关Java的专业术语：
- JDK（Java Development Kit ）：编写Java程序的程序员使用的软件
- JRE（Java Runtime Environment）：运行Java程序的用户使用的软件
- Server JRE （Java SE Runtime Environment）：服务端使用的 Java 运行环境
- SDK（Software Development Kit）：软件开发工具包，在Java中用于描述1998年~2006年之间的JDK
- DAO（Data Access Object）：数据访问接口，数据访问，顾名思义就是与数据库打交道
- MVC（Model View Controller）：模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用于组织代码用一种业务逻辑和数据显示分离的方法
首先要明确一下两个概念上的区别：JDK、SDK。
- SDK——soft development kit，软件开发工具包。sdk是一个大的概念，比如开发安卓应用，你需要安卓开发工具包，叫 android sdk，比如你开发java程序，需要用到java - sdk，所以一般使用sdk这个概念，你需要在前面加上限定词。
- JDK——可以理解为 java sdk，它是编写java程序，使用到的工具包，为程序员提供一些已经封装好的 java 类库。
面向对象程序设计的 3 个主要特征：封装性、继承性、多态性。
Java 开发环境配置
Java 基础语法
基本语法 编写 Java 程序时，应注意以下几点：
- 大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
- 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应- 该大写，例如 MyFirstJavaClass 。
- 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
- 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
- 主方法入口：所有的 Java 程序由 public static void main(String []args) 方法开始执行。
- Java 标识符
Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
关于 Java 标识符，有以下几点需要注意： - 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
- 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
- 关键字不能用作标识符
- 标识符是大小写敏感的
- 合法标识符举例：age、$salary、_value、__1_value
- 非法标识符举例：123abc、-salary
Java修饰符
像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符： - 访问控制修饰符 : default, public , protected, private
- 非访问控制修饰符 : final, abstract, static, synchronized
在后面的章节中我们会深入讨论 Java 修饰符。
Java 变量
Java 中主要有如下几种类型的变量 - 局部变量
- 类变量（静态变量）
- 成员变量（非静态变量）
Java 数组
数组是储存在堆上的对象，可以保存多个同类型变量。在后面的章节中，我们将会学到如何声明、构造以及初始化一个数组。
Java 枚举
Java 5.0引入了枚举，枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的 bug。
例如，我们为果汁店设计一个程序，它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。
继承
在 Java 中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。
利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。
接口
在 Java 中，接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。
接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。
Java 对象和类
Java作为一种面向对象语言。支持以下基本概念：多态 继承 封装 抽象 类 对象 实例 方法 重载 本节我们重点研究对象和类的概念。
- 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
- 类：具备某些共同特征的实体的集合，它是一种抽象的数据类型，它是对所具有相同特征实体的抽象。类是把各种对象的一些共性一起封装起来了。它描述一类对象的行为和状态。
- java类是对具有相同特征事物的抽象，而对象是具体的个体。类是对象的抽象（集合），对象是类的实例。
一个类可以包含以下类型变量：
局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。
一个类可以拥有多个方法，在上面的例子中：barking()、hungry()和sleeping()都是Dog类的方法。
构造方法
每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。
下面是一个构造方法示例：
public class Puppy{
public Puppy(){
}
public Puppy(String name){
// 这个构造器仅有一个参数：name
}
}
创建对象 对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：
- 声明：声明一个对象，包括对象名称和对象类型。
- 实例化：使用关键字new来创建一个对象。
- 初始化：使用new创建对象时，会调用构造方法初始化对象。
下面是一个创建对象的例子：
public class Puppy{
public Puppy(String name){
//这个构造器仅有一个参数：name
System.out.println("小狗的名字是 : " + name );
}
public static void main(String[] args){
// 下面的语句将创建一个Puppy对象
Puppy myPuppy = new Puppy( "tommy" );
}
}
编译并运行上面的程序，会打印出下面的结果：
小狗的名字是 : tommy
源文件声明规则
在本节的最后部分，我们将学习源文件的声明规则。当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。
- 一个源文件中只能有一个public类
- 一个源文件可以有多个非public类
- 源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么- 源文件应该命名为Employee.java。
- 如果一个类定义在某个包中，那么package语句应该在源文件的首行。
- 如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。
- import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。
类有若干种访问级别，并且类也分不同的类型：抽象类和final类等。这些将在访问控制章节介绍。
除了上面提到的几种类型，Java还有一些特殊的类，如：内部类、匿名类。
Java包
包主要用来对类和接口进行分类。当开发Java程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。
Import语句
在Java中，如果给出一个完整的限定名，包括包名、类名，那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径，使得编译器可以找到某个类。
例如，下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类
import java.io.*;
类的构造方法
1、构造方法的名字和类名相同，并且没有返回值。
2、构造方法主要用于为类的对象定义初始化状态。
3、我们不能直接调用构造方法，必须通过new关键字来自动调用，从而创建类的实例。
4、Java的类都要求有构造方法，如果没有定义构造方法，Java编译器会为我们提供一个缺省的构造方法，也就是不带参数的构造方法。
new关键字的作用
1、为对象 分配内存空间。
2、引起对象构造方法的调用。
3、为对象返回一个引用。
Java 基本数据类型
内置数据类型
Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
byte：
| 数据类型 | 位数 | 默认值 | 取值范围 | 举例说明 |
|---|---|---|---|---|
| byte(位) | 8 | 0 | -2^7 - 2^7-1 | byte b = 10; |
| short(短整数) | 16 | 0 | -2^15 - 2^15-1 | short s = 10; |
| int(整数) | 32 | 0 | -2^31 - 2^31-1 | int i = 10; |
| long(长整数) | 64 | 0 | -2^63 - 2^63-1 | long l = 10l; |
| float(单精度) | 32 | 0.0 | -2^31 - 2^31-1 | float f = 10.0f; |
| double(双精度) | 64 | 0.0 | -2^63 - 2^63-1 | double d = 10.0d; |
| char(字符)16 | 空 | 0 | - 2^16-1 | char c = 'c'; |
| boolean(布尔值) | 8 | false | true、false | boolean b = true; |
整数型：byte、short、int、long，long修饰变量，需要在数值后加L或l
浮点数：float、double，表示小数点部分，float后面需要加上F或f，否则会被当成double处理，同double可以加D或d，也可不加
char类型：表示单个字符。字符需用单引号括起来，如：char a='a',可以和整数互相装换，字符a也可以写成 char a=97。也可以写成十六进制表示char a='\u0061'。
boolean类型：布尔类型，表示真值ture或者价值false，java中不能和整数类型或者其他类型互相转化。
引用类型
在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
- 对象、数组都是引用数据类型。
- 所有引用类型的默认值都是null。
- 一个引用变量可以用来引用任何与之兼容的类型。
- 例子：Site site = new Site("Runoob")。
Java 常量 - 常量在程序运行时是不能被修改的。
- 在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：
final double PI = 3.1415927;
虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。
自动类型转换
整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
转换从低级到高级。
低 ------------------------------------> 高
byte,short,char—> int —> long—> float —> double
数据类型转换必须满足如下规则：
-
不能对boolean类型进行类型转换。
-
不能把对象类型转换成不相关类的对象。
-
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
-
转换过程中可能导致溢出或损失精度，例如：
int i =128;
byte b = (byte)i;
因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。
Java 变量类型
在Java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：
type identifier [ = value][, identifier [= value] ...] ;
格式说明：type为Java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。
以下列出了一些变量的声明实例。注意有些包含了初始化过程。
int a, b, c; // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22; // 声明并初始化 z
String s = "runoob"; // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x'; // 声明变量 x 的值是字符 'x'。
Java语言支持的变量类型有：
- 类变量：独立于方法之外的变量，用 static 修饰。
- 实例变量：独立于方法之外的变量，不过没有 static 修饰。
- 局部变量：类的方法中的变量。
public class Variable{
static int allClicks=0; // 类变量
String str="hello world"; // 实例变量
public void method(){
int i =0; // 局部变量
}
}
java 局部变量
- 局部变量声明在方法、构造方法或者语句块中；
- 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
- 访问修饰符不能用于局部变量；
- 局部变量只在声明它的方法、构造方法或者语句块中可见；
- 局部变量是在栈上分配的。
- 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
实例变量
- 实例变量声明在一个类中，但在方法、构造方法和语句块之外；
- 当一个对象被实例化之后，每个实例变量的值就跟着确定；
- 实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
- 实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
- 实例变量可以声明在使用前或者使用后；
- 访问修饰符可以修饰实例变量；
- 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
- 实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
- 实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
类变量（静态变量）
- 类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
- 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
- 静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
- 静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
- 静态变量在第一次被访问时创建，在程序结束时销毁。
- 与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
- 默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
- 静态变量可以通过：ClassName.VariableName的方式访问。
- 类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。
成员变量、局部变量、静态变量的区别
| 成员变量 | 局部变量 | 静态变量 | |
|---|---|---|---|
| 定义位置 | 在类中,方法外 | 方法中,或者方法的形式参数 | 在类中,方法外 |
| 初始化值 | 有默认初始化值 | 无,先定义,赋值后才能使用 | 有默认初始化值 |
| 调用方式 | 对象调用 | --- | 对象调用，类名调用 |
| 存储位置 | 堆中 | 栈中 | 方法区 |
| 生命周期 | 与对象共存亡 | 与方法共存亡 | 与类共存亡 |
| 别名 | 实例变量 | --- | 类变量 |
Java 修饰符
访问控制修饰符 Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
- default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
- private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
- public : 对所有类可见。使用对象：类、接口、变量、方法
- protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
默认访问修饰符-不使用任何关键字
使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。
私有访问修饰符-private
私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。
声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。
公有访问修饰符-public
被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。
受保护的访问修饰符-protected
protected 需要从以下两个点来分析说明：
子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。
protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。
访问控制和继承
请注意以下方法继承的规则：
-
父类中声明为 public 的方法在子类中也必须为 public。
-
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
-
父类中声明为 private 的方法，不能够被继承。
非访问修饰符
为了实现一些其他的功能，Java 也提供了许多非访问修饰符。 -
static 修饰符，用来修饰类方法和类变量。
-
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
-
abstract 修饰符，用来创建抽象类和抽象方法。
-
synchronized 和 volatile 修饰符，主要用于线程的编程。
Java 运算符
算术运算符
算术运算符用在数学表达式中，主要实现的是算术运算，如常见的加法、减法、乘法、除法等。
表格中的例子中，变量a的值为 5，变量b的值为 3，变量i的值为 1：
| 算数运算符 | 名称 | 描述 | 类型 | 举例 |
|---|---|---|---|---|
| + | 加法 | 相加运算符两侧的值 | 双目运算符 | a + b 等于 8 |
| - | 减法 | 左操作数减去右操作数 | 双目运算符 | a - b 等于 2 |
| * | 乘法 | 相乘操作符两侧的值 | 双目运算符 | a * b 等于 15 |
| / | 除法 | 左操作数除以右操作数 | 双目运算符 | a / b 等于 1 |
| % | 取余 | 左操作数除右操作数的余数 | 双目运算符 | a % b 等于 2 |
| ++ | 自增 | 操作数的值增加 1 | ++i（或 i++） | 等于 2 |
| -- | 自减 | 操作数的值减少 1 | --i（或 i--） | 等于 0 |
其中，自增(++)和自减(--)运算符有两种写法：前缀（++i,--i）和后缀（i++,i--）。
- 前缀自增自减法(++i,--i): 先进行自增或者自减运算，再进行表达式运算。
- 后缀自增自减法(i++,i--): 先进行表达式运算，再进行自增或者自减运算。2
关系运算符
表格中的实例整数变量A的值为10，变量B的值为20：
| 运算符 | 描述 | 例子 |
|---|---|---|
| == | 检查如果两个操作数的值是否相等，如果相等则条件为真。 | （A == B）为假。 |
| != | 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 | （A> B）为假。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 | （A <B）为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 | （A> = B）为假。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 | （A <= B）为真。 |
位运算符
Java 定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。位运算时先转换为二进制，再按位运算。
表格中的例子中，变量a的值为 60，变量b的值为 13：
| 位运算符 | 名称 | 描述 | 举例 |
|---|---|---|---|
| & | 按位与 | 如果相对应位都是 1，则结果为 1，否则为 0 | （a＆b），得到 12，即 0000 1100 |
| 丨 | 按位或 | 如果相对应位都是 0，则结果为 0，否则为 1 | （ a 丨 b ）得到 61，即 0011 1101 |
| ^ | 按位异或 | 如果相对应位值相同，则结果为 0，否则为 1 | （a^b）得到 49，即 0011 0001 |
| ~ | 按位补 | 翻转操作数的每一位，即 0 变成 1，1 变成 0 | （〜a）得到-61，即 1100 0011 |
| << | 按位左移 | 左操作数按位左移右操作数指定的位数 | a<<2 得到 240，即 1111 0000 |
| >> | 按位右移 | 左操作数按位右移右操作数指定的位数 | a>>2 得到 15 即 1111 |
| >>> | 按位右移补零 | 左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充 | a>>>2 得到 15 即 0000 1111 |
逻辑运算符
逻辑运算符是通过运算符将操作数或等式进行逻辑判断的语句。
表格中的例子中，假设布尔变量 a 为真，变量 b 为假：
| 逻辑运算符 | 名称 | 描述 | 类型 | 举例 |
|---|---|---|---|---|
| && | 与 | 当且仅当两个操作数都为真，条件才为真 | 双目运算符 | （a && b）为假 |
| ｜｜ | 或 | 两个操作数任何一个为真，条件为真 | 双目运算符 | （a ｜｜ b）为真 |
| ！ | 非 | 用来反转操作数的逻辑状态。如果条件为真，则逻辑非运算符将得到假 | 单目运算符 | （!a）为假 |
| ^ | 异或 | 如果两个操作数逻辑相同，则结果为假，否则为真 | 双目运算符 | （a ^ b）为真 |
当使用&&(与)逻辑运算符时，在两个操作数都为 true 时，结果才为 true，但是当得到第一个操作为 false 时，其结果就必定是 false，这时候就不会再判断第二个操作了。
条件运算符（?:）
条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
variable x = (expression) ? value if true : value if false
instanceof 运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
instanceof运算符使用格式如下：
( Object reference variable ) instanceof (class/interface type)
Java 循环结构
Java中有三种主要的循环结构：
- while 循环
- do…while 循环
- for 循环
- while 循环
在Java5中引入了一种主要用于数组的增强型for循环。
while是最基本的循环，它的结构为：
while( 布尔表达式 ) {
//循环内容
}
do…while 循环
对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。
do {
//代码语句
}while(布尔表达式);
for循环
虽然所有循环结构都可以用 while 或者 do...while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。
for循环执行的次数是在执行前就确定的。语法格式如下：
for(初始化; 布尔表达式; 更新) {
//代码语句
}
注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。
关于 for 循环有以下几点说明：
- 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
- 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
- 执行一次循环后，更新循环控制变量。
- 再次检测布尔表达式。循环执行上面的过程。
- 判断条件无论是简单还是复杂结果都是布尔类型（布尔表达式）
Java 增强 for 循环
Java5 引入了一种主要用于数组的增强型 for 循环。
Java 增强 for 循环语法格式如下:
for(声明语句 : 表达式)
{
//代码句子
}
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
break 关键字
break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break 跳出最里层的循环，并且继续执行该循环下面的语句。
continue 关键字
continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。
for 嵌套循环实例：
for(int i=1; i<=3; i++){
for(int n=1; n<=3; n++){
//输出结果。。。。
System.out.println("i = " + i + ", n = " + n);
}
}
Java 条件语句
Java中有三种条件语句：
- if条件语句
- if...else条件语句
- if...else if...else条件语句
if 语句的语法如下：
if(布尔表达式)
{
//如果布尔表达式为true将执行的语句
}
如果布尔表达式的值为 true，则执行 if 语句中的代码块，否则执行 if 语句块后面的代码。
if…else 的用法如下：
if(布尔表达式){
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}
或
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码
}else {
//如果以上布尔表达式都不为true执行代码
}
if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行。
if...else if...else 语句
if 语句后面可以跟 else if…else 语句，这种语句可以检测到多种可能的情况。
使用 if，else if，else 语句的时候，需要注意下面几点：
- if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后。
- if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
- 一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。
嵌套的 if…else 语句
使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。
语法
嵌套的 if…else 语法格式如下：
if(布尔表达式 1){
////如果布尔表达式 1的值为true执行代码
if(布尔表达式 2){
////如果布尔表达式 2的值为true执行代码
}
}
你可以像 if 语句一样嵌套 else if...else。
Java switch case
switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
语法
switch case 语句语法格式如下：
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}
switch case 语句有如下规则：
- switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
- switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
- case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
- 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
- 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
- switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
- switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。
Java Number & Math 类
Java Number类
一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、long、double 等。
实例
int a = 5000;
float b = 13.65f;
byte c = 0x4a;
然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。
下面是一个使用 Integer 对象的实例：
Test.java 文件代码：
public class Test{
public static void main(String args[]){
Integer x = 5;
x = x + 10;
System.out.println(x);
}
}
以上实例编译运行结果如下：
15
当 x 被赋为整型值时，由于x是一个对象，所以编译器要对x进行装箱。然后，为了使x能进行加运算，所以要对x进行拆箱。
Java Math 类
Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。
Math.floor 是向下取整。
Math.ceil 是向上取整。
Math.round 是四舍五入取整 但是需要注意的是：
1、参数的小数点后第一位小于 5，运算结果为参数整数部分。
2、参数的小数点后第一位大于 5，运算结果为参数整数部分绝对值 +1，符号（即正负）不变。
3、参数的小数点后第一位等于 5，正数运算结果为整数部分 +1，负数运算结果为整数部分。
Java Character 类
Character 类用于对单个字符进行操作。
Character 类在对象中包装一个基本类型 char 的值
实例
char ch = 'a';
// Unicode 字符表示形式
char uniChar = '\u039A';
// 字符数组
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };
然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情况。为了解决这个问题，Java语言为内置数据类型char提供了包装类Character类。
Character类提供了一系列方法来操纵字符。你可以使用Character的构造方法创建一个Character类对象，例如：
Character ch = new Character('a');
在某些情况下，Java编译器会自动创建一个Character对象。
例如，将一个char类型的参数传递给需要一个Character类型参数的方法时，那么编译器会自动地将char类型参数转换为Character对象。 这种特征称为装箱，反过来称为拆箱。
实例
// 原始字符 'a' 装箱到 Character 对象 ch 中
Character ch = 'a';
// 原始字符 'x' 用 test 方法装箱
// 返回拆箱的值到 'c'
char c = test('x');
转义序列
前面有反斜杠（\）的字符代表转义字符，它对编译器来说是有特殊含义的。
下面列表展示了Java的转义序列：
| 转义序列 | 描述 |
|---|---|
| \t | 在文中该处插入一个tab键 |
| \b | 在文中该处插入一个后退键 |
| \n | 在文中该处换行 |
| \r | 在文中该处插入回车 |
| \f | 在文中该处插入换页符 |
| ' | 在文中该处插入单引号 |
| " | 在文中该处插入双引号 |
| \ | 在文中该处插入反斜杠 |
\r： return 到当前行的最左边。
\n： newline 向下移动一行，并不移动左右。
Linux中\n表示：回车+换行；
Windows中\r\n表示：回车+换行。
Mac中\r表示：回车+换行。
实例
当打印语句遇到一个转义序列时，编译器可以正确地对其进行解释。
以下实例转义双引号并输出：
Test.java 文件代码：
public class Test {
public static void main(String args[]) {
System.out.println("访问\"菜鸟教程!\"");
}
}
以上实例编译运行结果如下：
访问"菜鸟教程!"
Java String 类
Java StringBuffer
Java 数组
Java 语言中提供的数组是用来存储固定大小的同类型元素。
你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99。
声明数组变量
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
dataType:数据库类型
dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法
注意: 建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar[] 风格是来自 C/C++ 语言 ，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。
创建数组
Java语言使用new操作符来创建数组，语法如下：
arrayRefVar = new dataType[arraySize];
上面的语法语句做了两件事：
一、使用 dataType[arraySize] 创建了一个数组。
二、把新创建的数组的引用赋值给变量 arrayRefVar。
数组变量的声明，和创建数组可以用一条语句完成，如下所示：
dataType[] arrayRefVar = new dataType[arraySize];
或
dataType[] arrayRefVar = {value0, value1, ..., valuek};
数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。
处理数组
数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者 For-Each 循环。
示例
该实例完整地展示了如何创建、初始化和操纵数组：
TestArray.java 文件代码：
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (int i = 0; i < myList.length; i++) {
System.out.println(myList[i] + " ");
}
或
// 打印所有数组元素
for(type element: array){
System.out.println(element);
}
// 计算所有元素的总和
double total = 0;
for (int i = 0; i < myList.length; i++) {
total += myList[i];
}
System.out.println("Total is " + total);
// 查找最大元素
double max = myList[0];
for (int i = 1; i < myList.length; i++) {
if (myList[i] > max) max = myList[i];
}
System.out.println("Max is " + max);
}
}
以上实例编译运行结果如下：
1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5
数组作为函数的参数
数组可以作为参数传递给方法。
例如，下面的例子就是一个打印 int 数组中元素的方法:
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
下面例子调用 printArray 方法打印出 3，1，2，6，4 和 2：
printArray(new int[]{3, 1, 2, 6, 4, 2});
数组作为函数的返回值
public static int[] reverse(int[] list) {
int[] result = new int[list.length];
for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
result[j] = list[i];
}
return result;
}
以上实例中 result 数组作为函数的返回值。
数组作为函数的参数和数组作为函数的返回值
实例和数组倒序实例：
public class Test2 {
public static void main(String[] args){
int[] test= {1,2,4,5,7};
for (int i : test) {
System.out.print(i+" ");
}
System.out.println("\n");
test = Test2.reverse(test);
for (int i : test) {
System.out.print(i+" ");
}
}
public static int[] reverse(int[] arr){
int[] result = new int[arr.length];
for (int i = 0,j=result.length-1; i < arr.length; i++,j--) {
result[j] = arr[i];
}
return result;
}
}
多维数组
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：
String str[][] = new String[3][4];
多维数组的动态初始化（以二维数组为例）
- 直接为每一维分配空间，格式如下：
type[][] typeName = new type[typeLength1][typeLength2];
type 可以为基本数据类型和复合数据类型，arraylength1 和 arraylength2 必须为正整数，arraylength1 为行数，arraylength2 为列数。
例如：
int a[][] = new int[2][3];
解析：
二维数组 a 可以看成一个两行三列的数组。
2. 从最高维开始，分别为每一维分配空间，例如：
String s[][] = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");
解析：
s[0]=new String[2] 和 s[1]=new String[3] 是为最高维分配引用空间，也就是为最高维限制其能保存数据的最长的长度，然后再为其每个数组元素单独分配空间 s0=new String("Good") 等操作。
多维数组的引用（以二维数组为例）
对二维数组中的每个元素，引用方式为 arrayName[index1][index2]，例如：
num[1][0];
// 声明二维数组：有两行，列数待定，数组结构 = { { }, { } }
String s[][] = new String[2][];
// 确定每行的元素个数，第一行有2个元素，第二行有3个元素，
// 数组结构 = {{"E1", "E2"}, {"E1", "E2", "E3"}}
s[0] = new String[2];
s[1] = new String[3];
Arrays 类
java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
具有以下功能：
- 给数组赋值：通过 fill 方法。
- 对数组排序：通过 sort 方法,按升序。
- 比较数组：通过 equals 方法比较数组中元素值是否相等。
- 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
具体说明请查看下表：
| 序号 | 方法和说明 |
|---|---|
| 1 public static int binarySearch(Object[] a, Object key) | 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。 |
| 2 public static boolean equals(long[] a, long[] a2) | 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
| 3 public static void fill(int[] a, int val) | 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
| 4 public static void sort(Object[] a) | 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
