4.4. 整数型──byte, short, int, long. 5
QQ：519517915
l 本模块阐述了在Java技术中使用的基本元素，包括变量、关键字、原始类型和类类型。
完成本模块的学习后，你应该能够：
- 区分有效和无效标识符
- 识别Java技术关键字
- 列出八个原始类型
- 为数字类型和文本类型定义文字值
- 解释术语class、object、member variable和reference variable
- 为一个简单的包含原始成员变量的类创建一个类定义
- 声明类类型变量
- 使用new构造一个对象
- 描述缺省初始化
- 使用点符号访问一个对象的成员变量
- 描述一个引用变量的意义
- 描述分配类类型变量的结果
3.1 基本语法元素
3.1.1 注 释
l 注释是程序员用来标记、说明程序的。编译器会忽略注释中的内容，注释中的内容不会对程序的运行产生任何影响。Java语言允许三种风格的注释：
// 单行注释
/* 多行注释 */
/** 文档注释 */
3.1.2 分号
l 在Java编程语言中，语句是一行由分号(;)终止的代码。
l 例如
totals=a+b+c+
d+e+f ；
l 与下式相同
totals=a+b+c+
d+e+f；
3.1.3语句块(block)
l 语句块(block)也叫做复合语句。一个语句块(block)是以上括号和下括号（{}）为边界的语句集合；语句块也被用来组合属于某个类的语句。例如：
public class Date {
private int day=3;
private int month;
private int year;
public void pri(){
}
public static void main(String[] a){
}
l }
语句块可被嵌套。HelloWorldApp类由main方法构成，这个方法就是一个语句块，它是一个独立单元，单元本身可作为在类HelloWorldApp块中的一组事务之一。
下面的语句是合法的：
// a block statement
{
x = y + 1;
y = x + 1;
}
// an example of a block statement nested within another block statement
while ( i < large ) {
a = a + i;
if ( a == max ) {
b = b + a; // nested block is here
a = 0;
}
}
3.1.4空白
l 空白：是空格、tabs和新行的统称。
在源代码元素之间允许插入任意数量的空白。空白可以改善源代码的视觉效果，增强源代码的可读性。例如：
{
int x;
l x = 23 * 54;
}
{
int x
x = 23 + 54;
}
3.2 标识符
标识符是语言元素的名称，是我们在程序中表示变量、类或方法等等的符号。
标识符可从一个字母、下划线(_)或美元符号($)开始；随后跟随字母、下划线(_)、美元符号($)或数字。
可用一句话来描述：也就是说标识符由字母、下划线(_)、美元符号($)或数字组成，其中不能以数字开头。
标识符是大小写区别对待的。
标识符未规定最大长度。
下列标识符是有效的：
idendsafdstifier
ugfdsgName
Udsaf_dsfe
_sys_varldaf
$changdsafe
Java技术源程序采用双字节的“统一字符编码” (Unicode)标准，而不是单字节的 ASCII文本。因而，一个字母有着更广泛的定义，而不仅仅是a到z和A到Z。
标识符不能是关键字，但是它可包含一个关键字作为它的名字的一部分。例如，thisone是一个有效标识符，但this却不是，因为this是一个Java关键字。
3.3 Java关键字
表2-1列出了使用在Java编程语言中的关键字。
l abstract do implements private throw
boolean double import protected throws
break else instanceof public transient
byte extends int return true
case false interface short try
catch final long static void
char finally native super volatile
class float new switch while
continue for null synchronized
default if package this
关键字对Java技术编译器有特殊的含义，它们可标识数据类型名或程序构造（construct）名。
以下是有关关键字的重要注意事项：
- true、false和null为小写，而不是象在C++语言中那样为大写。
- 无sizeof运算符；所有类型的长度和表示是固定的，不依赖执行。
- goto和const不是Java编程语言中使用的关键字。
3.4基本Java数据类型
l Java编程语言定义了八种原始数据类型：
类型 位数（bit） 默认值
逻辑型 boolean 1bit false/true
文本型 char 16bit(2byte) 0(Unicode编码)
整数型 byte, 8bit(1byte) 0
short, 16bit(2byte) 0
int, 32bit(4byte) 0
long 64bit(8byte) 0
浮点型 double, 64bit(8byte) 0.0
float 32bit(4byte) 0.0
注意：整数类型默认的是int，浮点型默认的是double
1.1. 逻辑型──boolean
逻辑值有两种状态，即人们经常使用的 “true”和“false”。这样的值是用boolean类型来表示的。boolean有两个文字值，即true和false。
以下是一个有关boolean类型变量的声明和初始化：
boolean truth = true; //declares the variable truth
//as boolean type and assigns it the value true
l 注意：在整数类型和boolean类型之间无转换计算。有些语言（特别值得强调的是C和C++）允许将数字值转换成逻辑值， 这在Java编程语言中是不允许的；boolean类型只允许使用boolean值。
1.2. 字符型──char
使用char类型可表示单个字符。一个char代表一个16-bit无符号的（不分正负的）Unicode字符。一个char文字必须包含在单引号内(‘’)。
l ‘a’
‘/t’ 一个制表符
‘/u????’ 一个特殊的Unicode字符。????应严格按照四个16进制数字进行替换。例如： ’/u03A6’表示希腊字母“Φ”
l Char类型变量的声明和初始化如下所示：
l char ch = `A'; // declares and initializes a char variable
l char ch1,ch2 ; // declares two char variables
1.3. 文本类──String
String不是原始类型，而是一个类（class），它被用来表示字符序列。字符本身符合Unicode标准。与C和C++不同，String不能用 /0作为结束。
l String的文字应用双引号封闭，如下所示：
l “The quick brown fox jumped over the lazy dog.”
l
l String类型变量的声明和初始化如下所示：
l // declare two String variables and initialize them
l String greeting = "Good Morning !! /n" ;
l String err_msg = "Record Not Found !" ;
l String str1,str2 ; // declare two String variables
1.4. 整数型──byte, short, int, long
在Java编程语言中有四种整数类型，它们分别使用关键字byte, short, int和long中的任意一个进行声明。整数类型的文字可使用十进制、八进制和16进制表示，如下所示：
2 十进制值是2
077 首位的0表示这是一个八进制的数值
0xBAAC 首位的0x表示这是一个16进制的数值
l 注意──所有Java编程语言中的整数类型都是带符号的数字。
整数类文字被默认为int类型。
整数类文字后面紧跟着一个字母“L”，可以强制它为long型。
例如：
2L 十进制值是2，是一个long
077L 首位的0表示这是一个八进制的数值
0xBAACL 前缀0x表示这是一个16进制的数值
四种整数类型的长度和范围如表3-2所示。这些长度和范围是按Java编程语言规范定义的，是不依赖于平台。
1.5. 浮点数──float和double
l 如果一个数字文字包括小数点或指数部分，则该数字文字为double型浮点数。
l 例如： 3.14
3.02E23
l 如果一个数字文字后带有字母F或f，则该数字文字为float型浮点数。
例如： 2.718F
l 如果一个数字文字后带有字母D或d，则该数字文字为double型浮点数。
例如： 123.4E-306D
l
l 浮点变量可用关键字float或double来声明。
l Java技术规范的浮点数的格式是由电力电子工程师学会（IEEE）754定义的，是独立于平台的。
2. 变量、声明和赋值
l 变量用于存储信息。一个变量代表一个特殊类型的存储位置，它指向内存的某个单元，而且指明这块内存有多大。变量的值可以是基本类型，也可以是对象。
下列程序显示了如何声明及赋值整数、浮点、boolean、字符和String类型变量。
public class TestAssign {
public static void main(String args []) {
int a, b; // declare int variables
float f = 5.89f; // declare and assign float
double d = 2.78d; // declare and assign double
boolean b = true;// declare and assign boolean
char c; // declare character variable
String str; // declare String
String str1 = "good"; // declare and assign String variable
c = 'A'; // assign value to char variable
str = "hello ,hello"; // assign value to String variable
a = 8;
b = 800; // assign values to int variables
}
}
3. 引用（Reference）类型
从大的范围来讲，JAVA中的数据类型就分为两种：基本类型和引用类型。
3.1. 创建一个新类型
为克服JAVA中数据类型的不完整，Java编程语言使用类来创建新类型。例如可以用下面的类表示人：
class Person {
private double height=1.75;
private double weight=65;
private String name;
public Person(String aName)
{
name=aName;
}
public Person()
{}
}
l 关键字class是用来声明类的。Person是我们给表示人的类指定的名称。
一个变量可被声明为归属于类型Person，从而体重，身高部分将被隐含声明。例如：
Person zhang三, lisi;
zhangsan = new Person ()；//这两个对象为引用类型，zhangsan,lisi 分别指向了各自的对象
lisi = new Person ()；//这两个变量都是引用类型的，并不实际存储这些数据
3.2. 创建并初始化一个对象
l 当任何原始类型(如boolean, byte, short,char,int,long,float或double类型) 的变量被声明时，作为上述操作的一部分，存储器空间也同时被分配。
l 使用非原始类型(如String或class)的变量的声明不为对象分配存储器空间。事实上，使用class类型声明的变量不是数据本身，而是数据的引用(reference)。引用可以理解为C语言的指针（Pointer），但是不能象C语言那样计算指针。
l 在你使用引用变量之前，必须为它分配实际存储空间。这个工作是通过使用关键字new来实现的。如下所示：
Person pangzi;
pangzi= new Person();
第一个语句仅为引用分配了空间，而第二个语句则通过调用对象的构造函数Person（）为对象生成了一个实例。这两个操作被完成后，Person对象的内容则可通过pangzi进行访问。
l 还可以用一条语句创建并初始化一个对象：
l Person pangzi = new Person(“danan”);
3.3. 存储器分配和布局
l 在一个方法体中，做如下声明：
l Person liuxiang；
l liuxiang= new Person();
l 语句Person liuxiang; 仅为一个引用分配存储器
l
liuxiang
|
???? |
|
0x01edaff8 |
liuxiang
|
1.75 |
height
|
65.0 |
weight
|
???? |
name
3.4. 引用类型的赋值
l 在Java编程语言中，一个被类声明的变量，叫做引用类型变量，这是因为它正在引用一个非原始类型，这对赋值具有重要的意义。请看下列代码片段：
int x = 7;
int y = x;
String s = “Hello”;
String t = s;
四个变量被创建：两个原始类型 int 和两个引用类型String。x的值是7，而这个值被复制到y。x 和 y是两个独立的变量且其中任何一个的进一步的变化都不对另外一个构成影响。
至于变量 s 和 t，只有一个String 对象存在, 它包含了文本”Hello” ，s 和 t均引用这个单一的对象。
将变量t 重新定义， t= "World"；则新的对象World被创建，而 t 引用这个对象。上述过程被描述如下：
3.5. 值传递
l 方法只能改变引用类型的值，而不能改变引用类型的地址和基本类型的值。也就是说方法只能改变堆内存中的值，而不能改变栈内存中的值。管是实例变量都是保存在堆内存里的。不引用类型还是基本类型。所有的引用类型的值都是保存在堆内存里的。
l 例如：
l public class TestReference
l {
l int i=5;
l int j=6;
l A a=new A();
l
l public void changeIJ(int m,int n)//试图改变基本类型的参数的值
l {
l int z=0;
l z=m;
l m=n;
l n=z;
l }
l public void changeAB(A a1,A a2 )//试图改变引用类型的参数的地址
l {
l A a=null;
l a=a1;
l a1=a2;
l a2=a;
l }
l public void test(int c) //试图改变基本类型的参数的值
l {
l c=c+6;
l }
l public void testA(A a) //试图改变引用类型参数的值
l {
l a.i=100;
l }
l
l public static void main(String args[])
l {
l TestReference t=new TestReference(); //构造本类的一个对象
l int z=5;
l int y=6;
l A aa=new A(); //定义A类的一个对象aa
l t.testA(aa); //改变对象aa的值
l System.out.println(aa.i); //输出aa的值（属性值）
l A bb=new A(); //再定义A类的一个对象bb
l t.changeIJ(z,y); //试图改变两个基本类型的值
l t.changeAB(aa,bb);// 试图改变两个引用类型的地址
l System.out.println(z);
l System.out.println(y);
l System.out.println(aa.i);
l System.out.println(bb.i);
l }
l }
l class A
l {
l int i=5;
l };
l 输出结果如下：
l 100
l 5
l 6
l 100
l 5
l 可见，方法只能改变引用类型的值，而不能改变引用类型的地址和基本类型的值。
3.6. this引用
l this有两个作用：
1， 代表隐含参数的调用
2， 调用本类的其它的构造器
l 关键字this是用来指向当前对象（类实例）的。这里，this.name指的是当前对象的name字段。
例1，
public class Person {
private double height=1.75;
private double weight=65;
private String name;
public Person(String aName)
{
this.name=aName;//全称应该是：Person.this.name
}
public Person()
{}
}
l 例2，
public class Person {
private double height=1.75;
private double weight=65;
private String name;
public Person(String aName)
{
this.name=aName;//全称应该是：Person.this.name
}
public Person()
{
this(“zhangsan”);
}
}
l
l
4. Java编码约定
l 虽然任何一个合法的标识符都可以用来当作变量、类、方法等的名称，但是Java编程语言极力推荐它的编码约定：
classes──类名应该是名词，大小写可混用，但首字母应大写。例如：
class AccountBook
class ComplexVariable
interface──界面（接口）名大小写规则与类名相同。
interface Account
method──方法名应该是动词，大小写可混用，但首字母应小写。在每个方法名内，大写字母将词分隔并限制使用下划线。例如：
balanceAccount（）
addComplex （）
Variables──所有变量都可大小写混用，但首字符应小写。词由大写字母分隔，限制用下划线，限制使用美元符号（$），因为这个字符对内部类有特殊的含义。
currentCustomer
变量应该代表一定的含义，通过它可传达给读者使用它的意图。尽量避免使用单个字符， 除非是临时“即用即扔”的变量（例如，用i, j, k作为循环控制变量）
l constant──原始常量应该全部大写并用下划线将词分隔；对象常量可大小写混用。
HEAD_COUNT
MAXIMUM_SIZE
l control structures──当语句是控制结构的一部分时，即使是单个语句也应使用括号（｛｝）将语句封闭。例如：
if (condition) ｛
do something
｝
else ｛
do something else
｝
spacing── 每行只写一个语句并使用四个缩进的空格使你的代码更易读。
l comments──用注释来说明那些不明显的代码段落；对一般注释使用 // 分隔符， 而大段的代码可使用 /*···*/分隔符。使用 /**···*/将注释形成文档，并输入给javadoc以生成HTML代码文档。
l
l // A comment that takes up only one line.
l /* Comments that continue past one line and take up space on multiple lines...*/
l /** A comment for documentation purposes.
l @see Another class for more information
l */
5. 练习：使用对象
5.1. 创建一个类和相应的对象
1. 一个点可用x和y坐标描述。定义一个称为Point的类来表达上述想法。
2. 在另一个类MyPoint中声明两个Point变量，将变量称为start和end；用new Point()创建对象并分别将引用值赋予变量start和end；
3. 将值10赋予对象start的成员x和y；
4. 将值20赋予对象end的x值，将值20赋予对象end的y值。
5. 分别打印start和end的成员值(x和y)。
5.2. 检验引用赋值
使用你在前一个练习中MyPoint类，增加代码到main()方法，以完成下列事项：
1. 为类型Point声明一个新的变量，称之为stray。将现存变量end的引用值赋予stray；
2. 打印end和stray变量的成员x和y的值；
3. 赋予变量stray的成员x和y新的值；
4. 打印end和stray的成员的值；编译并运行MyPoint类。end的值反映了stray内的变化，表明两个变量都引用了同一个Point对象；
5. 将start变量的成员x和y赋予新的值；
6. 打印start和end的成员值; 再次编译并运行MyPoint类，start的值仍然独立于stray和end的值，表明start变量仍然在引用一个Point对象，而这个对象与stray和end引用的对象是不同的。
6. 检查你的进度
· 在源程序中使用注释
· 区分有效和无效标识符
· 识别Java技术关键字
· 列出八个原始类型
· 为数字和文本类型定义文字值
· 定义术语class, object,member,variable,referrence variable
· 为一个简单的包含原始成员变量的类创建一个类定义
· 声明类类型的变量
· 使用new构造一个对象
· 描述缺省初始化
· 使用点符号访问一个对象的成员变量
· 描述引用变量的意义
· 陈述分配类类型变量的结果
1192
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
