java语言指超文本标记语言 java的语言标识符

一、Java语言的基本组成

Java语言主要由5种元素组成：标识符、关键字、直接量、运算符和分隔符。这5种元素有着不同的语法含义和组成规则，他们互相配合、共同完成Java的语意表达。

1、标识符

变量以及后面将要讲到的类和方法都需要一定的名称，这种名称就叫做标识符。什么是一个有效的标识符呢？在Java中，所有的标识符都必须以一个字母、下划线或美元符号$开头。后面可以包括字母、数字、下划线和美元符号。

标识符是由用户自己规定的名称，可按上面的规则随意选取。不过，Java中有一个标识符命名约定：常量用大写字母，变量用小写字母开始，类以大写字母开始。如果一个变量名由多个单词构成，第一个单词后面的单词以大写字母开始，例如anInt。下划线虽然可以作为标识符的一员，但常用于变量名的单词分隔，因为常量名都是以大写字母单词命名的。

2、关键字

关键字是Java语言本身使用的标识符，它有着其特定的语法含义。所有的Java关键字将不能被用作标识符，如：for、while、boolean等都是Java语言的关键字。关键字用英文小写字母表示，下图为一些常见的Java关键字。

3、分隔符

分隔符是用来区分源程序中的基本成分，可使编译器确认代码在何处分割。分隔符有注释、空白符和普通分隔符三种。

（1）、注释

注释是程序员为了提高程序的可读性和可理解性，在源程序的开始或中间对程序的功能、坐着、使用方法等所写的注释。注释仅用于阅读源程序，系统编译程序时，忽略其中的所有注释。注释有两种类型：
①、注释一行，以『//』开始，最后以回车结束。一般作单行注释使用，也可放在某个语句的后面。
②、一行或多行注释，以『/』开始，最后以『/』结束，中间可写多行。

（2）、空白符

空白符包括空格、回车、换行和制表符（Tab健）等符号，用来作为程序中各种基本成分之间的分隔符。各基本成分之间可以有一个或多个空白符，其作用相同。和注释一样，系统编译程序时，只用空白符区分各种基本成分，然后忽略它。

（3）、普通分隔符

普通分隔符和空白符的作用相同，用来区分程序中的各种基本成分，但它在程序中有确定的含义，不能忽略。Java有4种普通分隔符：
①、{}大括号，用来定义复合语句、方法体、类体及数组的初始化；
②、;分号，是语句结束的标识；
③、，逗号，分割方法的参数和变量说明等；
④、:冒号，说明语句标号；
例如：标识符、关键字和分隔符的使用

public class Example {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int i,c;
    }
}

程序说明：class是关键字，用来定义类，public说明这个类是公有的。Example是标识符，用来说明类的名称。为了与类的其他成员区别，一般将类名的第一个字母大写。
第一行末尾与最后一行是一对大括号，括号中为类体。类体中定义了类的成员：属性和方法，并且指明成员的访问权限，本例中，只定义了一个方法main。
第二行public static void为关键字，说明方法main是公有的（public），是类的静态成员（static），无返回值（void）。需要注意的是，Java Application中的main方法声明必须采用这种方式，括号里的内容是参数定义，String是字符串类名，args是数组名。
方法体中的int是关键字，说明i与c是整型变量。

二、数据类型

数据类型说明了常量、变量或表达式的性质。Java的数据类型可分为：

• 基本类型 包括整型、浮点型、布尔型和字符型；
• 数组类型 包括一维数组和多维数组；
• 复合类型 包括类、接口；

1、基本数据类型

2、直接量

直接量（literal）是指在程序中直接给出的一个符号串，作用是为变量赋值或参与表达式运算。直接量可以是一个具体的数值或字符串，也称常量。但Java中的常量另有所指，是用final说明一个标识符。在很多教科书中往往不加区分地统称为常量。讲一个标识符说明为常量，然后赋予它一个直接量，就在二者时间划上等号。直接量或常量在程序执行过程中是不可以更改的，它们的区别是不占用内存的。

（1）、布尔常量

布尔常量只有两个值true和false，代表了两种状态：真和假，书写时直接使用这两个单词，不能加引号。

（2）、整型常量

整型常量是不含小数的整型值，书写时可采用十进制、十六进制和八进制形式。十进制常量以非0开头，八进制常量以0开头，十六进制则以0X开头。下面是三条赋值语句：

int i = 15;
int j = 017;
int k = 0xF;

赋值后，三个变量相等，值的大小都是十进制的15。整型常量默认为32位的int型，如果在数值后边加上L或l，则表示为64位的长整型。

（3）、浮点型常量

Java的浮点型常量有两种表示形式：
①、十进制数形式，由小数点组成，且必须有小数点，如.123，0.123，123.0；
②、科学计算法形式，如123e3或123E-3，其中E或e之前必须有数，且e或E后面的指数必须为整数。
对于一个浮点数，加上f或者F后缀，就是单精度浮点数；加上d或者D后缀，就是双精度浮点数。不加后缀的浮点数被默认为双精度浮点数，双精度浮点数在计算机中占64位，有很高的精度。

（4）、字符常量

字符常量是由一对单引号括起来的单个字符。它可以是Unicode字符集中的任意一个自负，如：’a’，’Z’。对于无法通过键盘输入的自负，可用转义字符号表示，见下图：

字符常量的另外一种表示就是直接写出字符编码，如字母A的八进制表示为’\101’，十六进制表示为’\u0041’。

（5）、字符串常量

字符串常量是用一对双引号括起来的字符序列。当字符串只包含一个字符时，不要把它和字符常量混淆，例如’A’是字符常量，而”A”是字符串常量
。字符串常量中可包含转移字符，例如”Hello\n world!”在中间加入了一个换行符，输出时，这两个单词将显示在两行上。

3、变量

变量是内存中的一块空间，提供了可以存放信息和数据的地方，具有记忆数据的功能。变量是可以改变的，它可以存放不同类型的数据，通常用字母或单词作为变量名。

（1）、变量的声明

在Java中存储一个数据，必须将它保存到一个变量中。变量在使用前必须有定义，即有确定的类型和名称。声明变量的语句如下：

类型 变量名[,变量名] [= 初值]；

该语句告诉编译器以给定的数据类型的变量名建立一个变量。可以一次声明多个变量，并同时赋初值。例如：

byte b1,b2;
int v1=0,v2=10,v3=18;

上面的两条语句声明了2个字节型变量b1、b2，3个整型变量v1，v2，v3，分别赋值0、10和18.
例如：

public class Example {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        byte b=0x55;
        short s=0x55ff;
        int i=1000000;
        long l=0xffffl;
        char c='c';
        float f=0.23F;
        double d=0.7E-3;
        boolean B=true;
        String S ="This is a string";
        System.out.println("字节型变量b="+b);
        System.out.println("短整型变量s="+s);
        System.out.println("整型变量i="+i);
        System.out.println("长整型变量l="+l);
        System.out.println("字符型变量c="+c);
        System.out.println("浮点型变量f="+f);
        System.out.println("双精度变量d="+d);
        System.out.println("布尔型变量B="+B);
        System.out.println("字符串对象S="+S);
    }
}

打印：

字节型变量b=85
短整型变量s=22015
整型变量i=1000000
长整型变量l=65535
字符型变量c=c
浮点型变量f=0.23
双精度变量d=7.0E-4
布尔型变量B=true
字符串对象S=This is a string

（2）、变量的使用范围

当你声明一个变量后，它将被引入到一个范围当中。也就是说，该变量只能在程序的特定范围内使用，除了这个范围，变量就消失了。
在类中声明的变量就是成员变量，通常在类的开始处声明。在方法和块中声明的变量叫局部变量，使用范围是从它被声明的地方到它所在那个块的结束出，块是由两个大括号所定义的。

public class Example {
    int i;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int j;
        if (true) {
            int k = 10;
        }
    }
    System.out.println("k="+k);//编译时将出错，已出k使用范围
}

k在一个块中声明，在这个块之外它是不存在的，所以编译时会出错。

（3）、变量的类型转换

系统方法System.in.read返回一个整形数值，但你却尝尝想要把它当作一个字符来使用。现在的问题是，当有一个整数而你需要把它变成一个字符时应该做些什么呢？你需要去做的是讲一个整数类型转换为一个字符型。变量类型的转换可采用在表达式前加上类型转换的方式实现：(类型)表达式。例如：

int a;
char b;
b='A';
a=(int)b;
System.out.println("a="+a);

上面的语句表示a为整型，b为字符型，(int)告诉编译器你想把字符型的b编程整型把它放在变量a里。

记住整型和字符型变量位长的不同是非常重要的，整型是32位，而字符型是16位，所以从整型转换到字符型可能会丢失信息。

同样，当你把64位的长整型数转换为整型数时，由于长整型有比32位更多的信息，也很可能丢失信息。即使两个数有相同的位数，比如整型和浮点型（都是32位），从浮点型转换为整型时也会丢失信息。

Java不允许自动类型转换，当你进行类型转换时，要主要使目标类型能够容纳原类型的所有信息。

3、运算符和表达式

Java的运算符代表着特定的运算指令，程序运行时将堆运算符连接的操作数进行相应的运算。运算符和操作数的组合形成了表达式，表达式代表着一个确定的量。表达式上总是先计算后使用，因此，不算一个表达式有多么的复杂，其最终结果仍是一个有确定类型和大小的量。

按照运算符功能来分，运算符有7种：赋值运算符、算术运算符、关系运算符、条件运算符、逻辑运算符、位运算符和其他运算符。

按照连接操作数的多少来分，有一元运算符、二元运算符和三元运算符。另外，算术运算符和赋值运算符可以结合在一起形成算术赋值运算符。

（1）、赋值运算符

由赋值运算符构成的表达式称为赋值表达式。赋值运算符的右边是一个表达式，这个表达式还可以包含一个表达式。例如a=b=c=0，相当于三个表达式c=0，b=c，a=b。

（2）、算术运算符

算术运算符按操作数的多少可分为一元运算符和二元运算符，一元运算符一次对一个操作数进行运算，二元运算符一次对两个操作数进行运算。对于表达式的运算来说，如果有一个变量或操作数是长整型的，那么结果就肯定是长整型的，否则即使操作数还没有确定是字节型、短整型或字符型，运算结果都是整型。浮点型和双精度型的情况是类似的。

（3）、关系运算符

关系运算符用于两个操作数之间关系的比较。关系表达式的运算结果为布尔值，不是true就是false，操作数可以是常量、变量和表达式。关系表达式常常用作分支结构或循环结构的控制条件。

（4）、条件运算符

条件运算符有一个『?』和一个『:』，条件运算符和上面的运算符略有不同，是三元运算符。条件表达式结构为：

（条件）?结果1:结果2;

条件表达式的计算过称为：首先计算作为条件的逻辑表达式或关系表达式，返回值为true时表达式的值为结果1，返回值为false时表达式的值为结果2。
条件表达式可取代简单的二分支结果，书写简单，并有较快的运算速度。例如：

int a=5,b=2,result;
if (a>b) {
    result=a-b;
}else {
    result=b-a;
}

其中的分支结构可改写为

result=a>b?a-b:b-a;

（5）、逻辑运算符

逻辑表达式通常由多个关系表达式构成，最终运算结果为布尔值true或false。

①、『&&』连接的两个表达式中，只要有一个不为真，则整个表达式就为假。运算时只要判断左边的表达式为假，就可立即得出结论，不再计算右边表达式。所以，最有可能取假值的表达式尽量放在左边，这样可提高表达式的运算速度；

②、『&』在表达式判定上和『&&』相同，唯一不同的是它总是计算两边表达式的值；

③、『||』连接的两个表达式中，只要有一个为真，则整个表达式就为真。运算时只要判定左边表达式为真，就可立即得出结论，不再计算右边表达式。所以，最有可能取真值的表达式尽量放在左边，以提高表达式的运算速度；

④、『|』在表达式判定上和『||』相同，不同之处是它总是计算两边表达式的值；

⑤、『^』连接的两个表达式同为真或同为假时，整个表达式为假，其他情况下取真值。

（6）、位运算符

（7）、其他运算符

（8）、运算符的优先级

4、数组

数组是由于数据的集合，数组中的每个元素具有相同的数组名，根据数组名和下标来唯一地确定数组中的元素。数组有一维数组和多维数组，使用时要先声明后创建。

（1）、一维数组的声明

数组是Java语言中的特殊数据类型，它们保存着能通过下标索引来引用的一组同类数据，一维数组是指一个线性数据序列，声明方式为：
数据类型 数组名[];或 数据类型[] 数组名;
例如：

int arr1[];
char[] arr2;

声明了两个数组，arr1是整型数组，arr2是字符型数组
说明：其中『数组类型』可以是Java中任意的数组类型，『数组名』为一个合法的标识符，”[]”指明该变量是一个数组类型变量并且是一维的。

Java在数组的定义中并不为数组元素分配内存，因此”[]”中不用指出数组中元素的个数即数组长度，而且对于如上定义的一个数组暂时还不能访问它的任何元素。

（2）、一维数组的创建与赋值

定义数组后，还必须为数组分配内存、初始化。这有两个方法。
①、、用运算符new分配内存再赋值
命令格式如下：

数组名=new 数据类型[size]；

其中size指明数组的长度，如：

int intArr[]=new int[3];
char chArr[]=new char[5];

上述语句将数组的声明和创建放在一起，第一条语句声明了一个整型数组并分配了3个整型主句所占据的内存空间，顺序为intArr[0]，intArr[1]，intArr[2]。注意下标是从第一个元素的0开始，到数组长度减1.第二条语句声明并分配了5个char型变量所占据的内存空间。
数组元素赋值的方法与变量相同，如：

intArr[0]=10;
intArr[1]=15;
intArr[2]=20;

②、直接赋初值并定义数组的大小
第二种方法是直接赋值并定义数组的大小。初值必须用大括号括起来，用逗号作分隔符，初值的个数表示数组的大小。例如：

int a[]={1,2,3,4,5,6,7,8,9,10};
char c[]={'a','b','c','d'};

举例：一维数组的使用。该程序堆数组中的每个元素赋值，然后按逆序输出

public class Example {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int i;
        int a[]=new int[5];
        for (i = 0;  i<5; i++) {
            a[i]=i;
        }
        for (i = a.length - 1; i >= 0; i--) {
            System.out.println("a["+i+"]="+a[i]);
        }
    }
}

说明：数组作为Array类的实例，继承了Array类的属性和方法，求数组长度时可引用Array的length属性；

3、多维数组

与C++一样，Java将多维数组看做数组的数组。例如二维数组就是一个特殊的一维数组，它的每个元素是一个一维数组。
举例：二维数组的使用。该程序对二维数组中的每个元素赋值，然后输出，程序运行结果：

public class Example {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] arr1 = new int[3][4];
        int arr2[][] = new int[3][];
        int k = 0;
        for(int i = 0;i < 3; i++){//arr1为3行4列
            for(int j = 0; j < 4;j++){
                arr1[i][j] = k++;
                System.out.println("arr1["+i+"]["+j+"]="+arr1[i][j]);
            }
        }
        for(int i = 0;i < 3;i++){//arr2每一行是变长的，元素个数为3、4、5
            arr2[i] = new int[i + 3];
        }
        for(int i = 0;i < 3;i++){
            for(int j = 0;j < arr2[i].length;j++){
                arr2[i][j] = k ++;
                System.out.println("arr2["+i+"]["+j+"]="+arr2[i][j]);
            }
        }
    }
}