Java基本程序设计结构1

Java基本程序设计结构1

本章内容

n         计算机中数据的表示方法

n         关键字和标识符

n         数据类型

n         变量

n         运算符

n         类型转换

n         枚举型

n         注释

 

 

一　计算机中数据的表示方法

 

1.1 　为什么计算机采用二进制

 

计算机是一种电子设备，由复杂的电子元器件组合而成，一个电子元器件有带电和不带电两种状态，通常我们将带电状态表示为数值1，不带电状态表示为数据0，多个这样的元器件的组合可以表示更多状态，也就是可以表示更多的数据，如000表示0，001表示1,010表示2，011表示3，依此类推，111表示7，一个元器件可表示一位（bit）数据，这种表示数据的方式就叫二进制。在实际的电子设备中，我们将8个这样的元器件形成一个单元，这样的单元叫一个字节（byte），一个字节能表示多少个数呢？表示数值的范围是0~255。

一个字节由8个二进制位组成，其中最右边的一位称为“最低有效位”或“最低位”，最左边的一位称为“最高有效位”或“最高位”。每一个二进位的值是0或1。

 

1.2 　二进制的缺点

 

二进制计数的缺点是书写太长，容易出错。一般计算机的数据位数都是4的整数倍，所以，在计算机里通常采用16进制计数法。用数字可以表示各种信息，计算机里只有数值，当你在内存中看到一个数值时，这个数值可能代表各种意义，生活中数值也可以代表其他意义，如1234可以代表密码，存款额，电报信息，根据上下线索，我们就能够知道这数值代表的意义。

 

1.3 　不同进制之间的数值转换

 

在生活中，我们最为常用的是十进制，而计算机只能识别二进制，因为二进制书写太长，所以，在计算机里通常采用16进制计数法。下面我们来了解一下以上几种进制之间转换方法。

 

1.3.1    二进制转换十进制

10010111转换为十进制的方法为：

10010111 = 1×2⁰ + 1×2¹ + 1×2² + 0×2³ + 1×2⁴ + 0×2⁵ + 0×2⁶ + 1×2⁷

10010111 = 1 + 2 + 4 + 0 + 16 + 0 + 0 + 128

10010111 = 151

 

1.3.2    十六进制转换十进制

 

5D14转换为十进制的方法为：

5D14 = 4×16⁰ + 1×16¹ + 13×16² + 5×16³

5D14 = 4 + 16 + 3328 + 20480

5D14 = 23828

 

1.3.3    十进制转换二进制

 

50转换为二进制的方法为：

50 ÷ 2 = 25...0

25 ÷ 2 = 12...1

12 ÷ 2 = 6...0

6 ÷ 2 = 3...0

3 ÷ 2 = 1...1

1 ÷ 2 = 0...1

结果为：110010

 

1.3.4    十进制转换十六进制

 

7296转换为十六进制的方法为：

7296 ÷ 16 = 456...0

456 ÷ 16 = 28...8

28 ÷ 16 = 1...12

1 ÷ 16 = 0...1

结果为：1C80

 

1.4　原码、反码和补码

　　

一个数分为正数和负数，在计算机中表示数可以采用多种方法，一般有原码、反码和补码。

 

1.4.1　原码

 

将最高位作为符号位（以0代表正，1代表负），其余各位代表数值本身的绝对值（以二进制表示）。

为了简单起见，我们用1个字节（8个bit位）表示一个整数。

+7的原码为：0000 0111

-7的原码为：1000 0111

问题：

+0的原码为：0000 0000

-0的原码为：1000 0000

无论是+0还是-0，其实它们都是0，而使用原码来表示+0和-0时，其二进制值不唯一。所以，在我们计算机中没有采用原码的表示形式。

 

1.4.2　反码

 

一个数如果为正，则它的反码与原码相同；一个数如果为负，则符号位为1，其余各位是对原码的取反。

为了简单起见，我们用1个字节来表示一个整数。

+7的反码为：0000 0111

-7的反码为：1111 1000

问题：

+0的反码为：0000 0000

-0的反码为：1111 1111

无论是+0还是-0，其实它们都是0，而使用反码来表示+0和-0时，其二进制值不唯一。所以，在我们计算机中没有采用反码的表示形式。

 

1.4.3　补码

 

在计算机中，如果我们用1个字节表示一个数，一字节有8位，超过8位的位数丢弃，在内存中情况为：

1 0000 0000

1被丢弃了。

一个数如果为正，则它的原码、反码、补码相同；一个数如果为负，则符号位为1，其余各位是对原码取反，然后整个数加1。

为了简单起见了，我们用1个字节来表示一个整数。

+7的补码为：0000 0111

-7的补码为：第①步取反：1111 1000

　　　　　　第②步加一：1111 1001

 

+0的补码表示：0000 0000

-0的补码表示：第①步取反：1111 1111

　　　　　　　第②步加一：1 0000 0000

　　　　　　　第③步丢弃高出8位的位：0000 0000

那么我们可以看到，采用补码来表示数值的时候，+0与-0的表示形式是唯一的，所以，在我们的计算机中，采用的是补码的形式。

 

二　关键字和标识符

 

2.1　关键字

 

关键字就是Java语言中已经被赋予特定意义的一些单词。不可以把这类词作为标识符来用。至于关键字的含义，在后面的各个章节中将陆续介绍。表2-1描述了Java中所有关键字及其含义的简单描述。

 

表2-1　关键字

关键字

含　义

abstract

抽象类和方法

assert

用来定位内部的程序错误

boolean

布尔类型

break

跳出switch或循环语句

byte

8位整型

case

switch语句的判断分支

catch

捕获异常的try语句块的子句

char

Unicode字符类型

class

定义类类型

const

未使用

continue

结束本次循环而继续执行下一次循环

default

switch语句的默认分支

do

do/while循环的开始

double

双精度浮点数类型

else

if语句的else子句

extends

定义一个类的父类

final

常量、不能继承的类或不能覆盖的方法

finally

try语句块总被执行的部分

float

单精度浮点类型

for

一种循环语句

goto

未使用

if

一种条件语句

implements

定义一个类实现的接口

import

导入一个包

instanceof

检测某个对象是否是某个类的实例

int

32位整型

interface

一种抽象类型，其方法需要用一个类实现

long

64位长整型

native

一种由主机系统实现的方法

new

分配一个新对象或数组

null

空引用

package

包含类的包

private

仅能由本类的方法访问的特性

protected

仅能由本类的方法、子类及其本包中的其他类访问的特性

public

可以由所有类的方法访问的特性

return

从一个方法中返回

short

16们整型

static

第个类只有唯一的副本，而不是每个对象有一个副本

strictfp

浮点计算采用严格的规则

super

父类对象或构造器

switch

一种选择语句

synchronized

线程类的原始方法或代码块

this

方法的隐式参数或本类的构造器

throw

抛出异常

throws

方法可以抛出的异常

transient

标记数据不能够持久化

try

捕获异常的代码块

void

表明方法不返回值

volatile

确保一个域可以被多个线程访问

while

一种循环语句

 

2.2　标识符

 

2.2.1　什么是标识符

用来标识变量名、方法名、数组名、类名、接口名等有效字符序列称为标识符。简单地说，标识符就是一个名字。

2.2.2　标识符的组成

Java语言规定标识符由字母、下划线、美元符号和数字组成，并且第一个字符不能是数字。

另外，标识符不能是关键字。而且Java是大小写敏感的，ABC、abc、Abc是三个不同的标识符。

2.2.3　风格约定

n         接口名、类名：所有单词第一个字母大写，其余字母小写。例如AnyVariableWorld；

n         变量名、方法名：除首字母小写外，同类名相同。例如：anyVariableWorld；

n         常量：完全大写。例如：ANY_VARIABLE_WORLD；

n         见名知意：例如定义一个变量来表示学生的年龄。studentAge。

 

三　数据类型

 

Java是一种强类型语言。这就意味着必须为每一个变量声明一种类型。在Java中，一共有8种基本类型，其中有4个整型、2个浮点型、1个字符型和1个用于表示真假值的boolean类型。除基本类型外，其它类型我们称之为类类型（即引用类型）。我们在今后的学习中会发现，引用类型与基本类型的不同，引用类型的功能更加强大。

 

3.1　整型

 

整型用于表示没有小数部分的数值，它允许是负数。Java提供了4种整型，具体内容如表2-2所示。

表2-2　Java整型

类型

存储需求

取值范围

byte

1字节

-128 ~ 127

short

2字节

-32768 ~ 32767

int

4字节

-2147483648 ~ 2147483647

long

8字节

-9223372036854775808 ~ 9223372036854775807

 

在通常情况下，int类型非常有用，但要表示地球上的居住人数，就要使用long类型了。byte和short类型主要用于特定的场合，例如，底层的文件处理或者需要控制占用存储空间量大的数组。

长整型数值有一个后缀L（如40000000000L）。十六进制数值有一个前缀0x（如0xCAFE）。八进制有一个前缀0。

 

3.2　浮点型

 

浮点类型用于表示有小数部分的数值。在Java中有两种类型，具体内容如表2-3所示。

 

表2-3　浮点类型

类型

存储需求

取值范围

float

4字节

大约±3.40282347E+38F（有效位数为6~7位）

double

8字节

大约±1.79769313486231570E＋308（有效位数为15位）

 

double表示这种类型的数值精度是float类型的两倍。（有称之为双精度）绝大部分应用程序都采用double类型。在很多情况下，float类型的精度很难满足需求。例如，用7位有效数字足以精确表示普通雇员的年薪，但表示公司总裁的年薪可能就不够用了。实际上，只有很少的情况适合使用float类型，例如，需要快速地处理单精度数据，或者需要存储大量数据。

float类型的数值有一个后缀F（例如，3.402F）。没有后缀F的浮点数值（如3.402）默认为double类型。当然，也可以在浮点数值后面添加后缀（例如，3.402D）。

 

在JDK5.0中，可以使用十六进制表示浮点数值。例如，0.125可以表示成0x1.0P-3。在十六进制表示法中，使用P表示指数，而不是E。

 

提 示

 

　　　　　浮点数值不适用于禁止出现舍入误差的金融计算中。例如，命令System.out.println(2.0-1.1)将打印出0.8999999999999999，而不是人们希望的0.9。出现这种问题的主要原因在于浮点数值是采用二进制系统表示，而在二进制系统中无法精确的表示分数1/10。这就好象十进制无法精确地表示1/3一样。如果需要在数值计算中不含有任何舍入误差，就应该使用BigDecimal类。

 

3.3　char类型

 

在java中规定，字符型为16位（2字节）Unicode编码，字符型可以通过转换转成整数型或浮点型，实际上，可以把字符型变成十六位无符号整数使用，整数的值是该字符Unicode编码。

Unicode编码包含ASCⅡ码，Unicode编码基本包含全世界所有的字符。而学员只需要市记住A、a、0的编码值即可。

 

0 零   48…..

A　　65。。。。

a　　97……

 

在Java中，char类型用UTF-16编码描述一个代码单元。字符常量的表示形式有如下几种。

n         ‘a’表示一个字符a，当然也可以表示一个汉字，例如，’崔’也是一个合法的Java字符。

n         /u后面跟随4位的十六进制数来表示一个字符。例如：’/u5d14’。

n         特殊字符的转义字符。例如’/n’表示换行。表2-4给出了转义字符表。

 

表2-4　特殊字符的转义序列符

转义序列

名称

Unicode值

/b

退格

/u0008

/t

制表

/u0009

/n

换行

/u000a

/r

回车

/u000d

/”

双引号

/u0022

/’

单引号

/u0027

//

反斜杠

/u005c

/XXX

/后跟随3位8进制整数

 

 

3.4　boolean类型

 

boolean（布尔）类型有两个值：false和true，用来判定逻辑条件。这两个值不能与整型进行相互转换。Java没有明确给出boolean类型占用的内存空间大小。

 

以上学习的基本类型中，除boolean类型外，都是数值类型。char类型可以被当做数值类型与整型或浮点型进行运算。但数据类型不能与boolean类型转换。boolean类型也不能转换为数值类型。

 

四　变量

 

在Java中，每一个变量属于一种类型。在声明变量时，变量所属的类型位于前面，随后是变量名。这里列举一些声明变量的例子：

double d;

int i;

long l;

boolean b;

char c;

注意，用于Java中，声明是一条完整的语句，因此每一个声明都必须以分号结束。可以在一行中声明多个变量：

int i, j;

不过，不提倡使用这种风格。逐一声明每一个变量可以提高程序的可读性。

 

4.1　初始化变量

 

声明一个变量之后，必须利用赋值语句对变量进行显式初始化，千万不要使用一个未初始化的变量。例如，Java编译器认为下面语句是错误的：

int a;

System.out.println(a);//错误，变量没有初始化

要想对一个已经声明过的变量进行赋值，就需要将变量名放在等号（=）左侧，具有相应取值的Java表达式放在等号的右侧。

int a;

a = 10;

也可以将变量的声明和初始化放在同一行中。例如：

int a = 10;

注意，不能使用未初始化的变量。变量的声明尽可能地靠近变量第一次使用的地方，这是一种良好的程序编写风格。

 

4.2　常量

 

在Java中，利用关键字final声明常量。关键字final表示这个变量只能被赋值一次。一旦被赋值之后，就不能够再更改了。习惯上，常量名使用大写。

final int ABC = 100;

System.out.println(ABC);

ABC = 200;//错误，final变量只能被赋值一次。

 

五　运算符

 

在Java中，有算术运算符、关系运算符、逻辑运算符、位运算符、下标运算符、成员运算符、赋值运算符等。

运算符有三个特性：

n         运算量个数。例如：加法运算，需要两个运算量。那么加法运算符就是二元运算符；正号运算符，只需要一个运算量，那么它就是一元运算符。

n         结合性。复合表达式中，运算顺序分别从左到右，和从右到左两种。例如，a+b+c;首先运算a+b的和，再与c相加。它的结合性是从左到右，即左结合性。

n         优先级。复合表达式中，运算符的运算顺序不只受结合性的影响，还要受优先级的影响。例如，a+b*c;首先运算b*c的积，再求a加b*c的积。那么，乘法运算符的优先级高于加法运算符。

 

5.1　算数运算符

 

算数运算符包括+、-、*、/、%、++、--。算数运算符的运算量只能是数值类型或运算结果为数值类型的表达式（+可以应用于String类型）。算数表达式的运算结果为数值类型。要注意的是，整数除法与浮点数除法的不同。例如：15/2等于7，而15.0/2等于7.5。求余（有时称为取模）通常只应用于整型，15%2等于1；5.5%3等于2.5。

当然，程序员都知道加1、减1是数值变量最常见的操作。在Java中，借鉴了C和C++的实现方式，也使用了自增、自减运算符：n++将变量n的当前值加1；n--将n的值减1。例如：

int n = 12;

n++;

n的值将变为13。因为这些运算符改变了变量的值，所以它的操作数不能是字面值。例如，4++就是一条非法的语句。因为自增、自减都是在变量原有值的基础上加1或减1。如果变量在进行自增、自减之前没有赋值，会出现错误。

实际上，这两个运算符有两种形式。上面介绍的是运算符放在后面的“后缀”形式，还有一种“前缀”形式（++n）都是对变量值加1。但在表达式中，这两种形式就有区别了。前缀方式先进行加1运算；后缀方式则使用变量原来的值。

int m = 7;

int n = 7;

int a = 2 * ++m;//a等于16，m等于8

int b = 2 * n++;//b等于14，n等于8

我们建议不要在其他表达式的内部使用++，这样编写的代码很容易令人感到迷惑，并会产生烦人的bug。

 

5.1　逻辑运算符

 

逻辑运算符包括!（逻辑非）、&&（逻辑与）、||（逻辑或）。运算量必须是boolean型或运算结果为boolean型的表达式。逻辑表达式的值也是boolean型。

n         !（逻辑非）。例如，b如果为true，那么!b就是false；如果b为false，那么!b就为true。（可以把!读为“非”）

n         &&（逻辑与）。例如，a&&b，a与b中只要有一个是false，那么a&&b就为false；除非a与b都是true，那么a&&b才会为true。（可以把&&读为“并且”）

n         ||（逻辑或）。例如，a||b，a与b中只要有一个是true，那么a||b就为true；除非a与b都是false，那么a||b才会为false。（可以把||读为“或者”）

&&和||是按照“短路”方式求值的。如果第一个运算量已经能够确定值，第二个运算量就不必计算了。例如，a&&b，如果a为false，那么结果不可能为true。因此b的值就没有必要计算了。与之类似，对于a||b，当a为true时，结果不可能为false，那么不必再计算b的值。这就是短路方式。

Java还给出了非短路方式的逻辑与（&）、逻辑或（|）。例如a&b，无论a的值是否能够确定表示式的结果，都会继续计算b的值。同理，a|b，也是如此。

 

5.2　关系运算符

 

关系运算符包括>（大于）、<（小于）、>=（大于等于）、<=（小于等于）、==（恒等于）、!=（不等于）六种。前四种的运算量只能是数值类型，后两种的运算量可以是数值及引用类型。关系运算符的运算结果为boolean类型。前四种的优先级大于后两种。

表达式10>3的结果为true，而10<3的结果为false。

我们经常会将关系运算符与逻辑运算符混合使用，例如：

a > 0 && a < 100

c == ‘男’|| c == ‘女’

 

5.3　位运算符

 

位运算是按照二进制位进行运算的。它包括&（按位与）、|（按位或）、^（按位异或）、~（按位非，即取反）、<<（左移）、>>（有符号右移或算术右移）、>>>（无符号右移或逻辑右移）。位运算符的运算量必须是整型，其结果也是整型的。

n         7 & 3。为了简单起见，我们用一个字节来表示整数。

0000 0111

& 0000 0011

           -------------

             0000 0011

　　　　&，相同位的两个数值进行运算，如果两个数都为1那么该运算结果为1，否则为0。

n         7 | 3。

0000 0111

| 0000 0011

           -------------

             0000 0111

　　　　|，相同位的两个数值进行运算，如果两个数都为0，该位运算结果0，否则为1。

n         7 ^ 3。

0000 0111

^ 0000 0011

           -------------

             0000 0100

　　　　^，相同位的两个数值进行运算，如果两个数相同，该位运算结果0，否则为1。

n         ~7。

0000 0111

           -------------

             1111 1000

　　　　~，将每一位上的数值取反，1取反为0,0取反为1。

n         7 << 1。

0000 0111

<<         1

           -------------

             0000 1110

　　　　<<，将所有位向左移动1位，进位溢出，空位补0。

n         7 >>> 1。

0000 0111

>>>        1

           -------------

             0000 0011

　　　　>>>，将所有位向右移动1位，进位溢出，空位补0。

n         7 >> 1。

0000 0111

>>         1

           -------------

             0000 0011

　　　　>>，将所有位向右移动1位，进位溢出，空位补“符号值”。

 

5.4　赋值运算符

 

赋值运算符包括=。赋值运算符的运算量可以是任意类型，结果根据运算量而定。例如a = 10;表达式的结果就是a的值。

复合赋值运算符包括+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=、>>>=。它们把其它运算与赋值运算融合到一起，形成了复合赋值运算符。例如：

int a = 10;

a += 10;

上面的语句会使a变量在原有值的基础上自增10。可以把上面语句分解开来理解。例如，a+=10分解为a = a + 10。分解后发现，如果a没有初始化，那么a+=10会报错。

 

5.5　条件运算符

 

条件运算符只有一个?:，它是Java中唯一一个三元运算符。a?b:c，a运算量必须是boolean类型，而其它两个运算量可以是任意类型。表达式的结果取决于a是true还是false，如果a为true，那么表达式的值为b（即冒号左边的），否则为c（即冒号右边的）。

char c = b ? ‘男’:’女’;

 

5.6　运算符优先级与结合性

 

表2-5列出了Java中所有运算符。本章没有讲到的其它运算符将在其它章节中陆续讲

解。

表2-5　运算符

优先级

运算符

名称

结合性

运算量

1

()

括号

无

无

1

.

成员运算符

从左到右

一元

1

()

方法调用运算符

从左到右

一元

1

[]

下标运算符

从左到右

一元

2

！

逻辑非运算符

从右到左

一元

2

~

取反运算符

从右到左

一元

2

++、--

自增、自减运算符

从右到左

一元

2

+、-

正号、负号运算符

从右到左

一元

2

()

强制类型转换运算符

从右到左

一元

2

new

新建运算符

从右到左

一元

3

*、/、%

乘、除、取余运算符

从左到右

二元

4

+、-

加法、减法运算符

从左到右

二元

5

<<、>>、>>>

左移、算术右移、逻辑右移

从左到右

二元

6

<、<=、>、>=

小于、小于等于、大于、大于等于

从左到右

二元

6

instanceof

实例运算符

从左到右

二元

7

==、!=

恒等于、不等于

从左到右

二元

8

&

按位与

从左到右

二元

9

^

按位异或

从左到右

二元

10

|

按位或

从左到右

二元

11

&&(&)

逻辑与

从左到右

二元

12

||(|)

逻辑或

从左到右

二元

13

?:

条件运算符

从右到左

三元

14

=、+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=、

>>>=

赋值及复合赋值运算符

从右到左

二元

 

六　类型转换

 

在程序运行时，经常需要将一种数值类型转换为另一种数值类型。图2-1给出了数值类型之间的合法转换。

图2-1　数值类型之间的合法转换

 

在图2-1中有6个实箭头，表示无数据丢失的转换；有3个虚箭头，表示可能有精度损失的转换。例如，123456789是一个大整数，它所包含的位数比float类型所能够表达的位数多。当将这个整型数值转换为float类型时，将会得到同样大小的结果，但失去了一定的精度。

int n = 123456789;

float f = n;

System.out.println(f);// 1.23456792E8

当使用上面两个数值进行二元运算时（例如n+f，n是整数，f是浮点数），先要将两个运算量转换为同一种类型，然后再进行计算。

l         如果两个运算量中有一个是double类型的，那么另一个运算量将会转换为double类型。

l         否则，如果其中一个运算量是float类型，那么另一个运算量将会转换为float类型。

l         否则，如果其中一个运算量是long类型，那么另一个运算量将会转换为long类型。

l         否则，两个运算量都将被转换为int类型。

 

6.1　强制类型转换

 

在上一小节如看到，在必要的时候，int类型的值将会自动地转换为double类型。但另一方面，有时也需要将double转换成int。在Java中，允许进行这种数值之间的类型转换，当然，有可能会丢失一些精度。在这种情况下，需要通过强制类型转换实现这个操作。

强制类型转换的语法格式是在圆括号中给出想要转换的目标类型，随后紧跟待转换的变量名。例如：

double x = 9.9997;

int n = (int)x;

这样，变量n的值为9。强制类型转换将通过截断小数部队来把一个浮点值转换为整型。

如果想对浮点数进行舍入运算，得到最接近的整数，就需要使用Math.round方法：

double x = 9.9997;

int n = (int)Math.round(x);

现在，变量n的值为10。当调用round的时候，仍然需要使用强制类型转换(int)。其原因是round方法返回的结果为long类型，由于存在精度丢失的可能性，所以只有使用显示的强制类型转换才能够将long类型转换成int类型。

 

七　枚举类型

 

有些时候，变量的取值仅在一个有限的范围内。例如：销售的服装或比萨饼只有小、中、大和超大这四种尺寸。当然，可以将这些尺寸编码为（整型）1、2、3、4或（字符）S、M、L、X。但这样做存在着一定的隐患。在变量中很可以保存的是一个错误的值（如5或A）。

从JDK5.0开始，针对这种情况，可以自定义枚举类型。枚举类型包括有限个命名的值。例如，enum Size(SMALL,MEDIUM,LARGE,EXTRA_LARGE);

现在，可以声明这样一种类型的变量：

Size s = Size.MEDIUM;

Size类型的变量只能存储该类型声明中给定的某个枚举值，或者null值。

有关枚举类型的详细内容将在后续章节中讲解。

 

八　注释

 

与大多数程序设计语言一样，Java中的注释也不会出现在可执行程序中。因此，可以在源程序中添加任意多的注释，而不必担心可执行代码会膨胀。在Java中，有三种表示注释的方法。最常用的方式是使用//，其注释内容从//开始到本行结尾。

System.out.println(“Hello,World!”);//这是一个Hello World程序。

当需要比较长的注释时，可以在每行的注释前面标记//，也可以使用/*和*/将一段比较长的注释括起来。

/*

这是一个简单的程序

作者：qdmmy6

时间：2008-08-08

*/

第三种注释可以用来自动地生成文档。这种注释以/**开始，以*/结束。有关这种注释的详细内容和自动生成文档的具体方法将在后续章节中介绍。

注意，在Java中，/**/注释不能嵌套。也就是说，如果代码本身包含了一个*/，就不能用/*和*/将注释括起来。

 

本章小结

　　本章讲述的内容，都是必须要掌握的基本知识。学员必须多读、多练，只有多上机测试，才能真正掌握这些基本知识。

 

本章练习

十进制整数153、234、45、16，转换为二进制、十六进制。如何转换为十六进制？

1、  将十进制整数-110、-98、36、49用补码表示。

2、  测试下列标识符是否正确：_123、大家好、＆abc、$abc、+abc、123abc。例如使用它们做变量名测试。  ·

3、  测试

byte b = 127:

b = b + 1;………………………….出错，可能丢失精度

b += 1;

b++;

其中那一条语句编译出错。

4、  测试

byte b = 127;

b++;

System.out.println(b);

查看结果，为什么？。。。。。。。。。。。。。。。-128  因为冒了

5、  测试

byte b = 128;

编译是否出错，为什么？………….出错，可能丢失精度

6、  测试

short s = 32768;

编译是否出错，为什么？。。。。。。 出错，可能丢失精度

7、  01测试

char c = ‘a’;

c = c – 32;

编译是否出错，为什么？……………出错！因为c是char类型，右面是int类型

8、02测试

char c = ‘a’;

c -= 32;

编译是否出错，为什么？。。。。。。。。。。。。。。。。不会出错。因为编译器不考虑类型

9、测试

float f = 1.0;

编译是否出错，为什么？。。。。。出错，要强制类型转化

10、测试

float f = 1.0F;

编译是否出错，为什么？。。。。。。没事

11、测试

float f = 1.0F;

System.out.println(f);

输出多少位？。。。。。。。。。2

12、测试

double d = 1.0;

System.out.println(d);

输出多少位？2.。。。。。。。。。。。。。

13、测试

System.out.println(2.0-1.1)    。。。。。。。。。。  。。。。。。。。0.8999999999999999

输出结果，为什么？

14、测试

System.out..println(“hello/tworld/nhello world/rabc”);

System.out.print("hello/b/b/b");

System.out.println(“/”//b//t//n//r/””);

System.out.println("/141/142/143");

System.out.println("/u0061/u0062/u0063");

System.out.println("/u4E2D/u534E/u4EBA/u6C11/u5171/u548C/u56FD/u4E07/u5C81/uFF01");

15、测试

boolean b = true;

int i = b;

编译是否通过，为什么？………………。。。不兼容的类型，boolean类型，int类型

16、测试

int i;

float f;

double d;

System.out.println(i + f + d);

编译是否通过，为什么？。。。。。。。。。能，表达式的值的类型是double

17、测试

int i, j = 100, k;

int n;

是否编译通过，为什么？。。。。。。。能，符合java规则

18、测试

final int i;

i = 100;

i = 100;

是否编译通过，为什么？。。。。。。。。。。不能，因为final修饰的变量一旦初始化了就不可以重新赋值了！

19、Ok测试

int i = 7;

System.out.println(i / 2);。。。。。。。。。。3

int j = 7;

System.out.println(j / 2.0);.。。。。。3.5

20、测试

int m = 7;

int n = 7;

int a = 2 * ++m;    a=16 ;m=8

 int b = 2 * n++;    a=14 ;n=8

21、测试

System.out.println(10 < 3);false

System.out.println(10 >= 10);true

System.out.println(10 >= 10 == 10 < 3);false

System.out.println(10 < 10 < 3);

System.out.println(10 > 3 && 10 > 20);

System.out.println(10 < 3 || 10 < 20);

System.out.println(!10 < 3); 

22、测试

boolean b1 = true;

System.out.println(false && (b1 = false));       false

System.out.println(b1);    true

 

boolean b1 = true;

System.out.println(false & (b1 = false));  false

System.out.println(b1);  false

23、测试

boolean b1 = true;

System.out.println(true || (b1 = false));  true

System.out.println(b1);  true

 

boolean b1 = true;

System.out.println(true | (b1 = false));  true

 

 

 

System.out.println(b1); false

24、             测试

    int i = 3;

    i = ~i + 1;

    System.out.println(i);

25、测试

    int a = 4, b = 7;

    a ^= b;System.out.println(a + ", " + b);

    b ^= a;System.out.println(a + ", " + b);

    a ^= b;System.out.println(a + ", " + b);

26、有变量a=20,b=10,c=30，使用条件运算符，找出a、b、c中最大值

                     int max =a>b?a:c

27、测试

    byte b1 = 1 + 2;  通过

    byte b2 = b1 + 3; 可能丢失精度

    byte b3 = b1 + b2; 可能丢失精度

 

28、找出下列语句中，哪些向上转型，哪些是向下转型。把向下转型的语句，添加强制类型转换。Ok Ok Ok Ok Ok Ok

byte b = 1;

short s = 1;

char c = 1;

int i = 1;

long l = 1;

float f = 1;

double d = 1;

b = s;

b = c;

b = i;

b = l;

b = f;

b = d;

s = b;

s = c;    这个char和short虽然大小都是2个字节，但相互之间要强制类型的转换

s = i;

s = l;

s = f;

s = d;

c = b;

c = s;  这个char和short虽然大小都是2个字节，但相互之间要强制类型的转换

 

c = i;

c = l;

c = f;

c = d;

i = b;

i = s;

i = c;

i = l;

i = f;

i = d;

l = b;

l = s;

l = c;

l = i;

l = f;

l = d;

f = b;

f = s;

f = c;

f = i;

f = l;

f = d;

d = b;

d = s;

d = c;

d = i;

d = l;

d = f;

29、创建一个方向的枚举类型，方向只有上、下、左、右。

enum FangXing{u，d，l，r}；

30、测试  ok

//abc//def

/*abc*/

 

/*

    //abc//def

    /*abc*/

*/