java基础
1. 概述
Java 编程语言最初是由太阳计算机系统公司开发的，该公司由 James gosling 于 1995 年创立，它的主要组成部分就是 Java 平台。
截止到 2008 年 12 月，最新发布的 Java 标准版本是第六版（J2SE）。随着 Java 的发展进步和它的广泛流行， Java 做出了很多调整从而适应不同类型的平台。例如： J2EE 是为企业级应用程序设计的， J2ME 是为移动应用程序设计的。
Sun 计算机系统有限公司将新的 J2 版本分别命名为 Java SE、Java EE 和 Java ME。 Java 承诺 “编写一次，随处运行”。
Java 是：
- 面向对象的：在 Java 中，所有的东西都是一个对象。 Java 可以很容易的扩展原因就是因为它是基于对象模型的。
- 平台独立的： Java 不像包括 C 和 C++ 语言在内的其他语言，当 Java 被编译时，它并不是编译到特定的机器中，而是用具有平台独立性的字节码编译。这种字节码在网页上是分布式存储的，并且可以再不同的平台通用的虚拟机上运行。
- 简单的：Java 是为了易于学习而设计的。如果你能够理解面向对象程序设计的基本概念，那么你就很容易掌握 Java 了。
- 安全的：由于 Java 的安全特征它可以用来开发防病毒、防干扰的系统。它的身份验证技术是基于公开密钥加密技术的。
- 体系结构中立的：Java 编译器可以生成一个结构中立的对象文件格式，它能够使被编译过的代码在 Java 运行系统存在的情况下在很多进程中运行。
- 便捷的：由于 Java 的结构中立性以及它的运行不受限制的特征使得它十分便捷， Java 中的编译器是由 ANSI C 语言编写的，它具有很好的接口是因为它是可移植性系统操作接口的子接口。
- 稳健的：Java 主要通过检查编译时间错误以及运行检查来努力消除有错误倾向的情况。
- 多线程的：因为 Java 的多线程性的特征使得它可以用于编写同时执行众多任务的程序。这个特征可以使开发者平稳设计运行交互式应用程序。
- 易于理解的：Java 的字节码可以很容易翻译成本地机器码并且很容易存储于任意位置。这个发展进程很快并且很有分析性，因为他们的联系就像增加和减轻体重的过程。
- 高性能：由于使用了准时编译器，它可以表现出很高的性能。
- 分布式的：Java 是为互联网分布式的结构而设计的。
- 动态的：Java 被认为是比 C 和 C++ 更有活力的语言因为它是为适应动态环境而设计的。Java 程序可以携带大量的运行信息，这些信息可以用来区分对象间的入口问题。
Java 的历史
James Gosling 在 1991 年启动 Java 语言项目是为了在他的众多的电视机顶盒项目之一上应用，这种语言起初被称为 Oak ，是因为 Gosling 的办公室外有一棵像树，也被称为过 Green ，最终被以一些随机的字母命名为 Java。
Sun 计算机有限公司于 1995 年发行第一个公开版本 Java1.0。它承诺“编写一次，随处运行”（WORA），并且提供在任意主流平台上无成本运行。
2006 年 11 月 13 日，根据 GNU 的通用公共许可证（GPL），太阳计算机有限公司发布了许多免费且开源的 Java 应用程序。
2007 年 5 月 8 日，太阳计算机有限公司完成了一项进程，它将除去一小部分没有版权的代码外的核心代码全部免费且开源。
你所需要的工具
为了试验本指南中所给的例子，你需要一台处理器为奔腾 200MHz，最小内存 64MB（推荐128MB）的电脑。
你还需要下列软件：
- Linux 7.1 或者 Windows XP/7/8 操作系统
- Java JDK 8
- 微软记事本程序或其他文本编辑器
本指南将提供用 Java 创建图形用户界面，网络及网页应用程序的必要技巧。
2. 环境设置
本地环境设置
如果你依然想要为 Java 编程语言设置环境，那么本节将指导你如何在你的电脑上下载和设置 Java。请按照以下步骤进行环境设置。
Java SE 可以从下载 Java 这个链接免费下载。你可以根据你的系统类型下载相应版本的 Java。
按照上述指导下载 Java 然后运行 .exe 文件进行安装。你在电脑上安装完 Java 之后，你需要将环境变量设置到指定目录。
Windows XP/7/8 系统下的设置方法
假设你把 Java 安装在 c:\Program Files\java\jdk 路径下：
- 右键点击「我的电脑」选择「属性」选项
- 在高级标签下点击「环境变量」按钮
- 现在，改变变量的路径使其包含可执行的 Java 程序。
例如：如果现在的路径设置的是
C:\WINDOWS\SYSTEM32，
那么就要将其改成C:\WINDOWS\SYSTEM32;c:\ProgramFiles\java\jdk\bin。
Linux, UNIX, Solaris, FreeBSD 系统下的设置方法
环境变量路径必须指向 Java 文件的安装位置。如果进行该设置时有任何问题，请参考shell帮助文档。
例如，如果你用 bash 作为你的 shell ，那么在你的 shell 最后加入如下代码
.bashrc: export PATH=/path/to/java:$PATH
流行的 Java 编辑器
在编写 Java 程序时，你需要一个文本编辑器。市场中有很多精致的编辑器。但是就现在而言，你可以考虑下面几个：
- 记事本：在 Windows 计算机中你可以使用像记事本（本指导推荐），日记本这样的简单的文本编辑器。
- Netbeans：这是一款开源且免费的 Java 编辑器。你可以从以下链接下载http://www.netbeans.org/index.html
- Eclipse：这是一款由 eclipse 开源社区开发的 Java 编辑器。你可以从以下链接下载 http://www.eclipse.org/
3. 基本语法
Java 应用程序可以被定义为对象的集合，这些对象通过调用各自的方法来进行通信。下面让我们具体看一看类，对象，方法，实体变量是什么含义。
- 对象:对象具有状态和行为。例如：狗有它的状态—颜色，名字，品种，同时也有行为—摇尾巴，汪汪叫，吃东西。对象时类的一个实例。
- 类:类可以被定义为描述对象所支持的类型的行为和状态的模板或蓝图。
- 方法:方法是一种基本的行为。类中可以包含很多方法。在方法中，可以编写逻辑，操纵数据，执行动作。
- 实体变量:每个对象都有它的特殊的实体变量的集合，一个对象的状态是由那些实体变量所被赋的值所决定的。
第一个 Java 程序
让我们看一下下面可以输出 “Hello World” 的代码。
public class MyFirstJavaProgram { /* This is my first java program. * This will print 'Hello World' as the output */ public static void main(String []args) { System.out.println("Hello World"); // prints Hello World } } 让我们看一下如何保存这个文件，编译运行这个程序。请按照以下步骤操作：
- 打开记事本添加上述代码
- 以
MyFirstJavaProgram.java为文件名保存文件 - 打开命令提示符窗口转到你保存类的位置。假设是
C:\ - 在窗口中输入
javac MyFirstJavaProgram.java然后按回车来编译你的代码。如果你的代码没有错误，那么命令提示符将会转到下一行（假设：路径变量设置成功）。 - 现在输入
java MyFirstJavaProgram来运行你的程序 - 你将会看到屏幕上显示
“Hello World”
C : > javac MyFirstJavaProgram.java C : > java MyFirstJavaProgram Hello World基本语法
关于 Java 程序，记住一下几点很重要。
- 大小写敏感性： Java 是一种大小写敏感的语言，这就意味着 Hello 和 hello 在 Java 中代表不同的意思。
- 类的命名：所有类的名称首字母必须大写。
如果类名称中包含几个单词，那么每个单词的首字母都要大写。
例如类MyFirstJavaClass - 方法的命名：所有方法名称必须以小写字母开头。
如果方法名称中包含几个单词，那么其中的每个单词的首字母都要大写。
例如public void myMethodName() - 程序文件名：程序的文件名必须和类的名称准确匹配。
但保存文件时，你应当以类的名称保存（注意区分大小写），并在文件名后加 .java 的后缀（如果文件名和类名不匹配那么将无法编译你的程序）。
例如：假设类名是MyFirstJavaProgram，那么文件名就应该是MyFirstJavaProgram.java。 - public
static void main(String args[])：Java 程序都是从
main（）方法开始处理的，这个方法是 Java 程序的强制性的部分。
Java 标识符
Java 的所有的组成部分都要有自己的名称。类、变量和方法的名称称为标识符。
在 Java 中，需要记住关于标识符的一下几点。如下：
- 所有标识符必须以字母（ A 到 Z 或者 a 到 z ）、货币字符（ $ ）或者下划线( _ )开头。
- 在第一个标识符之后可以有任意字母组合。
- 关键字不能被用作标识符。
- 大多数标识符需要区分大小写。
- 合法标识符的例子： age, $salary, _value, __1_value
- 非法标识符的例子： 123abc, -salary
Java 修饰符
如其语言一样，方法和类等等是可以通过修饰符修饰的。Java 中有两种修饰符：
- 访问修饰符：default, public , protected, private
- 非访问修饰符：final, abstract, strictfp
我们将在下一节继续学习修饰符相关知识。
Java 变量
在 Java 中我们可以看到如下变量：
- 本地变量
- 类变量（静态变量）
- 实例变量（非静态变量）
Java 数组
数组时储存有多重相同变量类型的对象。然而，数字自身也是堆中的一个对象。我们将要学习如何声明，建立，初始化数组。
Java 枚举值
枚举是在 Java5.0 版本中被引进的。枚举限制了变量要有一些预先定义的值。枚举列表中的值称为枚举值。
运用枚举值可以大大减少你的代码中的漏洞。
举例来说，如果我们想为一家鲜榨果汁店编个程序，就可以将杯子的尺寸限制为小中和大。这样就可以确保人们不会定大中小尺寸之外的了。
例如：
class FreshJuice { enum FreshJuiceSize{ SMALL, MEDIUM, LARGE } FreshJuiceSize size; } public class FreshJuiceTest { public static void main(String args[]){ FreshJuice juice = new FreshJuice(); juice.size = FreshJuice. FreshJuiceSize.MEDIUM ; System.out.println("Size: " + juice.size); } }上述例子会输出如下结果：
Size: MEDIUM注：枚举可以自己声明也可以在类中声明。方法变量和构造器也可以在枚举值中定义。
Java 关键字
下面列出的是 Java 中保留的关键字。这些关键字不能用作常量、变量和其他标识符的名字。
|
关键字 |
关键字 |
关键字 |
关键字 |
|
abstract |
assert |
boolean |
break |
|
byte |
case |
catch |
char |
|
class |
const |
continue |
default |
|
do |
double |
else |
enum |
|
extends |
final |
finally |
float |
|
for |
goto |
if |
implements |
|
import |
instanceof |
int |
interface |
|
long |
native |
new |
package |
|
private |
protected |
public |
return |
|
short |
static |
strictfp |
super |
|
switch |
synchronized |
this |
throw |
|
throws |
transient |
try |
void |
|
volatile |
while |
Java 中的注释
Java 像 C 和 C++ 一样支持单行或多行注释。所有注释中的字母都会被 Java 编译器忽略。
public class MyFirstJavaProgram{ /* This is my first java program. * This will print 'Hello World' as the output * This is an example of multi-line comments. */ public static void main(String []args){ // This is an example of single line comment /* This is also an example of single line comment. */ System.out.println("Hello World"); } } 使用空行
一行只有空格的行可能是注释，这样的行叫做空行，Java 会完全忽略它。
继承
在 Java 中类可以从类中产生。简单来说，如果你想要创建一个新类并且现在已经存在一个包含你所需要代码的类，那么就有可能从这些存在的代码创建你的类。
这个概念可以使你在没有在新类中重写代码的情况下重复利用文件和方法。在这种情况下已经存在的类叫做超类，后来产生的类叫做子类。
接口
在 Java 语言中，接口可以定义为对象之间如何通信的合同。就继承性而言接口扮演了重要角色。
接口定义了子类所需要用的方法。但是方法的实施还是取决于子类。
4. 对象和类
Java 是一种面向对象的语言。作为一种具有面向对象特征的语言
Java 包括以下几项基本概念：
- 多态性
- 继承性
- 封装性
- 抽象性
- 类
- 对象
- 实例
- 消息解析
在这一章，我们将深入学习类和对象。
- 对象：对象具有状态和行为。如果我们考虑现实世界我们可以在我们身边找到很多对象，小汽车，狗，人类等等。所有这些对象都具有状态和行为。
- 类：类可以被定义为描述对象支持类型的行为、状态的的模板、蓝图。
Java 中的对象
现在让我们深入学习对象。如果我们考虑一条狗，那么它的状态就是-名字，品种，颜色，它的行为就是汪汪，摇尾巴，跑。
如果我们将软件中的对象和现实世界中的对象对比，那么我们将会发现他们有很多相似的特征。软件中的对象也具有状态和行为。软件的状态被储存在文件中，它的行为通过方法来表现。
因此，在软件发展过程中方法控制对象的内在状态并且对象和对象间的交流通过方法来完成。
Java 中的类
类是有独立的对象创造出的蓝图。
下面给出了一个类的例子：
public class Dog{ String breed; int age; String color; void barking(){ } void hungry(){ } void sleeping(){ } }类可以包括以下的变量类型：
- 局部变量：在方法，构造器或区域中定义的变量成为局部变量。变量将会在方法内产生和发展，然后当方法结束变量就会破坏。
- 实例变量：实例变量是在类内但是在方法外的变量。这些变量是当类被装载时被实体化的。实例变量可以是从特定类的任何方法，构造器，区域中存取。
- 类变量：类变量是在类中声明的变量，它处在任何方法之外，有静态关键字。
类可以有任意数量的方法来存取不同种类方法的值。在上面的例子中，barking()，hungry() 和 sleeping() 是方法。
下面提到的是一些深入了解 Java 语言所必须讨论的重要话题。
构造器
当我们讨论类时，其中一个重要的子话题就是构造器。每一个类都有一个构造器。如果我们不单独为一个类编写构造器那么 Java 的编译器将会给这个类建立一个默认的构造器。
每当一个新的对象被创建，至少一个构造器将会被调用。构造器的一个最主要的原则就是他们必须和类有同样的名字。一个类可以有不止一个构造器。
下面给出了一个构造器的例子：
public class Puppy{ public Puppy(){ } public Puppy(String name){ // This constructor has one parameter, name. } }在需要只创建一个类的实例的时，Java 也支持单例。
创造一个对象
如前所述，类为对象提供了蓝图。因此基本来说一个对象是从一个类中创造出来的。在 Java 中，新的关键词被用来创造新的对象。当我们从类中创造对象时需要三步：
- 声明：变量声明可以声明其所代表的对象类型。
- 实例化：“新的”关键词用来创造对象。
- 初始化：“新的”关键词伴随着一个构造器的启用，这个将新的对象初始化。
下面给出了一个创造对象的例子：
public class Puppy{ public Puppy(String name){ // This constructor has one parameter, name. System.out.println("Passed Name is :" + name ); } public static void main(String []args){ // Following statement would create an object myPuppy Puppy myPuppy = new Puppy( "tommy" ); } }如果编译并运行上述程序，那么将输出下列结果：
Passed Name is :tommy访问实体变量和方法
实体变量和方法是通过创造对象来访问的。为了访问一个实体变量完全有效的路径应该如下所示：
/* First create an object */ ObjectReference = new Constructor(); /* Now call a variable as follows */ ObjectReference.variableName; /* Now you can call a class method as follows */ ObjectReference.MethodName();例子
这个例子解释了如何存取类的实体变量和方法：
public class Puppy{ int puppyAge; public Puppy(String name){ // This constructor has one parameter, name. System.out.println("Passed Name is :" + name ); } public void setAge( int age ){ puppyAge = age; } public int getAge( ){ System.out.println("Puppy's age is :" + puppyAge ); return puppyAge; } public static void main(String []args){ /* Object creation */ Puppy myPuppy = new Puppy( "tommy" ); /* Call class method to set puppy's age */ myPuppy.setAge( 2 ); /* Call another class method to get puppy's age */ myPuppy.getAge( ); /* You can access instance variable as follows as well */ System.out.println("Variable Value :" + myPuppy.puppyAge ); } }如果我们编译运行上述程序，那么将会产生如下结果：
Passed Name is :tommy Puppy's age is :2 Variable Value :2源文件声明规则
在本节的最后一部分让我们学习一下源文件声明规则。当在源文件中声明类，输入和打包语法时，这些规则是十分重要的。
- 每个源文件中只能有一个公共类。
- 一个源文件可以有很多非公共类。
- 公共类的名称必须是源文件的名称同时也要以
.java为后缀。举例来说：类的名称是public class Employee{}，那么源文件就应该是Employee.java。 - 如果类是在一个程序包中定义的，那么程序包的声明必须是源文件的第一个声明。
- 如果输入声明出现那么他们必须被写在封装声明和类声明之间。如果没有封装声明那么输入声明必须在源文件的第一行。
- 输入和打包声明会暗示所有源文件中的存在的类。在源文件中很难为不同的类区分输入和封装声明。
类有不同的访问级别并且有很多不同的类；抽象的类，最终的类等等。我将会在后面的访问控制修饰符章节解释这些。
除了以上提到的类的类型之外， Java 也有像内部类和匿名类这样的特殊类。
Java 程序包
简而言之，就是一种分类类和接口的一种方法。当用 Java 开发程序时，数百个类和接口会被编写，因此分类这些类不但是必须的而且也是会使问题变得容易的。
Import 语法
在 Java 中，如果给出包括封装和类的名称的全限定名，那么编译器很容易定位到源类和源代码。Import 语法是给编译器寻找特定类的适当位置的一种方法。
举例来说，下面这行语句将会要求编译器去装载 java_installation/java/io 路径下的所有可用的类:
import java.io.*;一个简单的案例学习
在我们的案例学习中，我们将创造两个类。他们是 Employee 和 EmployeeTest。
首先打开记事本输入下列代码。记得这个是 Employee 类，这个类是公共类。现在以 Employee.java 为文件名保存这个源文件。
这个 Employee 类包括四个实体变量姓名（name），年龄（age），职位（designation）和薪水（salary）。这个类有一个确定的需要参数的的构造器。
import java.io.*; public class Employee{ String name; int age; String designation; double salary; // This is the constructor of the class Employee public Employee(String name){ this.name = name; } // Assign the age of the Employee to the variable age. public void empAge(int empAge){ age = empAge; } /* Assign the designation to the variable designation.*/ public void empDesignation(String empDesig){ designation = empDesig; } /* Assign the salary to the variable salary.*/ public void empSalary(double empSalary){ salary = empSalary; } /* Print the Employee details */ public void printEmployee(){ System.out.println("Name:"+ name ); System.out.println("Age:" + age ); System.out.println("Designation:" + designation ); System.out.println("Salary:" + salary); } }正如本指导之前所述，编程从主函数开始。因此，我们为了运行这个 Employee 类就应当建立主函数和类。我们将分别为这些任务创建类。
下面所给的是 EmployeeTest 类，这个类创建了两个 Employee 类的实例，并且为每个对象调用方法从而给每个变量赋值。
在 EmployeeTest.java 文件中保存下列代码
import java.io.*; public class EmployeeTest{ public static void main(String args[]){ /* Create two objects using constructor */ Employee empOne = new Employee("James Smith"); Employee empTwo = new Employee("Mary Anne"); // Invoking methods for each object created empOne.empAge(26); empOne.empDesignation("Senior Software Engineer"); empOne.empSalary(1000); empOne.printEmployee(); empTwo.empAge(21); empTwo.empDesignation("Software Engineer"); empTwo.empSalary(500); empTwo.printEmployee(); } }现在编译两个类然后运行 EmployeeTest，你将会看到如下结果：
C :> javac Employee.java C :> vi EmployeeTest.java C :> javac EmployeeTest.java C :> java EmployeeTest Name:James Smith Age:26 Designation:Senior Software Engineer Salary:1000.0 Name:Mary Anne Age:21 Designation:Software Engineer Salary:500.0Java 是一种面向对象的语言。作为一种具有面向对象特征的语言
Java 包括以下几项基本概念：
- 多态性
- 继承性
- 封装性
- 抽象性
- 类
- 对象
- 实例
- 消息解析
在这一章，我们将深入学习类和对象。
- 对象：对象具有状态和行为。如果我们考虑现实世界我们可以在我们身边找到很多对象，小汽车，狗，人类等等。所有这些对象都具有状态和行为。
- 类：类可以被定义为描述对象支持类型的行为、状态的的模板、蓝图。
Java 中的对象
现在让我们深入学习对象。如果我们考虑一条狗，那么它的状态就是-名字，品种，颜色，它的行为就是汪汪，摇尾巴，跑。
如果我们将软件中的对象和现实世界中的对象对比，那么我们将会发现他们有很多相似的特征。软件中的对象也具有状态和行为。软件的状态被储存在文件中，它的行为通过方法来表现。
因此，在软件发展过程中方法控制对象的内在状态并且对象和对象间的交流通过方法来完成。
Java 中的类
类是有独立的对象创造出的蓝图。
下面给出了一个类的例子：
public class Dog{ String breed; int age; String color; void barking(){ } void hungry(){ } void sleeping(){ } }类可以包括以下的变量类型：
- 局部变量：在方法，构造器或区域中定义的变量成为局部变量。变量将会在方法内产生和发展，然后当方法结束变量就会破坏。
- 实例变量：实例变量是在类内但是在方法外的变量。这些变量是当类被装载时被实体化的。实例变量可以是从特定类的任何方法，构造器，区域中存取。
- 类变量：类变量是在类中声明的变量，它处在任何方法之外，有静态关键字。
类可以有任意数量的方法来存取不同种类方法的值。在上面的例子中，barking()，hungry() 和 sleeping() 是方法。
下面提到的是一些深入了解 Java 语言所必须讨论的重要话题。
构造器
当我们讨论类时，其中一个重要的子话题就是构造器。每一个类都有一个构造器。如果我们不单独为一个类编写构造器那么 Java 的编译器将会给这个类建立一个默认的构造器。
每当一个新的对象被创建，至少一个构造器将会被调用。构造器的一个最主要的原则就是他们必须和类有同样的名字。一个类可以有不止一个构造器。
下面给出了一个构造器的例子：
public class Puppy{ public Puppy(){ } public Puppy(String name){ // This constructor has one parameter, name. } }在需要只创建一个类的实例的时，Java 也支持单例。
创造一个对象
如前所述，类为对象提供了蓝图。因此基本来说一个对象是从一个类中创造出来的。在 Java 中，新的关键词被用来创造新的对象。当我们从类中创造对象时需要三步：
- 声明：变量声明可以声明其所代表的对象类型。
- 实例化：“新的”关键词用来创造对象。
- 初始化：“新的”关键词伴随着一个构造器的启用，这个将新的对象初始化。
下面给出了一个创造对象的例子：
public class Puppy{ public Puppy(String name){ // This constructor has one parameter, name. System.out.println("Passed Name is :" + name ); } public static void main(String []args){ // Following statement would create an object myPuppy Puppy myPuppy = new Puppy( "tommy" ); } }如果编译并运行上述程序，那么将输出下列结果：
Passed Name is :tommy访问实体变量和方法
实体变量和方法是通过创造对象来访问的。为了访问一个实体变量完全有效的路径应该如下所示：
/* First create an object */ ObjectReference = new Constructor(); /* Now call a variable as follows */ ObjectReference.variableName; /* Now you can call a class method as follows */ ObjectReference.MethodName();例子
这个例子解释了如何存取类的实体变量和方法：
public class Puppy{ int puppyAge; public Puppy(String name){ // This constructor has one parameter, name. System.out.println("Passed Name is :" + name ); } public void setAge( int age ){ puppyAge = age; } public int getAge( ){ System.out.println("Puppy's age is :" + puppyAge ); return puppyAge; } public static void main(String []args){ /* Object creation */ Puppy myPuppy = new Puppy( "tommy" ); /* Call class method to set puppy's age */ myPuppy.setAge( 2 ); /* Call another class method to get puppy's age */ myPuppy.getAge( ); /* You can access instance variable as follows as well */ System.out.println("Variable Value :" + myPuppy.puppyAge ); } }如果我们编译运行上述程序，那么将会产生如下结果：
Passed Name is :tommy Puppy's age is :2 Variable Value :2源文件声明规则
在本节的最后一部分让我们学习一下源文件声明规则。当在源文件中声明类，输入和打包语法时，这些规则是十分重要的。
- 每个源文件中只能有一个公共类。
- 一个源文件可以有很多非公共类。
- 公共类的名称必须是源文件的名称同时也要以
.java为后缀。举例来说：类的名称是public class Employee{}，那么源文件就应该是Employee.java。 - 如果类是在一个程序包中定义的，那么程序包的声明必须是源文件的第一个声明。
- 如果输入声明出现那么他们必须被写在封装声明和类声明之间。如果没有封装声明那么输入声明必须在源文件的第一行。
- 输入和打包声明会暗示所有源文件中的存在的类。在源文件中很难为不同的类区分输入和封装声明。
类有不同的访问级别并且有很多不同的类；抽象的类，最终的类等等。我将会在后面的访问控制修饰符章节解释这些。
除了以上提到的类的类型之外， Java 也有像内部类和匿名类这样的特殊类。
Java 程序包
简而言之，就是一种分类类和接口的一种方法。当用 Java 开发程序时，数百个类和接口会被编写，因此分类这些类不但是必须的而且也是会使问题变得容易的。
Import 语法
在 Java 中，如果给出包括封装和类的名称的全限定名，那么编译器很容易定位到源类和源代码。Import 语法是给编译器寻找特定类的适当位置的一种方法。
举例来说，下面这行语句将会要求编译器去装载 java_installation/java/io 路径下的所有可用的类:
import java.io.*;一个简单的案例学习
在我们的案例学习中，我们将创造两个类。他们是 Employee 和 EmployeeTest。
首先打开记事本输入下列代码。记得这个是 Employee 类，这个类是公共类。现在以 Employee.java 为文件名保存这个源文件。
这个 Employee 类包括四个实体变量姓名（name），年龄（age），职位（designation）和薪水（salary）。这个类有一个确定的需要参数的的构造器。
import java.io.*; public class Employee{ String name; int age; String designation; double salary; // This is the constructor of the class Employee public Employee(String name){ this.name = name; } // Assign the age of the Employee to the variable age. public void empAge(int empAge){ age = empAge; } /* Assign the designation to the variable designation.*/ public void empDesignation(String empDesig){ designation = empDesig; } /* Assign the salary to the variable salary.*/ public void empSalary(double empSalary){ salary = empSalary; } /* Print the Employee details */ public void printEmployee(){ System.out.println("Name:"+ name ); System.out.println("Age:" + age ); System.out.println("Designation:" + designation ); System.out.println("Salary:" + salary); } }正如本指导之前所述，编程从主函数开始。因此，我们为了运行这个 Employee 类就应当建立主函数和类。我们将分别为这些任务创建类。
下面所给的是 EmployeeTest 类，这个类创建了两个 Employee 类的实例，并且为每个对象调用方法从而给每个变量赋值。
在 EmployeeTest.java 文件中保存下列代码
import java.io.*; public class EmployeeTest{ public static void main(String args[]){ /* Create two objects using constructor */ Employee empOne = new Employee("James Smith"); Employee empTwo = new Employee("Mary Anne"); // Invoking methods for each object created empOne.empAge(26); empOne.empDesignation("Senior Software Engineer"); empOne.empSalary(1000); empOne.printEmployee(); empTwo.empAge(21); empTwo.empDesignation("Software Engineer"); empTwo.empSalary(500); empTwo.printEmployee(); } }现在编译两个类然后运行 EmployeeTest，你将会看到如下结果：
C :> javac Employee.java C :> vi EmployeeTest.java C :> javac EmployeeTest.java C :> java EmployeeTest Name:James Smith Age:26 Designation:Senior Software Engineer Salary:1000.0 Name:Mary Anne Age:21 Designation:Software Engineer Salary:500.0
5. 基本数据类型
变量就是用来储存值而保留的内存位置。这就意味着当你创建一个变量时就会在内存中占用一定的空间。
基于变量的数据类型，操作系统会进行内存分配并且决定什么将被储存在保留内存中。因此，通过给变量分配不同的数据类型，你可以在这些变量中存储整数，小数或者字字母。
Java 中有两种有效地数据类型：
- 原始数据类型
- 引用数据类型
原始数据类型
Java 支持 8 种原始数据类型。原始数据类型是由该语言预先定义的并用关键词命名的。下面让我们深入学习一下这 8 种数据类型。
字节型（byte）
- 字节型是一种 8 位有正负的二进制整数
- 最小值是 -128(-2^7)
- 最大值是 127(2^7-1)
- 默认值为 0
- 字节型数据类型主要是为了在大型数组内节省空间，主要是替代整数由于字节型比整数小 4 倍。
- 例如：byte a = 100 , byte b = -50
- 短整数是一种 16 位有正负的二进制整数
- 最小值是 -32768(-2^15)
- 最大值是 32767(2^15-1)
- 短整数类型的数据也可以像字节型一样用于节省空间。短整数比整数小两倍
- 默认值为 0
- 例如：short s = 10000, short r = -20000
- 整数型是一种 32 位有正负的二进制整数
- 最小值是 - 2,147,483,648(-2^31)
- 最大值是 2,147,483,647(2^31 -1)
- 整数型一般默认被应用于整数值除非担心内存不够用。
- 默认值为 0
- 例如：int a = 100000, int b = -200000
- 长整型是一种 64 位有正负的二进制整数
- 最小值是 -9,223,372,036,854,775,808(-2^63)
- 最大值是 9,223,372,036,854,775,807 (2^63 -1)
- 这种数据类型一般是在需要比整数型范围更大时应用。
- 默认值为 0L
- 例如：long a = 100000L, int b = -200000L
- 浮点型数据是一种单精度的 32 位 IEEE 754 标准下的浮点数据。
- 浮点型数据主要是为了在大型浮点数字数组中节约内存。
- 默认值是 0.0f。
- 浮点型数据不能用于如货币这样的精确数据。
- 例如：float f1 = 234.5f
- 双精度型数据是一种双精度的 64 位 IEEE 754 标准下的浮点数据。
- 这种数据类型主要是默认被用于表示小数的值，一般是默认的选择。
- 双精度型数据不能用于如货币这样的精确数据。
- 默认值是 0.0d
- 例如：double d1 = 123.4
- 布尔型数据代表一个信息比特。
- 它只有两个可能的值：真（true）和假（false）
- 这种数据类型用于真假条件下的简单标记。
- 默认值是假（false）
- 例如：boolean one = true
- 字符型数据是简单的 16 位 Unicode 标准下的字符。
- 最小值是： '\u0000' (或 0)。
- 最大值是： '\uffff' (或 65,535 )。
- 字符型数据可以用来储存任意字母。
- 例如： char letter A（字符型的字母A） ='A'
- 引用数据类型是由类的编辑器定义的。他们是用于访问对象的。这些变量被定义为不可更改的特定类型。例如：Employee， Puppy 等等。
- 类对象和数组变量就是这种引用数据类型。
- 任何引用数据类型的默认值都为空。
- 一个引用数据类型可以被用于任何声明类型和兼容类型的对象。
- 例如：Animal animal = new Animal("giraffe")；
短整数（short）
整数型（int）
长整型（long）
浮点型（float）
双精度型（double）
布尔型（boolean）
字符型（char）
引用数据类型
Java 常量
常量是代表固定值的源代码。他们直接以代码的形式代表而没有任何估计。
常量可以被分配给任意的原始变量类型。例如：
byte a = 68; char a = 'A'字节型，整数型，长整型和短整型也可以由十进制，十六进制和八进制计数系统表示。
当用这些技术系统表示直接量时，前缀 0 是为了标明八进制，前缀 0x 是为了标明十六进制。例如：
int decimal = 100; int octal = 0144; int hexa = 0x64;Java 中的字符串型常量的规定和其他大多数语言一样，也是要写在双引号中间。字符串型直接量的例子如下：
"Hello World" "two\nlines" "\"This is in quotes\""字符和字符串型常量可以包含任意的 Unicode 字母。例如：
char a = '\u0001'; String a = "\u0001";Java 语言也支持一些特殊的转义序列的字符和字符串直接量。他们是：
|
转义字符 |
含义 |
|
\n |
换行 (0x0a) |
|
\r |
回车 (0x0d) |
|
\f |
换页 (0x0c) |
|
\b |
退格 (0x08) |
|
\s |
空格 (0x20) |
|
\t |
tab |
|
\" |
双引号 |
|
\' |
单引号 |
|
\ |
反斜杠 |
|
\ddd |
八进制字符 (ddd) |
|
\uxxxx |
十六进制 UNICODE 字符 (xxxx) |
6. 变量类型
变量可以给我们提供我们程序可以操纵的命名的存储。Java 中的每种变量都有特定的类型，这决定了变量的大小和它的设计占用内存空间；这一些列的值可以存储在那个内存空间中；变量可以应用的操作。
在使用前你必须现将所要使用的变量进行声明。声明变量的基本格式如下：
data type variable [ = value][, variable [= value] ...] ;这里的 data type 是 Java 的一种数据类型，variable 是一种变量的名称。要声明一个以上的特定变量类型，你可以采用逗号分隔开。
下面是 Java 中有效的变量声明和赋值的例子：
int a, b, c; // Declares three ints, a, b, and c. int a = 10, b = 10; // Example of initialization byte B = 22; // initializes a byte type variable B. double pi = 3.14159; // declares and assigns a value of PI. char a = 'a'; // the char variable a iis initialized with value 'a'本章将介绍 Java 中的各种可用的变量类型。Java 中共有三种变量：
- 本地变量
- 实例变量
- 类、静态变量
- 本地变量在方法、构造器或者块中声明
- 本地变量在方法、构造器或者块进入时被创建，一旦退出该变量就会被摧毁
- 可访问描述符不能用于本地变量
- 本地变量仅在已经声明的方法、构造器或者块中可见
- 本地变量在栈深度内部实施
- 本地变量没有默认值，因此本地变量必须被声明并且在第一次使用前要给它赋值
本地变量
例子
这里，age（年龄）是本地变量。这是在 pupAge() 方法下定义的，它的范围仅限于这个方法。
public class Test{ public void pupAge(){ int age = 0; age = age + 7; System.out.println("Puppy age is : " + age); } public static void main(String args[]){ Test test = new Test(); test.pupAge(); } }上述代码会输出如下结果：
Puppy age is: 7例子
下面的例子使用了本地变量 age 但是没有进行初始化，所以在编辑是就会显示错误。
public class Test{ public void pupAge(){ int age; age = age + 7; System.out.println("Puppy age is : " + age); } public static void main(String args[]){ Test test = new Test(); test.pupAge(); } }编辑时会产生如下错误：
Test.java:4:variable number might not have been initialized age = age + 7; ^ 1 error实例变量
- 实例变量在类中声明，但是它在方法、构造器或者块外。
- 当堆中的对象被分配了一个空间时，每个实例变量的位置就被创建了。
- 当对象采用关键字“ new ”创建时实例变量就被创建了，当对象被销毁时它也就被销毁了。
- 实例变量的值必须被一个以上的方法、构造器或者块，或者类中必须出现的对象的状态的重要部分所引用。
- 实例变量可以在类水平上在使用前或者使用后声明。
- 实例变量可以用可访问描述符。
- 实例变量对类中的所有方法、构造器或者块可见。一般来讲，推荐将这些变量私有（访问层面）。然而子类的可见性可用可访问描述符给予那些变量。
- 实例变量有默认值。数字的默认值为零，布尔型默认值为假，对象引用默认值为空。在声明或者构造器内可以进行赋值。
- 实例变量可以采用直接在类中叫名字方式访问。然而在静态方法和不同的类（实例变量可以被访问）中应当使用完全限定名称。ObjectReference.VariableName
例子
import java.io.*; public class Employee{ // this instance variable is visible for any child class. public String name; // salary variable is visible in Employee class only. private double salary; // The name variable is assigned in the constructor. public Employee (String empName){ name = empName; } // The salary variable is assigned a value. public void setSalary(double empSal){ salary = empSal; } // This method prints the employee details. public void printEmp(){ System.out.println("name : " + name ); System.out.println("salary :" + salary); } public static void main(String args[]){ Employee empOne = new Employee("Ransika"); empOne.setSalary(1000); empOne.printEmp(); } }上述代码会输出如下结果：
name : Ransika salary :1000.0类、静态变量
- 类变量也叫静态变量，它是在类中用 static 关键字声明的，但是它在方法、构造器或者块之外。
- 每个类中只有一个类变量，不管这个类有多少对象。
- 除了作为常量被声明之外，类变量很少被应用。常量是被作为 public、private, final 和 static 被声明的变量。实例变量的初始值不会被改变。
- 静态变量存储在静态内存中，很少采用静态变量而不是声明结束或者用常量public 或 private 之一。
- 静态变量随着程序的开始和结束而开始和结束。
- 可见性和实例变量相似。然而大多数静态变量被声明为public由于他们必须为类的使用者所用。
- 默认值和实例变量相似。对于数字的默认值为零，布尔型默认值为假，对象引用默认值为空。在声明或者构造器内可以进行赋值。除此之外，可以在特殊的静态初始化区赋值。
- 静态变量可以用类的名称访问。ClassName.VariableName
- 当静态变量被作为 public static final 声明时，变量（常量）名称都要用大写字母。如果静态变量不是 public 和 final，它的命名方法和实例变量和本地变量相同。
例子
import java.io.*; public class Employee{ // salary variable is a private static variable private static double salary; // DEPARTMENT is a constant public static final String DEPARTMENT = "Development "; public static void main(String args[]){ salary = 1000; System.out.println(DEPARTMENT+"average salary:"+salary); } }上述代码会输出如下结果：
Development average salary:1000注：如果变量从类外访问，常量就必须以 Employee.DEPARTMENT 访问。
7. 描述符的类型
描述符是你添加到那些定义中来改变他们的意思的关键词。Java 语言有很多描述符，包括以下这些：
- 可访问描述符
- 不可访问描述符
应用描述符，你可以在类、方法、变量中加入相应关键字。描述符要先于声明，如下面的例子所示（斜体）：
public class className { // ... } private boolean myFlag; static final double weeks = 9.5; protected static final int BOXWIDTH = 42; public static void main(String[] arguments) { // body of method }可访问描述符
Java 提供一系列可访问描述符来设定类，变量，方法和构造器的访问级别。四种访问级别如下：
- 默认的，对封装可见。不需要描述符。
- 仅对类可见（private）
- 全部可见（public）
- 对封装和子类可见（protected）
- Java 提供一些不可访问描述符来满足其他功能。
- Static 描述符是用来创造类方法和变量的。
- Final 描述符用来最终确定和实施类、方法和变量的。
- Abstract 描述符用来创造不允许实例化的类和方法。
- synchronized 和 volatile 描述符用来当做线的。
不可访问描述符
8. 基本运算符
Java 针对操控变量提供了一组丰富的运算符。我们可以将所有的 Java 运算符分为如下几组：
- 算数运算符
- 关系运算符
- 位运算符
- 逻辑运算符
- 赋值运算符
- 其他运算符
算数运算符
算术运算符在数学表达中的使用和它们在代数中的使用是相同的。下面的表格列举了算数运算符：
假设整体变量 A 有 10 个，变量 B 有 20 个，那么：
示例
|
运算符 |
描述 |
例子 |
|
+ |
加法 – 在运算符的另一端增加 |
A+B 为 30 |
|
- |
减法 – 将右侧的操作数从左侧的操作数中减去 |
A - B 为-10 |
|
* |
乘法 – 将运算符两端的值相乘 |
A * B 为200 |
|
/ |
除法 – 用右侧操作数除左侧操作数 |
B / A 为2 |
|
% |
系数 - 用右侧操作数除左侧操作数并返回馀数 |
B % A 为0 |
|
++ |
增量 – 给操作数的值增加1 |
B++ 为21 |
|
-- |
减量 – 给操作数的值减去1 |
B—为19 |
关系运算符
以下是 Java 语言可支持的关系运算符。
假设变量 A 有 10，变量 B 有 20，那么：
示例
|
运算符 |
描述 |
例子 |
|
== |
检查双方操作数的值是否相等，如果相等那么条件为真 |
(A == B) 不为真。 |
|
!= |
检查双方操作数的值是否相等，如果不相等那么条件为真 |
(A != B) 为真。 |
|
> |
检查左侧的操作数是否大于右侧的操作数，如果大于那么条件为真 |
(A > B) 不为真。 |
|
< |
检查左侧的操作数是否小于右侧的操作数，如果小于那么条件为真 |
(A < B) 为真。 |
|
>= |
检查左侧的操作数是够大于等于右侧的操作数，如果是那么条件为真 |
(A >= B) 不为真。 |
|
<= |
检查左侧的操作数是否小于等于右侧的操作数，如果是那么条件为真 |
(A <= B) 为真。 |
位运算符
Java 定义了几种运算符，这类运算符可被运用于整数型式，long, int，short，字符型和字节型。
位运算符作用于二进制系统间传输标准，并执行按位操作。假设如果 a 等于 60；b 等于 13；现在在二进制型式下它们就如下所示：
a = 0011 1100 b = 0000 1101 ----------------- a&b = 0000 1100 a|b = 0011 1101 a^b = 0011 0001 ~a = 1100 0011 以下表格列举了位运算符：
假设整数变量 A 有 60 个，B 有 13 个那么：
示例
|
运算符 |
描述 |
例子 |
|
& |
二进制AND运算符在结果上复制一位如果在双方操作数同时存在 |
(A & B) 为12，即 0000 1100 |
|
| |
二进制OR运算符在结果上复制一位如果在任何一个操作数上存在 |
(A | B) 为61，即0011 1101 |
|
^ |
二进制XOR 运算符复制位，如果它是设置在一个操作数上而不是两个。 |
(A ^ B) 为49， 即0011 0001 |
|
~ |
二进制补充运算符是一元的，b并有“翻转”位的影响 |
(~A ) 为 -61，由于是带符号的二进制数，那2的补位形式为1100 0011 |
|
<< |
二进制左移运算符。左侧操作数的值根据右侧操作数指定的位的数量移至左侧。 |
A << 2 为240 ，即1111 0000 |
|
>> |
二进制右移运算符。左侧操作数的值根据右侧操作数指定的位的数量移至右侧。 |
A >> 2 为 15即1111 |
|
>>> |
右移补零运算符。左侧操作数的值根据右侧操作数指定的位的数量移至右，并且转移的值用零补满。 |
A >>>2 为15 ，即0000 1111 |
逻辑运算符
下表格列举了逻辑运算符：
假设布尔数学体系变量 A 为真，B 为假，那么：
示例
|
运算符 |
描述 |
例子 |
|
&& |
称为逻辑与运算符。如果双方操作数都不为零，那么条件为真。 |
(A && B) 为真. |
|
|| |
称为逻辑或运算符. 如果双方操作数其中的任何一个都不为零，那么条件为真。 |
(A || B) 为真. |
|
! |
称为逻辑非运算符. 用作翻转操作数的逻辑状态。如果一个条件为真，那么逻辑非运算符为假。 |
!(A && B) 为真. |
赋值运算符
以下是由 Java 语言所支持的赋值运算符：
示例
|
运算符 |
描述 |
例子 |
|
|
= |
简单及运算符, 将右侧操作数的值赋给左侧操作数 |
C = A + B 会将 A + B 的值赋给 C |
|
|
+= |
增加及赋值运算符, 它将右侧的操作数增加到左侧的操作数并且结果赋给左侧操作数 |
C += A 同等于 C = C + A |
|
|
-= |
减去及赋值运算符，它将右侧操作数从左侧操作数中减去并将结果赋给左侧操作数 |
C -= A 同等于C = C - A |
|
|
*= |
乘以及赋值运算符，它将右侧操作数与左侧相乘并将结果赋给左侧操作数 |
C = A 同等于 C = C A |
|
|
/= |
除以及赋值运算符，它将右侧操作数除左侧操作数并将结果赋给左侧操作数 |
C /= A 同等于 C = C / A |
|
|
%= |
系数及赋值运算符 需要系数运用两个操作数并且将结果赋给左侧操作数 |
C %= A is 同等于 C = C % A |
|
|
<<= |
左移和赋值运算符 |
C <<= 2 同等于C = C << 2 |
|
|
>>= |
右移和赋值运算符 |
C >>= 2 同等于 C = C >> 2 |
|
|
&= |
按位和赋值运算符 |
C &= 2 同等于C = C & 2 |
|
|
^= |
按位异或及赋值运算符 |
C ^= 2 同等于 C = C ^ 2 |
|
|
|= |
按位可兼或及赋值运算符 |
C |= 2 同等于C = C |
2 |
其它运算符
以下是由 Java 语言所支持的一些其他的运算符：
条件运算符（？：）
条件运算符同样也被称作为三元运算符。这种运算符由三个操作数组成，被用作评估布尔数学体系表达。这种运算符的目的是来决定哪些值应被赋予到变量上。这个运算符被写作如下：
variable x = (expression) ? value if true : value if false 以下是示例：
public class Test { public static void main(String args[]){ int a , b; a = 10; b = (a == 1) ? 20: 30; System.out.println( "Value of b is : " + b ); b = (a == 10) ? 20: 30; System.out.println( "Value of b is : " + b ); } }这样就会有如下结果：
Value of b is : 30 Value of b is : 20Instanceof 符
这种操作符只用于对象引用变量。这种操作符检查对象是否是独特类型（类型或接口类型）。Instanceof 运算符写为：
( Object reference variable ) instanceof (class/interface type)如果在运算符左侧的由变量所指代的对象为右侧的类型或接口类型通过 IS-A 检查，那么结果为真。以下是示例：
public class Test { public static void main(String args[]){ String name = "James"; // following will return true since name is type of String boolean result = name instanceof String; System.out.println( result ); } }这就会产出如下结果：
true这种运算符仍会返回到真如果被比较的对象是与右边类型兼容的赋值。以下是另一个例子：
class Vehicle {} public class Car extends Vehicle { public static void main(String args[]){ Vehicle a = new Car(); boolean result = a instanceof Car; System.out.println( result ); } }这样将会产生以下的结果：
trueJava 运算符的优先级
运算符优先级决定一个表达式里术语的分组。它影响着一个表达式如何求值。一定的运算符比其他运算符拥有更高的优先级；例如：乘法运算符比加法运算符有更高的优先级：
例如，x=7+3 2; 这里x 被赋值为13，不是20，是因为运算符 比运算符+由更高的优先级， 所以它首先运算乘法 3*2, 然后再加7。
这里，有着最高优先级的运算符在这个表格的最高一层，最低优先权的则出现在最底部。在一个表达式中，越高等级的优先权的运算符会最先被求值。
|
类 |
运算符 |
关联性 |
|
后缀 |
() [] . (dot operator) |
从左到右 |
|
一元 |
++ - - ! ~ |
从右到左 |
|
乘法的 |
* / % |
从左到右 |
|
加法的 |
+ - |
从左到右 |
|
移位 |
>> >>> << |
从左到右 |
|
关系的 |
> >= < <= |
从左到右 |
|
相等 |
== != |
从左到右 |
|
位与 |
& |
从左到右 |
|
位异或 |
^ |
从左到右 |
|
位或 |
| |
从左到右 |
|
逻辑与 |
&& |
从左到右 |
|
逻辑或 |
|| |
从左到右 |
|
有条件的 |
?: |
从右到左 |
|
赋值 |
= += -= *= /= %= >>= <<= &= ^== |
从右到左 |
|
逗号 |
, |
从左到右 |
9. 循环控制
可能存在一种情况，当我们需要执行的代码块数次，通常被称为一个循环。
Java有非常灵活的三循环机制。可以使用以下三种循环之一：
- while 循环
- do...while 循环
- for 循环
截至Java5，对增强的for循环进行了介绍。这主要是用于数组。
while 循环
while循环是一个控制结构，可以重复的特定任务次数。
语法
while循环的语法是：
while(Boolean_expression) { //Statements }在执行时，如果布尔表达式的结果为真，则循环中的动作将被执行。只要该表达式的结果为真，执行将继续下去。
在这里，while循环的关键点是循环可能不会永远运行。当表达式进行测试，结果为假，循环体将被跳过，在while循环之后的第一个语句将被执行。
示例
public class Test { public static void main(String args[]) { int x = 10; while( x < 20 ) { System.out.print("value of x : " + x ); x++; System.out.print("\n"); } } }这将产生以下结果:
value of x : 10 value of x : 11 value of x : 12 value of x : 13 value of x : 14 value of x : 15 value of x : 16 value of x : 17 value of x : 18 value of x : 19do...while 循环
do ... while循环类似于while循环，不同的是一个do ... while循环是保证至少执行一次。
语法
do...while循环的语法是：
do { //Statements } while (Boolean_expression);请注意，布尔表达式出现在循环的结尾，所以在循环中的语句执行前一次布尔测试。
如果布尔表达式为真，控制流跳回，并且在循环中的语句再次执行。这个过程反复进行，直到布尔表达式为假。
示例
public class Test { public static void main(String args[]){ int x = 10; do{ System.out.print("value of x : " + x ); x++; System.out.print("\n"); }while( x < 20 ); } }这将产生以下结果:
value of x : 10 value of x : 11 value of x : 12 value of x : 13 value of x : 14 value of x : 15 value of x : 16 value of x : 17 value of x : 18 value of x : 19for 循环
for循环是一个循环控制结构，可以有效地编写需要执行的特定次数的循环。
知道一个任务要重复多少次的时候，for循环是有好处的。
语法
for循环的语法是：
for(initialization; Boolean_expression; update) { //Statements }下面是一个for循环的控制流程：
- 初始化步骤首先被执行，并且仅一次。这个步骤可声明和初始化任何循环控制变量。不需要把一个声明放在这里，只需要一个分号出现。
- 接下来，布尔表达式求值。如果是 true，则执行循环体。如果是false，则循环体不执行, 并且流程控制的跳转到经过for循环的下一个语句。
- 之后循环体在for循环执行时，控制流程跳转备份到更新语句。该语句允许更新任何循环控制变量。这个语句可以留空，只要一个分号出现在布尔表达式之后。
- 布尔表达式现在再次评估计算。如果是true，循环执行，并重复这个过程（循环体，然后更新的步骤，然后布尔表达式）。之后，布尔表达式为 false，则循环终止。
示例
public class Test { public static void main(String args[]) { for(int x = 10; x < 20; x = x+1) { System.out.print("value of x : " + x ); System.out.print("\n"); } } }这将产生以下结果:
value of x : 10 value of x : 11 value of x : 12 value of x : 13 value of x : 14 value of x : 15 value of x : 16 value of x : 17 value of x : 18 value of x : 19for 循环在 Java 中新特性
截至Java5，对增强的for循环进行了介绍。这主要是用于数组。
语法
增强的for循环的语法是：
for(declaration : expression) { //Statements }- 声明: 新声明块变量，这是一种与你所正在访问数组中的元素兼容的变量。该变量在for块内可被利用并且它的值作为当前的数组元素将是相同的。
- 表达: 这个计算结果完成需要循环数组。表达式可以是一个数组变量或返回一个数组的方法调用。
示例
public class Test { public static void main(String args[]){ int [] numbers = {10, 20, 30, 40, 50}; for(int x : numbers ){ System.out.print( x ); System.out.print(","); } System.out.print("\n"); String [] names ={"James", "Larry", "Tom", "Lacy"}; for( String name : names ) { System.out.print( name ); System.out.print(","); } } }这将产生以下结果:
10,20,30,40,50, James,Larry,Tom,Lacy,break 关键字
关键字break是用来停止整个循环的。 break关键字必须使用于任何循环中或一个switch语句中。
关键字break将停止最内层循环的执行，并开始执行在块之后的下一行代码。
语法
break语法是任何循环中一个单独的语句：
break 示例
public class Test { public static void main(String args[]) { int [] numbers = {10, 20, 30, 40, 50}; for(int x : numbers ) { if( x == 30 ) { break; } System.out.print( x ); System.out.print("\n"); } } }这将产生以下结果:
10 20continue 关键字
continue关键字可以在任一环的控制结构使用。它使循环立即跳转到循环的下一次迭代.
- 在for循环中，continue关键字会导致控制流立即跳转到更新语句。
- 在一个while循环或do/while循环，控制流立即跳转到布尔表达式。
语法
continue 语法是任何循环中一个单独的语句：
continue示例
public static void main(String args[]) { int [] numbers = {10, 20, 30, 40, 50}; for(int x : numbers ) { if( x == 30 ) { continue; } System.out.print( x ); System.out.print("\n"); } } }这将产生以下结果：
10 20 40 50
10. 条件判断
在 Java 中有两种类型的条件判断语句，它们分别是：
- if 语句
- switch 语句
if 语句:
if 语句由一个布尔表达式后跟一个或多个语句组成。
语法
if 语句的语法是：
if(Boolean_expression) { //Statements will execute if the Boolean expression is true }如果布尔表达式的值为 true，那么代码里面的块 if 语句将被执行。如果不是 true，在 if 语句（大括号后）结束后的第一套代码将被执行。
示例
public class Test { public static void main(String args[]){ int x = 10; if( x < 20 ){ System.out.print("This is if statement"); } } }这将产生以下结果：
This is if statementif...else 语句
任何 if 语句后面可以跟一个可选的 else 语句，当布尔表达式为 false，语句被执行。
语法
if...else 的语法是:
if(Boolean_expression){ //Executes when the Boolean expression is true }else{ //Executes when the Boolean expression is false }示例
public class Test { public static void main(String args[]){ int x = 30; if( x < 20 ){ System.out.print("This is if statement"); }else{ System.out.print("This is else statement"); } } }这将产生以下结果：
This is else statementif...else if...else 语句
if 后面可以跟一个可选的 else if...else 语句，在测试不同条件下单一的 if 语句和 else if 语句是非常有用的。
当使用 if , else if , else 语句时有几点要牢记。
- 一个 if 语句可以有0个或一个 else 语句 且它必须在 else if 语句的之后。
- 一个 if 语句 可以有0个或多个 else if 语句且它们必须在 else 语句之前。
- 一旦 else if 语句成功, 余下 else if 语句或 else 语句都不会被测试执行。
语法
if...else 的语法是:
if(Boolean_expression 1){ //Executes when the Boolean expression 1 is true }else if(Boolean_expression 2){ //Executes when the Boolean expression 2 is true }else if(Boolean_expression 3){ //Executes when the Boolean expression 3 is true }else { //Executes when the none of the above condition is true. }示例
public class Test { public static void main(String args[]){ int x = 30; if( x == 10 ){ System.out.print("Value of X is 10"); }else if( x == 20 ){ System.out.print("Value of X is 20"); }else if( x == 30 ){ System.out.print("Value of X is 30"); }else{ System.out.print("This is else statement"); } } }这将产生以下结果：
Value of X is 30嵌套 if...else 语句
它始终是合法的嵌套 if-else 语句，这意味着你可以在另一个 if 或 else if 语句中使用一个 if 或 else if 语句。
语法
嵌套 if...else 的语法如下：
if(Boolean_expression 1){ //Executes when the Boolean expression 1 is true if(Boolean_expression 2){ //Executes when the Boolean expression 2 is true } }因为我们有嵌套的 if 语句，所以可以用类似的方式嵌套 else if...else。
示例
public class Test { public static void main(String args[]){ int x = 30; int y = 10; if( x == 30 ){ if( y == 10 ){ System.out.print("X = 30 and Y = 10"); } } } }这将产生以下结果：
X = 30 and Y = 10switch 语句
switch 语句允许一个变量来对一系列值得相等性进行测试。每个值被称为一 case，并且被启动的变量会为每一个 case 检查。
语法
增强的 for 循环的语法是：
switch(expression){ case value : //Statements break; //optional case value : //Statements break; //optional //You can have any number of case statements. default : //Optional //Statements }以下规则适用于 switch 语句：
- 在 switch 语句中使用的变量只能是一个字节，short，int 或 char。
- 在一个 switch 语句中可以有任何数量的 case 语句。每个 case 后跟着即将被比较的值和一个冒号。
- 对于 case 的值必须是相同的数据类型作为开关变量，它必须是一个常量或文字。
- 当被启动了的变量与 case 是相等的，那 case 后的语句将执行，一直到 break 为止。
- 当达到一个 break 语句，switch 终止，并且控制流跳转到跟着 switch 语句的下一行。
- 不是每一个 case 需要包含一个 break。如果没有出现 break，控制流将贯穿到后面的 case 直到 break 为止。
- switch 语句可以有一个可选默认 case ，它必须出现在 switch 的结束处。在执行一项任务时没有任何 case 是真，那默认 case 可被使用。在默认 case 中不需要 break。
示例
public class Test { public static void main(String args[]){ //char grade = args[0].charAt(0); char grade = 'C'; switch(grade) { case 'A' : System.out.println("Excellent!"); break; case 'B' : case 'C' : System.out.println("Well done"); break; case 'D' : System.out.println("You passed"); case 'F' : System.out.println("Better try again"); break; default : System.out.println("Invalid grade"); } System.out.println("Your grade is " + grade); } }编译并运行上面使用各种命令行参数的程序。这将产生以下结果：
$ java Test Well done Your grade is a C $
