02_Java基本语法_2

 

2.2.7.1.2 字符类型

字符类型是用单引号扩起来的一个字符，在内存中占2个字节，可以用来保存英文字母等字符。计算机处理字符类型时，是把这些字符当成不同的整数来看待，因此，严格说来，字符类型也算是整数类型的一种，是一种范围更小的整数。

在计算机的世界里，所有的文字、数值都只是一连串的0与1。这些0与1对于设计者来说实在是难以理解，于是就产生了各种方式的编码。它们指定一个数值来代表某个字符，如常用的字符码系统ASCII。

虽然各类的编码系统合起来有数百种之多，却没有一种是包含足够的字符、标点符号及常用的专业技术符号。这些编码系统之间可能还会有相互冲突的情形发生，也就是说，不同的编码系统可能会使用相同的数值来表示不同的字符，在数据跨平台的时候就会发生错误。

Unicode就是为了避免上述情况的发生而产生的，它为每个字符制订了一个唯一的数值，因此在任何的语言、平台、程序中都可以安心地使用。Java 所使用的就是Unicode字符码系统。因此，一个char代表一个16位无符号的Unicode字符。

举例来说，Unicode中的小写a是以97来表示，在下面的程序中可以看到，声明字符类型的变量ch1、ch2，分别将变量ch1的值设为97，ch2的值设为字符a，再输出字符变量ch1及ch2的内容。

范例：TestJava2_7.java

//字符类型也可以直接赋给数值，下面的这段程序就是采用这种赋值方式

public class TestJava2_7
{
    public static void main(String args[])
    {
        char ch1 = 97;

        char ch2 = 'a';

        System.out.println("ch1 = " + ch1);

        System.out.println("ch2 = " + ch2);
    }
}

 

输出结果：

ch1 = a

ch2 = a

给字符变量在赋值可以使用数值和字符，它们都可以使程序正确地运行。要注意的是，字符要用一对单引号（' '）括起来。

举例来说，想在程序中输出一个包括双引号的字符串时，可把字符变量赋值为转义字符，再将它输出来，也就是说，在程序中声明一个字符类型变量ch，然后把ch设置为\"，再进行输出的操作。或者，也可以直接在要输出的字符串中加入特殊的转义字符。表2-4为常用的转义字符：

表2-4  常用的转义字符

 

以下面的程序为例，将ch 赋值为“\"”（要以单引号（'）包围），并将字符变量ch输出在显示器上，同时在打印的字符串里直接加入转义字符，可自行比较一下两种方式的差异。

范例：TestJava2_8.java

//下面这道程序表明了转义字符的使用方法

public class TestJava2_8
{
    public static void main(String args[])
    {
        char ch = ' \" ';

        System.out.println(ch + "测试转义字符！" + ch);

        System.out.println("\"hello world！\"");

    }
}

 

输出结果：

"测试转义字符！"

"hello world！"

不管是用变量存放转义字符，或是直接使用转义字符的方式来输出字符串，程序都可以顺利运行。由于使用变量会占用内存资源，似乎显得有些不妥；当然也可以不必声明字符变量就可以输出转义字符，但如果在程序中加上太多的转移字符，以至于造成混淆而不易阅读时，利用声明字符变量的方式就是一个很好的选择。

特殊的Unicode字符：'\u????'

????应严格按照四个16进制数字进行替换。例如：'\u03A6' 表示希腊字母"Φ"

2.2.7.1.3 浮点类型与双精度浮点类型

在日常生活中经常会使用到小数类型的数值，如身高、体重等需要精确的数值时，整数就不能满足程序设计者的要求了。在数学中，这些带有小数点的数值称为实数，在Java里，这种数据类型称为浮点数类型（float），其长度为4 个字节，有效范围为-3.4×10^38到3.4×10^38。当浮点数的表示范围不够大的时候，还有一种双精度（double）浮点数可供使用。双精度浮点数类型的长度为8个字节，有效范围为-1.7×10^308到1.7×10^308。

浮点数的表示方式，除了指数的形式外，还可用带有小数点的一般形式来表示。举例来说，想声明一个double类型的变量num与一个float类型的变量sum，并同时给sum赋初值3.0，可以在程序中做出如下的声明及设置：

double num;   //声明num为双精度浮点型变量

float sum = 3.0f;//声明sum为浮点型变量，其初值为3.0

声明之后，Java即会在可使用的内存空间中，分配一个占有8个字节的块供num变量使用，其范围在-1.7×10^308到1.7×10^308之间，分配一个占有4个字节的块供sum变量使用，而这个变量的范围只能在-3.4×10^38到3.4×10^38之间。在此例中，sum的初值为3.0。

下列为声明与设置float与double类型的变量时应注意的事项：

double num1 = -6.3e64;  //声明num1为double，其值为-6.3×10^64

double num2 = -5.34E16;  //e也可以用大写的E来取代

float num3 = 7.32f;   //声明num3为float，并设初值为7.32f

float num4 = 2.456E67;  //错误，因为2.456×10^67已超过float可表示的范围

值得一提的是，使用浮点型数值时，默认的类型是double，在数值后面可加上D或是d，作为double类型的标识。在Java中，D或d是可有可无的。在数据后面加上F或是f，则作为float类型的识别。若是没有加上，Java就会将该数据视为double类型，而在编译时就会发生错误，错误提示会告诉设计者可能会失去精确度。另外，在JDK1.5以后，可以使用十六进制表示浮点数，例如：0.125可以表示为0x1.0p-3。十六进制表示法中，p表示指数，而不是e。尾数采用十六进制，指数采用十进制。

下面举一个简单的例子，在下面的程序里，声明一个float类型的变量num，并赋值为3.0，将num*num的运算结构输出到显示器上。

范例：TestJava2_9.java

//下面这道程序说明了浮点数类型的使用方法

public class TestJava2_9
{
    public static void main(String args[])
    {
        float num = 3.0f;

        System.out.println(num + " *" + num + " = " + (num * num));
    }
}

 

输出结果：

3.0 * 3.0 = 9.0

Java也提供了浮点数类型的最大值与最小值的代码，其所使用的类全名与所代表的值的范围，可以在表2-5中查阅：

表2-5  浮点数常量的最值

 

相同的，在类全名中，可以省去类库java.lang，直接取用类名称即可（比如：Float.MAX_VALUE）。下面的程序是输出float 与double两种浮点数类型的最大与最小值，可以将下面程序的输出结果与上表一一进行比较。

范例：TestJava2_10.java

//下面这道程序用于取得单精度和双精度浮点数类型的最大、最小值

public class TestJava2_10
{
    public static void main(String args[])
    {

        System.out.println("float_max = " + java.lang.Float.MAX_VALUE);

        System.out.println("float_min = " + java.lang.Float.MIN_VALUE);

        System.out.println("double_max = " + java.lang.Double.MAX_VALUE);

        System.out.println("double_min = " + java.lang.Double.MIN_VALUE);

    }
}

 

输出结果：

float_max = 3.4028235E38

float_min = 1.4E-45

double_max = 1.7976931348623157E308

double_min = 4.9E-324

2.2.7.1.4 布尔类型

布尔（boolean）类型的变量，只有true（真）和false（假）两种。也就是说，当将一个变量定义成布尔类型时，它的值只能是true或false，除此之外，没有其他的值可以赋值给这个变量。注意：在整数类型和boolean类型之间无转换计算。有些语言（如C和C++）允许将数字值（0,1）转换成逻辑值，这在Java编程语言中是不允许的；boolean类型只允许使用boolean值。

boolean型的值或者变量主要用做标识，用来进行流程控制。

举例来说，想声明名称为status变量为的布尔类型，并设置为true值，可以使用下面的语句：

boolean status = true;   // 声明布尔变量status，并赋值为true

经过声明之后，布尔变量的初值即为true，当然如果在程序中需要更改status的值时，即可以随时更改。将上述的内容写成了程序TestJava2_11，可以先熟悉一下布尔变量的使用：

范例：TestJava2_11.java

//下面的程序声明了一个布尔值类型的变量

public class TestJava2_11
{
    public static void main(String args[])
    {

//声明一布尔型的变量status，布尔型只有两个值一个是true一个是false

        boolean status = true;

        System.out.println("status = " + status);

    }
}

 

输出结果：

status = true

布尔值通常用来控制程序的流程，现在可能会觉得有些抽象，在后面的章节中会给大家介绍布尔值在程序流程中所起的作用。

2.2.7.1.5 基本数据类型的默认值

在Java 中，若声明变量的时候没有给变量赋初值，则变量会有一个默认值，表2-6列出了各种数据类型变量的默认值。

表2-6  基本数据类型的默认值

 

虽然这种方式给程序编写者带来了很多便利，但是过于依赖系统给变量赋初值，就不容易检测到是否已经给予变量应有的值了，所以我们应该尽量做到在程序执行时，不会有这种未定义值的变量存在。另外需要注意的是：在方法外的定义的变量会带默认值。而对于在方法内部定义的变量（局部变量）在使用之前需要手工初始化，否则编译出错。

如果基本的整数和浮点数精度不能满足需求，那么可以使用java.math包中的两个很有用的类：BigInteger和BigDecimal。这两个类可以处理包含任意长度数字序列的数值。BigInteger类实现了任意精度的整数运算，BigDecimal类实现了任意精度的浮点数运算。

使用静态的valueOf方法可以将普通的数值转换为大数值：

BigInteger a = BigInteger.valueOf(100);

遗憾的是，不能使用人们熟悉的运算符（如，+和*）处理大数值。而熬使用大数值类中的add和multiply方法（关于其他方法请参考JDK手册），例如：

BigInteger a = new BigInteger("123233423534552352345234523523523424342");

a = a.multiply(BigInteger.valueOf(2).add(BigInteger.valueOf(1)));//a*=2+1;

System.out.println(a);

我们来看看福利彩票的中奖概率：33个红球中选6个，16个篮球中选1个，其中奖概率为：(6*5*4*3*2*1)/(33*32*31*30*29*28*16)=1/11827200。那么如果是490个号码随机选60个呢？，中奖概率为：

BigInteger num = BigInteger.valueOf(1);

for(int i = 1; i <= 60; i++)

num = num.multiply(BigInteger.valueOf((490-i+1)/i));

System.out.println("中奖概率为：" + num);

2.2.7.2 数据类型的转换

Java的数据类型在定义时就已经确定了，因此不能随意转换成其它的数据类型，但Java允许用户有限度地做类型转换处理。数据类型的转换方式可分为“自动类型转换”及“强制类型转换”两种。

2.2.7.2.1 自动类型转换

在程序中已经定义好了数据类型的变量，若是想用另一种数据类型表示时，Java会在下列的条件皆成立时，自动做数据类型的转换：

1、转换前的数据类型与转换后的类型兼容。

2、转换后的数据类型的表示范围比转换前的类型大。

举例来说，若是想将short类型的变量a转换为int类型，由于short与int皆为整数类型，符合上述条件1；而int的表示范围比short大，亦符合条件2。因此Java会自动将原为short类型的变量a转换为int类型。

数据类型按容量大小排序如下：

 

图2-5  数据类型自动转换规则

在图中有6个实心箭头，表示无信息丢失的转换；有3个虚箭头，表示可能会有精度损失的转换。利用将int数据类型的123456789转换为float类型，此时它所包含的位数比float类型所能精确的有效位数多，转换会丢失一些精度。

值得注意的是，类型的转换只限该行语句，并不会影响原先所定义的变量的类型，而且通过自动类型的转换，可以保证数据的精确度，它不会因为转换而损失数据内容。这种类型的转换方式也称为扩大转换。

前面曾经提到过，若是整数的类型为short或byte，为了避免溢出，Java会将表达式中的short和byte类型自动转换成int类型，即可保证其运算结果的正确性，这也是Java所提供的“扩大转换”功能。但是正因为这样的一种机制，有时会给程序带来一些隐含的错误，比如：

short a, b, c;

a = 1;

b = 2;

c = a + b;//在计算这个表达式的时候，会提升a和b为int，然后又将一个int赋给short，编译会报错。解决方法，将c定义为int或利用强制类型转换。

以“扩大转换”来看可能比较容易理解——字符与整数是可使用自动类型转换的；整数与浮点数亦是兼容的；但是由于boolean类型只能存放true或flase，与整数及字符是不兼容，因此是不可能做类型的转换。接下来看看当两个数中有一个为浮点数时，其运算的结果会有什么样的变化？

范例：TestJava2_12.java 

//下面这段程序声明了两个变量，一个是整型，一个是浮点型

public class TestJava2_12
{
    public static void main(String args[])
    {

        int a = 156;

        float b = 24.1f; // 声明一浮点型变量f，并赋值

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

        System.out.println("a / b = " + (a / b));  // 这里整型会自动转化为浮点型

    }
}

 

输出结果：

a = 156 , b = 24.0

a / b = 6.5

从运行的结果可以看出，当两个数中有一个为浮点数时，其运算的结果会直接转换为浮点数。当表达式中变量的类型不同时，Java会自动以较小的表示范围转换成较大的表示范围后，再作运算。也就是说，假设有一个整数和双精度浮点数作运算时，Java会把整数转换成双精度浮点数后再作运算，运算结果也会变成双精度浮点数。关于表达式的数据类型转换，这里先做简单的说明，在后面的章节中会有更详细的介绍。

表达式类型的自动提升

当一个算术表达式中包含多个基本类型的值时，整个算术表达式的数据类型将发生自动提升，java定义如下的自动提升规则：

·所有byte、short、char将提升到int型

·整个算术表达式的数据类型自动提升到与表达式中最高等级操作数同样的类型

2.2.7.2.2 强制类型转换

当两个整数进行运算时，其运算的结果也会是整数。举例来说，当做整数除法8/3的运算，其结果为整数2，并不是实际的2.6666…，因此在Java中若是想要得到计算的结果是浮点数时，就必须将数据类型做强制性的转换，转换的语法如下：

目标类型  变量  = （目标类型）变量名称;

因为这种强制类型的转换是直接编写在程序代码中的，所以也称为显性转换。下面的程序说明了在Java里，整数与浮点数是如何转换的。

范例：TestJava2_13

//下面范例中说明了自动转换和强制转换这两种转换的使用方法

public class TestJava2_13
{
    public static void main(String args[])
    {

        int a = 55;

        int b = 9;

        float g, h;

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

        g = a / b;

        System.out.println("a / b =" + g + "\n");

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

        h = (float) a / b; //在这里将数据类型进行强制类型转换

        System.out.println("a /b = " + h);

    }
}

 

输出结果：

a = 55 , b = 9

a / b = 6.0

a = 55 , b = 9

a /b = 6.111111

当两个整数相除时，小数点以后的数字会被截断，使得运算的结果保持为整数。但由于这并不是预期的计算结果，而想要得到运算的结果为浮点数，就必须将两个整数中的其中一个（或是两个）强制转换类型为浮点数，下面的三种写法都正确：

（1）(float)a/b //将整数a强制转换成浮点数，再与整数b相除

（2）a/(float)b //将整数b强制转换成浮点数，再以整数a除之

（3）(float)a/(float)b //将整数a与b同时强制转换成浮点数，再相除

只要在变量前面加上欲转换的数据类型，运行时就会自动将此行语句里的变量做类型转换的处理，但这并不影响原先所定义的数据类型。

此外，若是将一个超出该变量可表示范围的值赋值给这个变量时，这种转换称为缩小转换。由于在转换的过程中可能会丢失数据的精确度，Java并不会自动做这些类型的转换，此时就必须要做强制性的转换。

通常而言，将float或double类型的转换为整型的时候，会截断小数部分，如果想对浮点数进行舍入运算，以便得到最接近的整数，那就需要用到Math类的round方法，比如：

double x = 9.997;

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

通过查看JDK帮助手册，在Math类中，包含了各种各样的数学函数和两个常量（PI和E）。其中Math.random方法将返回一个0到1之间的随机浮点数（包含0、不包含1）。可以利用n乘以这个浮点值，就可以得到从0到n-1之间的随机数了。例如，可以利用下面的代码，帮我们随机的选出福彩的6个红号：

        int a[] = new int[6];

        for (int i = 1; i <= 6; i++)
        {

            a[i - 1] = (int) (Math.random() * 33 + 1);//产生1到33中的随机数

            for (int j = 0; j < i - 1; j++)
            {

                if (a[i - 1] == a[j])

                {
                    i--;
                }
            }

        }

        for (int iVal : a)
        {
            System.out.println(iVal);
        }

 

其他Math类的API方法具体的请参考JDK帮助手册。

2.2.7.5 引用类型

Java语言中除8种基本数据类型以外的数据类型称为引用类型；引用类型数据以对象的形式存在；引用类型变量的值是某个对象的句柄(指针)，而不是对象本身；声明引用类型变量时，系统只为该变量分配引用空间，并未创建一个具体的对象。具体的后面介绍。

2.2.8 变量

到目前为止，相信大家已经对Java有了一些初步的认识，如果想在程序中使用一个变量，就必须先声明，此时编译程序会在未使用的内存空间中寻找一块足够能保存这个变量的空间以供这个变量使用。

在程序的运行过程中，其值可以改变的量称为变量。变量在内存中占据一定的存储单元，用来存放该变量的值。变量由变量类型、变量名、变量值组成。变量的类型表明该变量用来存储什么类型的数据，变量名用来区分不同的变量，在同一作用域里变量名不能重复，在变量的存储单元中存放的值为变量值。在使用一个变量之前，必须要先定义，即“先定义，后使用”的原则（为什么要先定义？原因：变量定义是为变量指定数据类型，这样编译时就能在内存中分配相应的存储单元）。

接下来，来看看在Java中变量的使用规则。

2.2.8.1 变量的声明

变量定义的一般格式：

数据类型 变量名1[＝ 初始值1], 变量名2[＝ 初始值2], ...;

举例来说，想在程序中声明一个可以存放整数的变量，这个变量的名称为num，在程序中即可写出如下所示的语句：

int num; //声明num为整数变量

int为Java的关键字，代表整数（Integer）的声明。若要同时声明多个整型的变量，可以像上面的语句一样分别声明它们，也可以把它们都写在同一个语句中，每个变量之间以逗号分开，如下面的写法：

int num, num1, num2;   //同时声明num, num1, num2为整数变量

2.2.8.2 变量的数据类型

除了整数类型之外，Java还提供了多种其它的数据类型。Java的变量类型可以是整型（int）、长整型（long）、短整型（short）、浮点型（float）、双精度浮点型（double）等，除了这些数据类型外，还有字符型（char）或字符串型（String）。关于这些数据类型，在第三章中有详细的介绍。

2.2.8.3 变量名称

可以依据个人的喜好来决定变量的名称，这些变量的名称不能使用Java的关键字。变量的命名要尽量做到“顾名思义”。通常会以变量所代表的意义来取名，（如num代表数字）。当然也可以使用a、b、c等简单的英文字母代表变量，但是当程序很大时，需要的变量数量会很多，这些简单名称所代表的意义就比较容易忘记，必然会增加阅读及调试程序的困难度。另外，变量名是区分大小写的。

2.2.8.4 变量的设置

给所声明的变量赋予一个属于它的值，用等号运算符（=）来实现。具体可使用如下所示的两种方法进行设置：

方法1 —— 在声明变量的时设置，也叫变量的初始化

举例来说，在程序中声明一个整数的变量num，并直接把这个变量赋值为2，可以在程序中写出如下的语句：

int num = 2;   //声明变量，并直接设置为2

方法2 —— 声明后再设置

一般来说也可以在声明后再给变量赋值。举例来说，在程序中声明整数的变量num1、num2及字符变量ch，并且给它们分别赋值，在程序中即可写出如下面的语句：

int num1, num2; //声明变量

char c;

 num1 = 2;     //赋值给变量

 num2 = 3;

 ch = 'z';

2.2.9 常量

在程序运行过程中，其值不能被改变的量称为常量。在Java中，利用final声明常量。例如：

final double PRICE = 2.54;

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

在Java中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量声明为类常量。可以使用public static final设置一个类常量。实例如下：

范例：TestJava2_14.java 

public class TestJava2_14
{

    public static final double PRICE = 2.54;

    public static void main(String args[])
    {

        int num = 30;

        System.out.println("总价为:" + (num * PRICE));

    }

}

 

　　需要注意，类常量的定义位于main方法的外部。因此，在同一个类的其他方法中也可以使用这个常量。而且如果一个常量被声明为public，那么其他类的方法也可以使用这个常量，通过“类.常量”的形式。

 

感谢阅读。如果感觉此章对您有帮助，却又不想白瞟