《【Java 简介】
Java是由Sun Microsystems公司于1995年5月推出的Java面向对象程序设计语言和Java平台的总称。由James Gosling和同事们共同研发，并在1995年正式推出。
Java分为三个体系：
JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版）
JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版)
JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)。
2005年6月，JavaOne大会召开，SUN公司公开Java SE 6。此时，Java的各种版本已经更名以取消其中的数字"2"：J2EE更名为Java EE, J2SE更名为Java SE，J2ME更名为Java ME。
主要特性
Java语言是简单的：
Java语言的语法与C语言和C++语言很接近，使得大多数程序员很容易学习和使用。另一方面，Java丢弃了C++中很少使用的、很难理解的、令人迷惑的那些特性，如操作符重载、多继承、自动的强制类型转换。特别地，Java语言不使用指针，而是引用。并提供了自动的废料收集，使得程序员不必为内存管理而担忧。
Java语言是面向对象的：
Java语言提供类、接口和继承等面向对象的特性，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。Java语言全面支持动态绑定，而C++语言只对虚函数使用动态绑定。总之，Java语言是一个纯的面向对象程序设计语言。
Java语言是分布式的：
Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI（远程方法激活）机制也是开发分布式应用的重要手段。
Java语言是健壮的：
Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。Java的安全检查机制使得Java更具健壮性。
Java语言是安全的：
Java通常被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击。除了Java语言具有的许多安全特性以外，Java对通过网络下载的类具有一个安全防范机制（类ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查，并提供安全管理机制（类SecurityManager）让Java应用设置安全哨兵。
Java语言是体系结构中立的：
Java程序（后缀为java的文件）在Java平台上被编译为体系结构中立的字节码格式（后缀为class的文件），然后可以在实现这个Java平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发。
Java语言是可移植的：
这种可移植性来源于体系结构中立性，另外，Java还严格规定了各个基本数据类型的长度。Java系统本身也具有很强的可移植性，Java编译器是用Java实现的，Java的运行环境是用ANSI C实现的。
Java语言是解释型的：
如前所述，Java程序在Java平台上被编译为字节码格式，然后可以在实现这个Java平台的任何系统中运行。在运行时，Java平台中的Java解释器对这些字节码进行解释执行，执行过程中需要的类在联接阶段被载入到运行环境中。
Java是高性能的：
与那些解释型的高级脚本语言相比，Java的确是高性能的。事实上，Java的运行速度随着JIT(Just-In-Time）编译器技术的发展越来越接近于C++。
Java语言是多线程的：
在Java语言中，线程是一种特殊的对象，它必须由Thread类或其子（孙）类来创建。通常有两种方法来创建线程：其一，使用型构为Thread(Runnable)的构造子将一个实现了Runnable接口的对象包装成一个线程，其二，从Thread类派生出子类并重写run方法，使用该子类创建的对象即为线程。值得注意的是Thread类已经实现了Runnable接口，因此，任何一个线程均有它的run方法，而run方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。Java语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为synchronized）。
Java语言是动态的：
Java语言的设计目标之一是适应于动态变化的环境。Java程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类。这也有利于软件的升级。另外，Java中的类有一个运行时刻的表示，能进行运行时刻的类型检查。
发展历史
1995年5月23日，Java语言诞生
1996年1月，第一个JDK-JDK1.0诞生
1996年4月，10个最主要的操作系统供应商申明将在其产品中嵌入JAVA技术
1996年9月，约8.3万个网页应用了JAVA技术来制作
1997年2月18日，JDK1.1发布
1997年4月2日，JavaOne会议召开，参与者逾一万人，创当时全球同类会议规模之纪录
1997年9月，JavaDeveloperConnection社区成员超过十万
1998年2月，JDK1.1被下载超过2,000,000次
1998年12月8日，JAVA2企业平台J2EE发布
1999年6月，SUN公司发布Java的三个版本：标准版（JavaSE,以前是J2SE）、企业版（JavaEE以前是J2EE）和微型版（JavaME，以前是J2ME）
2000年5月8日，JDK1.3发布
2000年5月29日，JDK1.4发布
2001年6月5日，NOKIA宣布，到2003年将出售1亿部支持Java的手机
2001年9月24日，J2EE1.3发布
2002年2月26日，J2SE1.4发布，自此Java的计算能力有了大幅提升
2004年9月30日18:00PM，J2SE1.5发布，成为Java语言发展史上的又一里程碑。为了表示该版本的重要性，J2SE1.5更名为Java SE 5.0
2005年6月，JavaOne大会召开，SUN公司公开Java SE 6。此时，Java的各种版本已经更名，以取消其中的数字"2"：J2EE更名为Java EE，J2SE更名为Java SE，J2ME更名为Java ME
2006年12月，SUN公司发布JRE6.0
2009年04月20日，甲骨文74亿美元收购Sun。取得java的版权。
2010年11月，由于甲骨文对于Java社区的不友善，因此Apache扬言将退出JCP[4]。
2011年7月28日，甲骨文发布java7.0的正式版。
2014年3月18日，Oracle公司发表Java SE 8。
Java开发工具
Java语言尽量保证系统内存在1G以上，其他工具如下所示：
Linux 系统、Mac OS 系统、Windows 95/98/2000/XP，WIN 7/8系统。
Java JDK 7、8……
Notepad 编辑器或者其他编辑器。
IDE：Eclipse
安装好以上的工具后，我们就可以输出Java的第一个程序"Hello World！"
public class HelloWorld {
public static void main(String []args) {
System.out.println("Hello World");
}
}
在下一章节我们将介绍如何配置java开发环境。
【Java环境设置】
Java 环境设置
本地环境设置
如果你依然想要为 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.htmlEclipse：这是一款由 eclipse 开源社区开发的 Java 编辑器。你可以从以下链接下载
http://www.eclipse.org/【Java 基本语法】
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 语言中，接口可以定义为对象之间如何通信的合同。就继承性而言接口扮演了重要角色。
接口定义了子类所需要用的方法。但是方法的实施还是取决于子类。
【Java 的对象和类】
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.0
【Java 基本数据类型】
变量就是用来储存值而保留的内存位置。这就意味着当你创建一个变量时就会在内存中占用一定的空间。
基于变量的数据类型，操作系统会进行内存分配并且决定什么将被储存在保留内存中。因此，通过给变量分配不同的数据类型，你可以在这些变量中存储整数，小数或者字字母。
Java 中有两种有效地数据类型：
原始数据类型
引用数据类型
原始数据类型
Java 支持 8 种原始数据类型。原始数据类型是由该语言预先定义的并用关键词命名的。下面让我们深入学习一下这 8 种数据类型。
字节型（byte）
字节型是一种 8 位有正负的二进制整数
最小值是 -128(-2^7)
最大值是 127(2^7-1)
默认值为 0
字节型数据类型主要是为了在大型数组内节省空间，主要是替代整数由于字节型比整数小 4 倍。
例如：byte a = 100 , byte b = -50
短整数（short）
短整数是一种 16 位有正负的二进制整数
最小值是 -32768(-2^15)
最大值是 32767(2^15-1)
短整数类型的数据也可以像字节型一样用于节省空间。短整数比整数小两倍
默认值为 0
例如：short s = 10000, short r = -20000
整数型（int）
整数型是一种 32 位有正负的二进制整数
最小值是 - 2,147,483,648(-2^31)
最大值是 2,147,483,647(2^31 -1)
整数型一般默认被应用于整数值除非担心内存不够用。
默认值为 0
例如：int a = 100000, int b = -200000
长整型（long）
长整型是一种 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
浮点型（float）
浮点型数据是一种单精度的 32 位 IEEE 754 标准下的浮点数据。
浮点型数据主要是为了在大型浮点数字数组中节约内存。
默认值是 0.0f。
浮点型数据不能用于如货币这样的精确数据。
例如：float f1 = 234.5f
双精度型（double）
双精度型数据是一种双精度的 64 位 IEEE 754 标准下的浮点数据。
这种数据类型主要是默认被用于表示小数的值，一般是默认的选择。
双精度型数据不能用于如货币这样的精确数据。
默认值是 0.0d
例如：double d1 = 123.4
布尔型（boolean）
布尔型数据代表一个信息比特。
它只有两个可能的值：真（true）和假（false）
这种数据类型用于真假条件下的简单标记。
默认值是假（false）
例如：boolean one = true
字符型（char）
字符型数据是简单的 16 位 Unicode 标准下的字符。
最小值是： '\u0000' (或 0)。
最大值是： '\uffff' (或 65,535 )。
字符型数据可以用来储存任意字母。
例如： char letter A（字符型的字母A） ='A'
引用数据类型
引用数据类型是由类的编辑器定义的。他们是用于访问对象的。这些变量被定义为不可更改的特定类型。例如：Employee， Puppy 等等。
类对象和数组变量就是这种引用数据类型。
任何引用数据类型的默认值都为空。
一个引用数据类型可以被用于任何声明类型和兼容类型的对象。
例如：Animal animal = new Animal("giraffe")；
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)
【Java 变量类型】
变量可以给我们提供我们程序可以操纵的命名的存储。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 访问。
【Java 描述符的类型】
描述符是你添加到那些定义中来改变他们的意思的关键词。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 描述符用来当做线的。
接下来是什么呢？
在下一节，我们将讨论基本的 Java 运算符。这一章将会给你一个在开发应用程序时如何运用这些运算符的概述。
》