技术源 WWW.JOCK168.COM
第四章 Java语法基本语法(上)

发布于:2015-03-18 16:21亚博vip手机版网页:

 

4.1 类型

    Java中大体上可分为两大类型:基本数据类型(Primitive Type)和引用数据类型(Reference Type)。本章先介绍基本数据类型。
    基本数据类型是Java内置类型,是不同于类类型的特殊类型。它们在内存中的长度是不一样的,由JVM自动分配和管理。在Java中基本数据类型可分为字符型,整数、浮点数和布尔型。
    字符型:char类型长度为16位(2个字节),采用Unicode编码来存储用单引号引起来的单个字符,如:'A'、'a'、'男'等。每个字符类型占用两个字节,而一个汉字在Java中同样也是用两个字节来储存,所以字符型可以存储单个汉字。
    整数:可细分为字节、短整型、整型和长整型。
        字节:byte类型,长度为8位(1个字节),最大存储数据为255,存放的数据范围是-128 ~ 127之间。
        短整型:short类型,长度为16位(2个字节),最大存储数据为65536,存放的数据范围是-32768~32767之间。
        整型:int类型,长度为32位(4个字节),最大存储数据为2^32-1,存放数据范围是-2^31 ~ 2^31-1之间。
        长整型:long类型,长度为64位(8个字节),最大存储数据为2^64-1,存放数据范围是-2^63 ~ 2^63-1之间。

    浮点数:可细分为单精度和双精度。
        单精度:float类型,长度为32位(4个字节),存放数据范围是-3.4x10^38 ~ 3.4x10^38之间。
        双精度:double类型,长度为64位(8个字节)存放数据范围是-1.7x10^308 ~ 1.7x10^308之间。
    布尔:boolean类型,只有true和false两个值,分别表示“真”和“假”。在Java中不用考虑这处类型的长度,因为无法用boolean类型来运算,而是作为判断来使用。

4.2 标识符

    由字母、数字、下划线和$符组成。标识符不能以数字开头,不能是Java中的关键词。标识符包含包名、类名、变量、方法、常量等。
    包名:由多个单词组成,所有字母都是小写,目录之间用小点“.”连接。如:com.jock168
    类名:由单个或多个单词组成,每个单词首字母大写,其余字母小写。如:Person、StudentName等。
    变量和方法:由单个或多个单词组成,单个单词小写,多个单词第一个单词小写其后每个单词首字母大写。如:main、getName等。
    常量:由单个或多个单词组成,单词与单词之间用下划线连接,所有字母全部大写。如:COUNT、MY_COUNTRY等。

4.3 变量

    假设有一需求是计算半径为2的圆的面积,程序代码编写如下:
    范例:Circle.java

    public class Circle{
        public static void main(String[] args){
            System.out.println(2*2*3.14);
        }
    }

    现需求发生了变化,需要分别计算半径为2和4的两个圆面积,则程序代码应改为如下所示:
    范例:Circle.java

    public class Circle{
        public static void main(String[] args){
            System.out.println(2*2*3.14);
            System.out.println(4*4*3.14);
        }
    }

    从上面代码不难看出,两个都同时用到了3.14这个值,假想程序中有很多地方用到了3.14这个值,后来发现精度还需要提高,要变为3.14159来计算,那么很多地方都要去修改,这样的话太麻烦。有没有办法做到我只改一个地方,别的使用到它的值都根着变呢?答案是肯定的,可以定义一个变量来存放3.14这个值,然后其它地方就引用这个变量就可以了。代码修改如下:
    范例:Circle.java

    public class Circle{
        public static void main(String[] args){
            float PI = 3.14f; //定义float类型变量
            System.out.println(2*2*PI);
            System.out.println(4*4*PI);
        }
    }

    变量在程序语言中扮演了非常重要的角色。变量可以用来存放数据,而使用变量之前必须先声明它所预保存的数据类型。变量命名的风格主要以清楚易懂为主,当然还需要符合命名规则(标识符一节中已经介绍)。定义变量尽量做到让人一看就明白其意义或作用。定义变量有以下几种方式:
    1. 变量类型 变量名;

       int num; //声明整型变量num
       num = 10; //给变量赋值

    2. 变量类型 变量名1,变量名2,...变量名n;

       int num1,num2,num3; //同时定义三个整型变量
       num1 = 2;
       num2 = 8;
       num3 = 3;

    3. 变量类型 变量名 = 变量值;

       int ageOfStudent = 21;//定义学生年龄

    注:在使用变量之前,一定要给变量赋值。

    在Java SE 7之后,定义整数或浮点数常量时可以使用下划线更清楚地表示某些数字。示例如下:

        int number = 1234_5678;
        double pi = 3.141_592_653;


4.4 注释

    为了描述程序中某些语句的作用或功能,提高程序的可读性,通常会在该语句或该功能前加上一些描述性的文字,这些文件称之为注释。
    Java中注释根据不同的用途分为三种类型:

  •     单行注释

  •     多行注释

  •     文档注释


  •     单行注释,就是在注释内容前面加双斜线(//)来表示,Java编译器人忽略掉这部分信息。代码如下所示:

        int num;   //定义一个变量名num的整型变量


        多行注释,就是在注释内容前面以单斜线加一个星形标记(/*)开头,并在注释内容末尾以一个星形标记加单斜线(*/)结束。当注释内容超过一行时一般使用这种方式。代码如下所示:
        范例:Demo.java

        public class Demo{
            /*
               这是Java程序的入口方法
             */
            public static void main(String[] args){
                System.out.println(5);
            }
        }

        文档注释,是以单斜线加两个星形标记(/**)开头,并以一个星形标记加单斜线(*/)结束。用这种方式注释的内容会被解释成程序的正式文档,并能包含进如javadoc之类的工具生成的文档里,用以说明该程序的层次结构及其方法。代码如下所示:
        范例:Demo.java

        public class Demo{
            /**
               这段文字会出现在JavaDoc文档中
             */
            public static void main(String[] args){
                System.out.println(5);
            }
        }


    4.5 运算符

        程序的目的其实就是运算,而程序语言中提供运算功能的就是运算符。

        1. 算术运算

        与算术相关的运算符+、-、*、/(加、减、乘、除),另外%称为取模运算符。算术运算符使用上与数学上的运算一样,先乘除后加减。代码如下所示:

            System.out.println(1 + 2 * 3 - 4); //结果为3
            System.out.println(1 - 4 / 2 + 3); //结果为2

        %运算符计算的结果是除法后的余数,代码如下所示:

            System.out.println(5 % 2); //结果为1


        2.比较运算符

        数学上有大于、等于、小于的比较运算,Java中也提供了这些运算符,这些运算符称为比较运算符。它们分别是大于(>)、大于等于(>=)、小于(<)、小于等于(<=)、等于(==)、不等于(!=)等。使用示例代码如下:
        范例:ConditionalOperator.java

        public class ConditionalOperator{
            public static void main(String[] args){
                System.out.println("6 > 3 = " + (6 > 3));
                System.out.println("6 >= 3 = " + (6 >= 3));
                System.out.println("6 < 3 = " + (6 < 3));
                System.out.println("6 <= 3 = " + (6 <= 3));
                System.out.println("6 == 3 = " + (6 == 3));
                System.out.println("6 != 3 = " + (6 != 3));
            }
        }


        输出结果为:


        6 > 3 = true
        6 >= 3 = true
        6 < 3 = false
        6 <= 3 = false
        6 == 3 = false
        6 != 3 = true

        Java中还支持三元运算符,使用方式如下:


            条件表达式 ? 为true返回值 : 为false返回值;


        当条件表达式的结果为真(true)时,结果为“:”前的值,反之结果为“:”后的值。示例代码如下:

        System.out.println(6 > 3 ? 6 : 3); //结果为6
        System.out.println(6 < 3 ? 6 : 3); //结果为3


        3. 逻辑运算

        逻辑上有“与”(AND)、“或”(OR)、“非”(NOT),Java中也提供对应逻辑关系运算符,分别为“&&”(AND)、“||”(OR)、“!”(NOT)。使用示例代码如下:
        范例:LogicalOperator.java

        public class LogicalOperator{
            public static void main(String[] args){
                int age = 20;
                System.out.println(age > 18 && age < 25);
                System.out.println(age > 20 && age < 22);
                System.out.println(age > 18 || age < 20);
                System.out.println(age > 20 || age < 22);
                System.out.println(!(age > 20 || age < 22));
            }
        }

        运行结果为:


            true
            false
            true
            true
            false

        对于“&&”和“||”来说,它们除了进行逻辑运算外,还有短路效果。因为与(AND)只要其中一个为false,结果就必然为false。所以对于“&&”来说,只要左操作数为false,就会直接返回false,不会再去运算右操作数。而或(OR)只要其中一个为true,结果必然为true。所以对于“||”来说,只要左操作数为true,就会直接返回true,而不会再去操作右操作数。程序示例代码如下:
        范例:LogicalDemo.java

        public class LogicalDemo{
            public static void main(String[] args){
                int num1 = 2;
                int num2 = 0;
                if(num1 == 0 && num1 / num2 > 2){
                    System.out.println("这句不会输出");
                }
            }
        }


        4. 位运算

        在Java中提供了对位运算的支持,它们分别是&(与)、|(或)、^(异或)、~(补码)。使用示例代码如下:
        范例:BitwiseOperator.java

        public class BitwiseOperator{
            public static void main(String[] args){
                System.out.println("0 & 0" + (0 & 0));
                System.out.println("0 & 1" + (0 & 1));
                System.out.println("1 & 0" + (1 & 0));
                System.out.println("1 & 1" + (1 & 1));
                System.out.println();
                System.out.println("0 | 0" + (0 | 0));
                System.out.println("0 | 1" + (0 | 1));
                System.out.println("1 | 0" + (1 | 0));
                System.out.println("1 | 1" + (1 | 1));
                System.out.println();
                System.out.println("0 ^ 0" + (0 ^ 0));
                System.out.println("0 ^ 1" + (0 ^ 1));
                System.out.println("1 ^ 0" + (1 ^ 0));
                System.out.println("1 ^ 1" + (1 ^ 1));
            }
        }


        程序运行结果为:


        0 & 0 = 0
        0 & 1 = 0
        1 & 0 = 0
        1 & 1 = 1

        0 | 0 = 0
        0 | 1 = 1
        1 | 0 = 1
        1 | 1 = 1

        0 ^ 0 = 0
        0 ^ 1 = 1
        1 ^ 0 = 1
        1 ^ 1 = 0

        位运算是逐位进行运算的。例如:10010001与01000001做AND(&)运算,是一个一个位对应运算,相同为1,不相同为0,所以答案就是00000001;而10010001与01000001做OR(|)运算,也是一个一个位对应运算,只有都为0是才为0,否则为1,所以答案就是10010001;而补码运算是将所有位0变1而1变0,所以10010001的补码运算结果为01101110。

        除了上面几种位运算外,Java还提供了左移(<<)、右移(>>)和无符号右移(>>>)三个运算符。
        左移运算符会将所有位往左边移动指定位数,左边被挤出去的位会被丢弃,而右边补上0;右移运算则相反,会将所有位往右边移动指定位数,右边被挤出去的位会被丢弃,左边则补上原来的位,如果左边原来为0就补0,原来为1就补1;而>>>运算符是在右移后,最左边永远补0。
        范例:Shift.java

        public class Shift{
            public static void main(String[] args){
                int number = 1;
                System.out.println("2的0次方为:"+number);
                System.out.println("2的1次方为:"+(number<<1));
                System.out.println("2的2次方为:"+(number<<2));
                System.out.println("2的3次方为:"+(number<<3));
            }
        }


        程序运行结果为:


        2的0次方为:1
        2的1次方为:2
        2的2次方为:4
        2的3次方为:8

        5. 递增递减运算符

        在程序中,对某个变量做加1或减1的操作是很常见的,特别是后面中介绍的循环操作。示例代码如下:

        int i = 0;
        System.out.println(i++); //输出0
        System.out.println(i--); //输出1
        int j = 0;
        System.out.println(++j); //输出1
        System.out.println(--j); //输出0


        对于++在变量之后,是先输出变量的值,然后变量自身再执行加1操作;而++在变量之前是先执行加1操作,然后再输出变量的值。--操作和++操作一样,--在后先输出变量的值,然后变量自身再执行减1操作;而--在变量之前是先执行变量减1操作,然后再输出变量的值。

        6. 赋值运行符

    赋值运行符
    示例
    结果
    +=
    a += b
    a = a + b
    -=
    a -= b
    a = a - b
    *=
    a *= b
    a = a * b
    /=
    a /= b
    a = a / b
    %=
    a %= b
    a = a % b
    &=
    a &= b
    a = a & b
    |=
    a |= b
    a = a | b
    ^=
    a ^= b
    a = a ^ b
    <<=
    a <<= b
    a = a << b
    >>=
    a >>= b
    a = a >> b


        7. 基本数据类型的默认值

        在Java中,如果变量在声明时没有给变量赋初值,则会给该变量赋默认值,默认值如下表所示:
       

    数据类型
    默认值
    byte
    (byte)0
    short
    (short)0
    int
    0
    long
    0L
    float
    0.0f
    double
    0.0d
    char
    \u000(空)
    boolean
    false


        8. 数据类型转换

        Java中的数据类型在定义变量时已经确定,因此不能随意转换成别的数据类型。但是在开发过程中,不能避免会遇到要进行数据类型转换。因此,Java中提供了“向上类型转换”和“向下类型转换”两种。

        向上类型转换
        这种转换也叫“自动类型转换”。这种转换必须符合两个条件:第一个条件是转换前的数据类型与转换后的类型兼容;第二个条件是转换后的数据类型的表示范围比转换前的类型大。这种转换一般发生在小范围的类型和大范围的类型进行操作时。示例代码如下:
        范例:TypeConversion.java

        public class TypeConversion{
            public static void main(String[] args){
                short a = 10;
                int b = 20;
                int sum = a + b;
                System.out.println(sum);
            }
        }


        本例的输出结果为30。先来分析一下这段代码:首先程序第3行定义了short类型的变量a,第4行定义了int类型的变量b,第5行执行了两个变量相加操作。由于short与int都是整数类型,符合第一个条件;而int的表示范围比short大,也符合第二个条件。因此Java会自动将原short类型的变量a转换为int类型,这时就是两个int类型的数据进行相加操作,所以结果为int类型。
        如果一个short类型的整数和一个byte类型的整数进行操作,为了避免溢出,Java会将表达式中的short类型和byte类型都自动转换为int类型后再进行操作,结果也就int类型而不是short类型。

        向下类型转换
        这种类型转换也叫“强制类型转换”。转换的语法为:

        (欲转换的类型)变量名称;

        还是以上例为例来说明,如果想把变量a和变量b相加后的结果变为short类型的sum,就需要在结果的前面加上“(short)”来处理。示例代码如下:
        范例:TypeConversion.java

        public class TypeConversion{
            public static void main(String[] args){
                short a = 10;
                int b = 20;
                short sum = (short)(a + b);
                System.out.println(sum);
            }
        }


     
  • 链接

  • 百度
  • 新浪
  •