02.变量和运算符

一.单元概述
高级程序设计语言中一般都允许程序员使用标识符来命名程序中用到的语法单位，Java语言也有自己的命名规则。本章首先介绍Java语言中的基本数据类型、变量的命名规则、数据类型间的转换原则以及运算符的使用。通过本章的学习应该能够了解Java语言的基本语法，掌握基本语句的编写，为后续的程序编写奠定坚实的基础。
二、重点与难点
重点：

1. 数据类型
2. 数据类型的转换
3. 变量
4. 运算符

难点：

1. 数据类型的转换

2. 移位运算符

   2.1 Java程序结构

   程序是由程序块组成的，程序块的标志是”{}”，程序块是由下图中的变量、数据类型、运算符和控制语句共同组成的，如下图2.1所示。
   
   图2.1 Java块
   其中数据类型确定要存储在内存中的数据的类型；变量是存储数据的基本单元；运算符是一个符号，用于操作一个或多个参数以得出结果；程序是按顺序执行的，控制流语句允许改变此顺序。

   2.2 标识符、关键字和保留字

   2.2.1 标识符

   在Java语言中，通过标识符来表示一些元素的名字，比如变量名、类名、方法名和包名等。Java中的标识符要符合下面的规则：

3. 标识符必须以字母、下划线（_）、数字或美元（$）组成；

4. 标识符必须由字母、下划线（_）或美元（$）开头，不能由数字开头；
5. 标识符不能是关键字或者保留字；
6. 标识符中不能有空格;
7. 标识符没有长度限制。

   例如，A_123，$abc，length都是合法的标识符，而1a，s+g就是非法的标识符，各种不同的元素命名规则如下图2.2所示。

图2.2 Java块

提示：

1. Java区分大小写，因此area和Area是两个不同的标识符；
2. 为提高程序的可读性，建议使用有意义的命名标识符，如area，length等。

   2.2.2 关键字和保留字

   下表是Java中的关键字和保留字，关键字是对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等；保留字是为Java预留的关键字，虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字，关键字和保留字如下表2.1所示。
   表2.1 关键字和保留字

练习2.1 判断下列哪些是合法的标识符：
identifier 、userName 、class 、98.3 、Data#
user_name 、_sys_var1 、$change 、blue bird
按照标识符的命名规则进行判断，可以得出合法标识符为：
identifier 、userName、Data#、user_name 、_sys_var1 、$change

2.3 变量

变量（variable）是用来存储数据的一块存储区域，在程序运行中它的值可以发生变化。变量可以存放一种数据类型的值，Java程序在运行加载时会根据变量的不同数据类型来分配不同的内存空间，变量的数据类型在声明时指定。
变量是指在程序的运行过程中随时可以发生变化的量，作用是：
1．变量是程序中数据的临时存放场所
2．保存程序运行时用户输入的数据
3．特定的运算结果等

2.3.1 变量的声明

一个变量只有在声明后才有效，声明的作用就是确定该变量要存储的数据类型。声明变量的语法格式如下：
数据类型 变量名;
如果要同时声明多个相同数据类型的变量，可以如下写：
数据类型 变量名1,变量名2;
代码举例如下：
int number, max;
boolean isOK;
变量在声明后，不能直接访问，只有被赋值的变量才能够被访问，否则就会出现运行错误。下面通过例子来看一下结果。
例2.1 变量的命名和赋值

class VariableDemo{
  public static void main(String args[]) {
    double salary; //声明变量
    System.out.println(salary); //变量的访问
  }
}

例题中变量声明的语句时正确的，但是声明后，没有赋值就使用打印语句对变量进行访问，就会出错，在Eclipse中会做如下提示，如下图2.3和2.4所示。

图2.3 变量的访问

图2.4 变量的访问的错误信息
上述问题的解决办法就是对变量进行赋值，然后再使用。

2.3.2 变量的赋值

第一次给变量赋值叫”初始化”。使用等号”=”来进行赋值，语法如下：
变量名 = 数据值;
例如：
int number;
number = 1000;
有的时候也可以把变量的声明和初始化合用一个语句实现出来，例如上面两行代码就可以改写成一行代码：
int number = 1000;
每个已经声明了数据类型的存储变量只能存储对应类型的数据。如下代码是正确的：
boolean isFlag = true;
int ii = 100;
double pi = 3.14;
float speed = 2.6f;
而如下代码是错误的：
boolean isFlag = 100;
int ii = false;
float speed = 2.6;
例2.2 变量的命名和赋值

class VariableDemo{
    public static void main( String args[]) {
        double salary; //声明变量
        salary = 1500.00; //变量赋初值
        System.out.println(salary); //变量的访问
    }
}

程序运行结果即为打印出”1500.0”。

2.3.3 常量

在程序中往往会存在变量值不需要变化的情况，比如表示圆周率的变量，比如表示黄金分割点的变量，那么这些值不变的变量就叫常量。常量与变量相比，也是用来存储数据的一块存储区域，但是它在程序运行中值不会发生变化。在Java中，常量用关键字final来表示，它也是有数据类型的，语法如下：
final数据类型 常量名 = 初始值;

提示：

1. 常量在声明的时候必须初始化；
2. 常量在初始化后值不能再更改，否则会引起错误。

例如：
final double PI = 3.14;

2.4 基本数据类型

在现实生活中，数据是以多种形式存在的，比如数字、文字、图形、声音等形式。在计算机的世界中，我们使用数据类型来描述这些不同的数据。
在Java中，数据类型分为两大类：
基本数据类型：8种基本数据类型

• 字符型
• 布尔型
• 数值型
  • 整型
  • 浮点型

引用数据类型：存储地址的引用

• 类
• 接口
• 数组

每个数据类型都有取值范围，编译器会对每种数据类型分配相应大小的存储空间。下面我们来详细介绍一下这8种基本数据类型。

2.4.1 数值数据类型

1．整型
前面提到，Java有4种整形数据类型，表2.2列出了整型的类型及值域范围：
表2.2 整型数据类型 | 类型 | 说明 | 占空间大小 | 值域 | | —- | —- | —- | —- | | byte |字节型 |1个字节（8位二进制） |-128 到 127 | | short |短整型 |2个字节（16位二进制） |-2^15^ 到 2^15^-1 | | int |整型 |4个字节（32位二进制） | -2^31^到 2^31^-1 | | long | 长整型 | 8个字节（64位二进制） | -2^63^到 2^63^-1 |
Java中整型的三种表示形式
十进制整数：0 ~ 9，注：第一位不能是0
十六进制数：0 ~ 9 A ~ F, 注：必须以0x或0X开头
例如： 0X8A 0x12
八进制整数：0 ~ 7，注：必须以0开头
例如： 0123 012
八进制整数：0 ~ 7，注：必须以0开头
Java编译器为不同的数据类型开辟不同大小的内存空间，比如byte型数据就占据1个字节的长度，int型数据就占据4个字节的长度。数据值要符合数据类型的值域，下面的两行代码就都是错误的：
byte b = 200;
int i = 3.657;

提示：

1. Java各整数类型有固定的表数范围和字段长度，其不受操作系统的影响，以保证Java程序的可移植性；
2. Java语言的整型常量默认为int型，声明long型后面需加上l或者L，否则会出错。

例2.3 整型的表示方式
在java中与语句int a = 97;等效的声明语句是_

A.int a = 0X0061; B.int a = 0X61; C.int a = 0141; D.int a = 97.0; 答案：ABC

2．浮点型
与整数类型相似，Java浮点数类型有固定的表数范围和字段长度，不受平台影响，浮点数据类型如下表2.3所示。
表2.3 浮点型数据类型

Java浮点数类型有两种表示形式，分别是十进制形式和科学计数法形式，具体表示方式如下：
十进制数形式，例如：3.14 314.0 .314
科学计数法形式，如：3.14e2 3.14E-1
Java浮点型常量默认为double型，如要声明一个常量为float型，则需在数字后面加f或F，如:
double d = 12345.6
float f = 12.3F
提示：

1. 带小数的数据默认是double型而非float型的；
2. 定义float型数据需要后面紧跟”f”或”F”来表示，比如float f = 2.1f；

3. 定义长整型数据，可以后面紧跟”l”或”L”来表示。

   2.4.2 字符数据类型

   字符数据类型用于存放单个字符，每个字符占用2个字节（16位二进制）的内存空间。一个字符型数据由单引号括起来，使用”char”关键字来说明数据类型，语法如下：
   char letter = \’a\’;
   上面的语句中，把字符\’a\’赋值给变量letter。字符及其含义如下表2.4所示。
   表2.4 字符及其含义
   
   字符类型是一个16位无符号整数，Java中字符类型的值是对应字符的编码, 是unicode编码，其中，英文部分的值与ascII编码一致。char是定长编码, 所有的字符都是16位。例如：
   \’A\’ 对应的编码是0x0041
   \’中\’对用的编码是 0x4e2d
   char类型在编码中: \’0\’~\’9\’, \’a\’~\’z\’, \’A\’~\’Z\’都是连续编码的，\’0\’与\’\u0000\’不是同一个字符，字符编码的最小值为0, 最大值是65535 ，也就是2\^16-1，使用时要注意字符字面量使用单引号为定界符号。

   提示：

4. 字符型只表示一个字符，不能表示多个字符，比如\’abc\’是错的；

5. 字符型只能用单引号（\’）括起来，用双引号（\”）括起来的不是字符而是字符串（String），比如\”a\”表示的不是char型字符而是String型字符串。

Java还允许使用转义字符来表示特殊字符。转义字符用斜杠”\”打头，后面跟一个字符。常见的转义字符如下表2.5所示。
表2.5 常见转义字符

转义字符用在一些特殊字符的表示上，如下代码：
例2.4 转义字符的用法

public class EscapeCharDemo {
  public static void main(String[] args) {
    System.out.println("escape\\bchar");
    System.out.println("escape\\tchar");
    System.out.println("escape\\rchar");
    System.out.println("escape\\nchar");
    System.out.println("\\我在斜线里\\");
    System.out.println("\'我在单引号里\'");
    System.out.println(\"我没有单引号\");
    System.out.println("\"我在双引号里\"");
    System.out.println("我没有双引号");
  }
}

运行结果如下图2.5所示：

图2.5 转义字符运行结果
那么字符串str1的值就是：\”我在双引号里\”，字符串str2的值就是：我没有双引号。字符串str1中的双引号就是通过转义字符（\“）来实现的。

2.4.3 布尔数据类型

布尔数据类型由关键字boolean来表示，布尔型数据的值域只有两个值：true和false。例如，下面两行代码：
boolean isOK = true;
boolean isFirst = false;

提示：

1. true和false都是小写，True、TRUE、False、FALSE都不是布尔型数据的值；
2. 布尔型数据不能用数字0和1来表示真假，只能用true和false；
3. 布尔型数据默认值是false。

例2.5 布尔数据类型
boolean flag;
flag = true;

2.5 数据类型转换

在上面的代码例子中，我们已经看到会有数据类型与变量声明的类型不匹配的情况发生。Java是强类型语言，要求赋值或传递时数据类型必须匹配，我们可以利用Java提供的数据类型的转换来消除这种错误。
Java提供了两种数据类型的转换方式：自动转换和强制转换，如下图2.6所示。

图2.6 数据类型转换

2.5.1 自动数据类型转换

自动数据类型转换也称之为隐式类型转换，我们在数值数据类型中了解到，不同类型的数据会占用不同大小的存储空间，那么数据类型自动转换的原则就是：小空间的数据类型可以自动转换成大空间的数据类型，也就是说低精度的数据可以升级成高精度的数据，反之不行，我们可以理解成高精度的数据转换成低精度的数据会失去数据的精度，所以能这样转换。数据类型的自动转换顺序如下图2.7所示：

图2.7 数据类型自动转换顺序

2.5.2 强制数据类型转换

强制数据类型转换也称之为显式类型转换，既然有些数据类型不能互相自动进行转换，那么Java提供了强制转换的方法，强制转换的语法就是用圆括号括起你要转换成的目的数据类型：
变量=（目标类型）值;
例如：

byte a;
int b;
a = (byte) b;
int i = (int)2.8;
float f = (float)5.2;

例2.6 自动类型转换

class TestConvert {
  public static void main(String arg[]) {
    /*自动类型转换*/
    int i1 = 12;
    int i2 = 45;
    double d1 = (i1 + i2) * 1.0;//系统将转换为double型运算
    System.out.println(d1);
    /*自动类型转换*/
    float f3 = 12.3f;//必须加f
    long l1 = 12300;
    long l2 = 300000000000L;//必须加l
    float f = l1 + l2 + f3;//系统将转换为float型计算
    System.out.println(f);
    String s;
    byte m1=1;
    byte m2=3;
    byte m = (byte)(m1+m2);
    /*强制类型转换*/
    long l = (long)f;//强制转换会舍去小数部分（不是四舍五入）
    System.out.println(l);
    /*强制类型转换*/
    byte b1 = 67;
    byte b2 = 89;
    byte b3 = (byte)(b1 + b2);//系统将转换为int型运算，需要强制转换符
    System.out.println(b3);
  }
}

运行结果如下图2.8所示：

图2.8 数据类型转换运行结果

提示：

1. boolean型数据不能和其他基本数据类型进行转换；
2. char型和int型数据可以互换；
3. byte、short、char之间不会相互转换，它们三者在计算时首先会转换为int类型；
4. 在强制类型转换过程中，源类型的值可能大于目标类型，因此可能造成精度降低或溢出，使用时需注意。

   2.6 运算符

   在程序设计中经常会做一些运算，比如算术运算、关系运算和逻辑运算。Java语言中也使用了一些常见的运算符和表达式来进行运算，下面我们就介绍这些运算符和表达式。

   2.6.1 算术运算符和表达式

   算术运算是一种常见的运算，主要是对数值型数据进行加减乘除等运算，表2.6列出了Java中的算术运算符：
   表2.6 算术运算符

算术表达式比较简单，用于进行算术运算，算术表达式的值都是数值型，例如下面代码：
int i = 100;
int j = i+8;
int k = i0.2;
自增运算: ++, —
i++, 后++, 先将i的值作为整个表达的值, 然后将i增加1.
++i, 先++, 先将i增加1, 然后将i的值作为整个表达的值.
举例如下：
i++; 等价于 i = i+1;
++i; 等价于 i = i+1;
—i; 等价于 i = i-1;
i—; 等价于 i = i-1;
通过上面的例子，并不能看出前置++和后置++有什么不同，只有在参与运算时，才能体现出前置和后置的不同之处。
*例2.7 比较前置++与后置++的不同。

public class SelfplusOperatorDemo1 {
  public static void main(String[] args) {
    int i = 0;
    int a = i++;
    System.out.println(a + ", " + i);// 0,1
    a = ++i;
    System.out.println(a + ", " + i);// 2,2
    i = i++;
    // int b = i++;
    // i = b;
    System.out.println(i);// 2
    i = 0;
    System.out.println(i++ % 3);// 0
    System.out.println(i++ % 3);// 1
    System.out.println(i++ % 3);// 2
    System.out.println(i++ % 3);// 0
    System.out.println(i++ % 3);// 1
    System.out.println(i++ % 3);// 2
    System.out.println(i++ % 3);// 0
  }
}

运行结果如下图2.9所示。

图2.9 SelfplusOperatorDemo1的运行结果
例2.8 比较前置++与后置++的不同。

public class SelfplusOperatorDemo2{
  public static void main(String args[]){
    int x1 = 3, y1 = 5;
    int x2 = 3, y2 = 5;
    int r1, r2;
    r1 = x1++ + x1\*y1;
    r2 = ++x2 + x2\*y2;
    System.out.println("x1="+x1+" y1="+y1+" r1="+r1);
    System.out.println(\"x2="+x2+" y2="+y2+" r2="+r2);
  }
}

运行结果如下图2.10所示。

图2.10 SelfplusOperatorDemo2的运行结果
上图中r1和r2的结果不同，说明前置++和后置++起到了不同的作用。我们来分析一下计算的中间过程：
r1 = 3+45;
r2 = 4+45;
练习 2.3 算术运算，运算规则如下图2.11、2.12和2.13所示。

图2.11 S取余运算的结果

图2.12 除运算的结果

图2.13 自加自减运算的结果
在Java中，字符串连接运算符使用”+”运算符，但此时与算术运算符中的加法运算符”+”的意义是不同的。字符串连接运算符，能够将多个字符串合并到一起生成一个新的字符串。
对于”+”运算符，如果有一个操作数是String类型，则”+”为字符串连接运算符，否则视为加法运算符。字符串可与任意类型的数据进行字符串连接的操作，若该数据为基本类型则会自动转换为字符串，若为引用类型，则会自动调用所引用对象的toString()方法获得一个字符串，然后进行字符串连接的操作。
请看下面代码举例：
例2.9 使用字符串连接符。

public class StringDemo{
  public static void main(String args[]){
    char c = 'a';
    String s = "hello";
    int i = 100;
    float f = 2.15f;
    double d = 5.7;
    boolean b = true;
    System.out.println("c=" + c);
    System.out.println("s=" + s);
    System.out.println("i=" + i);
    System.out.println("f=" + f);
    System.out.println("d=" + d);
    System.out.println("b=" + b);
  }
}

运行结果如下图2.14所示。

图2.14 StringDemo的运行结果

2.6.2 赋值运算符

编写程序时我们会遇到这样的情况：
i = i+8;
这句代码的意思是使i在自身的基础上再增加8。我们可以使用简捷赋值运算符来简化上面的代码，下面的语句和上面的语句是等价的：
i += 8;
简捷赋值运算符如下表2.7所示。
表2.7 简捷赋值运算符 | 运算符 | 名称 | 例子 | 说明 | | —— | —— | —— | —— | | = | 赋值运算符 | i=8 | 8赋值给i | | += | 加简捷赋值运算符 | i+=8 | i=i+8 | | -= | 减简捷赋值运算符 | i-=8 | i=i-8 | | = | 乘简捷赋值运算符 | i=8 | i=i*8 | | /= | 除简捷赋值运算符 | i/=8 | i=i/8 | | \%= | 取模简捷赋值运算符 | i%=8 | i=i%8 |

2.6.3 关系运算符和表达式

关系运算又叫比较运算，用来对两个操作数进行大小、等于的关系比较，表2.8列出了关系运算符。
表2.8 关系运算符 | 运算符 | 名称 | 例 | 结果 | | —— | —— | —— | —— | | > | 大于 | 1>2 | false | | >= | 大于等于 | 1>=2 | false | | \< | 小于 | 1\<2 | true | | \<= | 小于等于 | 1\<=2 | true | | == | 等于 | 1==2 | false | | != | 不等于 | 1!=2 | true |
关系表达式用于进行关系比较，关系表达式的值都是布尔型的，例如下面代码：
int i = 10;
int j = 16;
boolean smalli = i\boolean equal = i==j;
boolean bigi = i>j;

提示：

1. 关系表达式的结果都是布尔值，true或false；
2. 比较相等的是双等号”==”，不是一个等号”=”，一个等号”=”只能用来赋值。

   2.6.4 逻辑运算符和表达式

   逻辑运算又叫布尔运算，包括四个运算符，分别是&&、||、！和\^，用来进行与、或、非和异或的逻辑运算。逻辑运算的操作数和结果都是布尔类型的值。表2.9列出了逻辑运算符。
   表2.9 逻辑运算符

例如下面代码：
boolean x = true, y = false;
用x和y做逻辑运算的结果为：
x&&y 结果是 false
x||y 结果是 true
!x 结果是 false
x\^y 结果是 true

2.6.5 三目条件运算符

三目条件运算符的语法为：
表达式1 ? 表达式2 : 表达式3
这个表达式可以用if语句表示成：
if(表达式1成立){
return 表达式2;
}else{
return 表达式3;
}
举例如下：
int a=3, b=6;
int x = a>b? a:b;
那么计算结果就是x=6。
在三目条件运算中，表达式1和表达式2的值可以是任意一种基本数据类型。
例2.13 三目运算符

public class TernaryOperatorDemo {
    public static void main(String args[ ]) {
        // 4 < 3表达式的结果为true和false的其中一个。
        boolean n = (4 \< 3) ? true : false;
        // 打印并显示结果
        System.out.println(n);
    }
}

运行结果如下图2.18所示。

图2.18 TernaryOperatorDemo的运行结果

2.6.6 运算符的优先级

表达式通常由多个运算符组成。优先级的规则决定每个运算符在任何给定表达式中的计算顺序。表达式是按照从左到右运算符的优先级来进行运算的，正因为这种优先级的限制，才保证了每个表达式每次运算的结果都一样。
按操作数多少划分
一元操作符 > 二元操作符 > 三元操作符
按运算类型划分
算术运算符 > 关系运算符 > 逻辑运算符 > 赋值运算符
尽量多的使用括号，括号优先级别最高，使用括号也可保证在不确定优先级的情况下，更好地控制语句的执行顺序。
运算符的优先级如下表2.12所示。
表2.12 运算符优先级

2.7 表达式

表达式是符合一定语法规则的运算符和运算数的序列。按照使用的运算符和运算结果的不同可以分为：
1.算术表达式
例如：(x+y-12)100
2.关系表达式
例如：x>y x>=y x!=y x==y
3、逻辑表达式
例如：x&&y x||y||z (!x)&&(!y)
4、赋值表达式
例如：x=y x+=y
关于表达式，有下面几个概念需要介绍。
表达式的值：对表达式中操作数进行运算得到的结果称为表达式的值；
表达式的类型：表达式值的数据类型即为表达式的类型；
表达式的运算顺序：应按照运算符的优先级从高到低的顺序进行，优先级相同的运算符按照事先约定的结合方向进行，具体参考上一小节的介绍。
*【总结与提示】

1. 变量一定要在赋值后，才可以被访问；
2. 给变量赋值要遵守数据类型匹配的原则，有时可以使用强制类型转换；
3. 提倡使用&&和||，不提倡使用&和|；
4. 要区分前置++和后置++的运算区别，前置—和后置—也同理；

5. 双等号（==）与单等号（=）不同，前者是关系运算符，后者是赋值运算符；

   2.8 课后作业

   （一）选择题

6. 对于一个三位的正整数 n，取出它的十位数字k（k为整型）的表达式是

A.k = n / 10 % 10
B.k = n%10 % 10
C.k = n % 10
D.k = n / 10

1. 设 x = 1 , y = 2 , z = 3，则表达式 y＋＝z－－/＋＋x中y的值是

A. 3
B. 3. 5
C. 4
D. 5

1. 执行下列程序段后，b, x, y的值分别是

int x=6,y=8; boolean b;
b=x>y&&++x==—y;
A.true , 6, 8
B.false , 7, 7
C.true, 7, 7
D.false, 6, 8

1. Java语言中，占用32位存储空间的是

A.long，double
B.long，float
C.int，double
D.int，float

1. 现有一个变量声明为boolean aa;下面赋值语句中正确的是

A.aa=false;
B.aa=False;
C.aa=\”true\”;
D.aa=0;

1. 下列数据类型的精度由高到低的顺序是

A.float，double，int，long
B.double，float，int，byte
C.byte，long，double，float
D.double，int，float，long

1. 以下的选项中能正确表示Java语言中的一个整型常量的是

A.12.
B. -20
C.1,000
D.4 5 6

1. 下面不正确的变量名是

A. haha
B. 23_number
C. _ADC
D. $123

1. 下列单词中，不属于Java关键字的是

A.NULL
B.class
C.this
D.byte

1. 下面哪个标识符是合法的

A.#_pound
B.$123+w
C.5Interstate
D.a_b

1. 下列哪一个是合法的标识符

A.12class
B.+viod
C.-5
D._black

1. 指出下列类型转换中正确的是

A.int i=8.3;
B.long L=8.4f;
C.int i=(boolean)8.9;
D.double d = 100;

1. 定义变量int i=3;那么表达式i/6 * 5的计算结果是

A.0
B.1
C.2.5
D.2

1. 关于数据类型转换的说法哪个是不正确的

A.Java共有两种数据类型的转换方式：自动转换和强制转换。
B.Java中当两个类型不同的运算对象进行二元运算时，Java自动把精度较低的类型转换成另一个精度较高的类型。
C.boolean型数据能和其他数据类型进行转换。
D.char型和int型数据可以互相转换。

1. 下列语句执行后，变量m、n的值分别是

int x = 23,m,n;
m = x/100;
n = x%10;
A.0，3
B.0，2
C.3，0
D.3，1

1. 设x = 2 ，则表达式 ( x + + ) * 3 的值是

A.6
B.9
C.6.0
D.9.0

1. 已知x和y均为boolean型变量，则x && y的值为true的条件是什么?\ A.至少其中一个为true

B.至少其中一个为false
C.x和y均为true
D.x和y均为false

1. 设有定义float x=3.5f, y=4.6f, z=5.7f；则以下的表达式中，值为true的是

A.x > y || x > z
B.x != y
C. z > ( y + x )
D.x \< y & ! ( x \< z )
（二）简答题

1. Java中的基本数据类型共有四种，分别是什么？
2. 写出定义双精度浮点型常量G，值为9.8的语句。
3. 标识符的命名规则有哪些？
4. 定义int a=6,b; b=a++*3; 程序执行后 a、b的值分别为多少？
5. 设 x = 2 ，则表达式 x + +／3 的值是__。
6. 若x = 5，y = 10，则x \< y和x >= y的逻辑值分别为多少？

（三）编程题

1. 已知a,b均是整型变量，写出将a,b两个变量中的值互换的程序。
2. 给定一个0～1000的整数，求各位数的和，例如345的结果是3+4+5＝12注：分解数字既可以先除后模也可以先模后除。
3. 华氏温度和摄氏温度互相转换，从华氏度变成摄氏度你只要减去32，乘以5再除以9就行了，将摄氏度转成华氏度，直接乘以9，除以5，再加上32即行。
4. 给定一个任意的大写字母A~Z，转换为小写字母。