Java基础02—变量运算符和数据类型转换

Posted 2021-02-19 xuliang-daydayup

Java语言基础

---

参考资料：《Java从入门到精通》/明日科技编著. 4版. 北京：清华大学出版社，2016

一、变量与常量

• 常量：在程序执行过程中，其值不能改变的量称为常量。
• 变量：在程序执行过程中，其值能被改变的量称为变量。
• 变量与常量的命名都必须使用合法的标识符。

1、标识符与关键字

（1）标识符

• 标识符可以简单地理解为一个名字，用来给类、变量、方法、文件等进行命名的有效字符序列。
• Java语言规定标识符只能由字母、数字、美元符号（$）、下划线（_）组成，并且第一个字符不能是数字。
• 标识符不能是Java中保留的关键字。

//合法的标识符
name
user_id
$age

//非法的标识符
5userid
class
user name 

注意：Java语言中的标识符严格区分大小写，如Good和good是不同的标识符。

（2）关键字

• 关键字是Java语言中已经被赋予特定意义的单词，不能把这些单词作为标识符来使用。
• 比如public、class、int等都是关键词。

2、声明变量

• 也叫做定义变量，就是告诉编译器这个变量的数据类型，这样编译器才能分配多少空间给它，以及它能存放什么样的数据。
• 定义变量时可以赋予初值，也可以不赋予。

int age；     //定义变量，但不赋予初始值
char c1 = ‘a‘;

变量的命名不是随意的，应该遵循如下准则：

• 变量名必须是一个有效的标识符；
• 变量名不可以使用Java语言的关键字；
• 变量名不可以重复；
• 应该选择有意义的单词作为变量名。

3、声明常量

在声明一个常量时，除了要指定数据类型外，还需要final关键词进行限定。

final double PI = 3.1415926D;   //声明常量
final boolean results = true;

• 常量通常使用大写字母表示，但这并不是强制要求。
• 常量在整个程序中只能被赋予一次。
• 当定义的final变量属于“全局变量”时，必须在定义时就赋予它初始值，否则会产生编译错误。

public class Part {
    static final double PI = 3.14D;   //必须定义初始值
    static int age ;
    
    public static void main(String[] args) {
        final int number;
        number = 12345;
        age = 12;
        //number = 2345;     //错误代码，常量只能被赋予一次
        System.out.println(PI);
        System.out.println(number);
        System.out.println(age);

    }
}

3、 变量的有效范围

由于变量被定义出来后只是暂存于内存中，等程序执行到某一个点，该变量会被释放掉，也就是说变量有它的生命周期。因此，变量的有效范围是指程序代码能够访问的区域，若超出该区域，则在编译时就会出错。在程序中，一般根据变量的有效范围，将变量分为“成员变量”和“局部变量”。

（1）成员变量

• 在类体中定义的变量称为成员变量，成员变量在整个类中都有效。
• 类的成员变量又可分为两种，即静态变量和实例变量。注意：前提是成员变量

class var{
    int x = 45;    //实例变量
    static int y = 34;   //静态变量
}

• 静态变量的有效范围可以跨类，甚至可以达到整个应用程序之内。
• 对于静态变量，除了能在定义它的类中存取，还可以直接以“类名.静态变量”的方式在其他类中使用。

（2）局部变量

• 在类的方法中定义的变量称为局部变量。局部变量只在当前代码块中有效。
• 局部变量可与成员变量同名，此时成员变量被隐藏，即这个成员变量在此方法中暂时失效。

public class Val {
    static int times = 3;    //成员变量
    public static void main(String[] args) {
        int times =123;     //局部变量
        System.out.println(times);    //输出123
    }
}

二、运算符

运算符是一些特殊的符号，主要用于数学函数、一些类型的赋值运算和逻辑比较等方面。

1、赋值运算符

赋值运算符以等号“=”表示，是程序开发中最常见的操作，它是一个二元运算符（对两个操作数作处理），其功能是将右方的数值赋予个左方。例如：

int a = 10;    //赋值操作

赋值运算会先取得右方表达式处理的结果，因此，一个表示式中若含有两个及以上的“=”运算符，会从最右的“=”开始处理。

int a = b = c =15;

2、算数运算符

• Java中的算数运算符主要有+（加）、-（减）、*（乘）、/（除）、%（求余），它们都是二元运算符。
• 其中，“+”和“-”运算符还可以作为数据的正负号，如+5、-7。

public class Arith {
    public static void main(String[] args) {
        int num1 = 12;
        float num2 = 2.4f;
        double num3 = 2.4;
        System.out.println(num1 + num2);   //加
        System.out.println(num1 - num2);   //减
        System.out.println(num1 * num2);   //乘
        System.out.println(num1 / num2);   //除
    }
}

3、自增和自减运算符

• 自增和自减是单目运算符，可以放在操作元之前，也可以放在操作元之后。
• 操作元必须是一个整型或浮点型变量。
• 放在前面的自增或自减，会先将变量的值加1或减1，然后再使变量参与表达式的运算。
• 放在后面的自增或自减，会使变量参与表达式的运算，然后再将变量加1或减1。

int a = 5；
b = ++a   //先将变量a的值加1，然后赋予b，此时a=6，b=6
b = a++   //先将变量a的值赋给b，然后a的值加1，此时a=6，b=5

4、比较运算符

• 比较运算符属于二元运算符，用于程序中的变量之间、变量和自变量之间以及其他类型的信息之间的比较。
• 比较运算符的运算结果是boolean型。当运算对应的关系成立时，运算结果为true，否则结果为false。

比较运算符总有6个，如下所示：

运算符	作用
>	是否大于
<	是否小于
==	是否等于
>=	是否大于等于
<=	是否小于等于
!=	是否不等于

public class Compare {
    public static void main(String[] args) {
        int num1 = 4;
        int num2 = 5;
        System.out.println(num1 > num2);   //输出false
        System.out.println(num1 < num2);   //输出true
        System.out.println(num1 == num2);  //输出false
        System.out.println(num1 != num2);  //输出true
    }
}

5、逻辑运算符

• 逻辑运算符包括&&/&（逻辑与）、||（逻辑或）、!（逻辑非）。
• 逻辑操作符的操作对象必须是boolean型数据。

运算符	含义	用法	结合方向
&&、&	逻辑与	a && b	从左到右
||	逻辑或	a || b	从左到右
!	逻辑非	!a	从右到左

逻辑与符号“&&”与“&”之间的区别：

表达式1  &  表达式2     //会判断两个表达式的boolean值
表达式1  &&  表达式2    //当表达式1的boolean值为false，则直接输出结果

public class Calculation {
    public static void main(String[] args) {
        int a = 2;
        int b = 5;
        boolean result1 = (a > b) && (a != b);
        boolean result2 = (a > b) || (a != b);
        System.out.println(result1);    //输出为false
        System.out.println(result2);    //输出为true
    }
}

6、位运算

整型数据在内存中以二进制的形式表示，如int型变量7的二进制表示为00000000 00000000 00000000 00000111（32位）。左边最高位是符号位，0表示正数，1表示负数。在内存中，负数采用补码的形式表示，如-8的二进制表示为11111111 11111111 11111111 11111000（32位）。

（1）按位与运算

• 按位与运算符为“&”，为双目运算。
• 运算规则：对应位都为1，结果为1，否则为0。
• 如果两个操作数的精度不同，则结果的精度与精度高的操作数相同。

int result3 = 5 & -4;   
System.out.println(result3);    //输出为4

（2）按位或运算

• 按位或的运算符为“|”，为双目运算。
• 运算规则：对应位都是0，结果才为0，否则为1。
• 如果两个操作数的精度不同，则结果的精度与精度高的操作数相同。

int result4 = 3 | 6;
System.out.println(result4);   //输出为7

（3）按位取反运算

• 按位取反运算也称按位非运算，运算符为“~”，为单目运算。
• 运算规则：就是将0改成1，1改成0。

int result5 = ~7;
System.out.println(result5);   //输出为-8

（4）按位异或运算

• 运算符为“^”，双目运算。
• 运算规则：同时为1或0时，结果为0，否则为1。
• 如果两个操作数的精度不同，则结果的精度与精度高的操作数相同。

int result6 = 10 ^ 3;
System.out.println(result6);    //输出为9

（5）移位操作

移位符有三种：

• << ：左移
• >> ：右移
• >>> ： 无符号右移

1. 左移就是将运算符左边的操作数的二进制数据按照指定的位数向左移动，右边移空的部分补0。
2. 右移复杂一些，如果高位是0，右移空的位置就填入0；如果高位是1，右移空的位置就填入1。
3. 无符号右移是指，无论高位是0还是1，被移空的高位都填入0。

        int x, y;
        int n = 2;
        x = n << 1;    //左移1位
        y = n << 2;    //左移2位
        System.out.println(x);    //输出为4
        System.out.println(y);    //输出为8

注意：移位操作符适合的数据类型有byte、int、short、long和char。

技巧：移位操作可以实现整数乘以2或除以2的效果，向左移一位就是乘以2，左移两位就是乘以4。

（6）三元运算符

• 三元运算符的使用格式为：条件式? 值1 : 值2
• 运算规则为：若条件表达式的值为true，则整个表达式取值1，否则取值2。

boolean b1 = 4 < 5? true : false;
int b2 = 4 < 5? 12 : 34;
char b3 = 4 < 5? ‘q‘ : ‘w‘;
System.out.println(b1);     //输出为true
System.out.println(b2);     //输出为12
System.out.println(b3);     //输出为q

（7）运算优先级

运算符的优先级决定了表达式中运算执行的先后顺序，通常优先级由高到底的顺序依次是：

• 增量和减量运算（++a或--a）
• 算数运算（*、/、+、-）
• 比较运算（>、<、>=、<=）
• 逻辑运算（&&、||）
• 赋值运算（=）

二、数据类型转换

类型转换是将一个值从一种类型变更为另一种类型的过程。

• 从低精度数据类型向高精度数据类型转换，则永远不会溢出，并且总是成功的；
• 把高精度数据类型向低精度数据类型转换，则必然会有信息丢失，有可能失败；
• 数据类型的转换有两种方式，即隐式转换与显示转换。

1、隐式类型转换

隐式类型转换是指从低级类型到高级类型的转换，系统将自动进行，程序员无须进行任何操作。

• 数据类型按精度从低到高的顺序排列：byte < short < int < long < float < double。

int x = 50;
float y = x;    //int型隐式转换为float型
System.out.println(y);   //输出为50.0

public class Conver {
    public static void main(String[] args) {
        byte mybyte = 12;
        int myint = 150;
        float myfloat = 234.34f;
        char mychar = 33;
        double mydouble = 21.2331234;
        System.out.println(mybyte + myfloat);  //转换为float型
        System.out.println(mybyte + myint);    //转换为int型
        System.out.println(mybyte + mychar);    //转换为int型
        System.out.println(mybyte + mydouble);   //转换为double型
    }
}

注意：Java中涉及到Byte，char和short类型的运算时，都会把这些类型提升为int类型，然后对int类型数值进行运算，最后得到int类型的结果。因此。两个byte型的运算最终得到int型。

2、显示类型转换

当把高精度的变量的值赋给低精度的变量时，必须使用显示类型转换运算，又称强制类型转换。

• 语法：（要转换的类型名）要转换的变量。

int a = (int)43.23;
System.out.println(a);   //输出为43

long b = (long)424.2313F;
System.out.println(b);   //输出为424

int c = (int)‘c‘;
System.out.println(c);   //输出为99

• 当执行显示转换时，可能会导致精度损失。
• 除了boolean类型，其他类型都能以显示转换的方式达到。

说明：当把一个整数赋值给byte、short、int、long型变量时，不可以超过这些变量的取值范围，否则必须进行强制类型转换。

byte b = (byte)129;
System.out.println(b);  //输出为-127

三、代码注释与编码规范

在代码中适当地添加注释可以提高程序的可读性和可维护性，好的编码规范可以时程序更加容易理解。

1、代码注释

Java语言提供了三种添加注释的方法，分别是单行注释、多行注释和文档注释。

（1）单行注释

“//”为单行注释的符号，从“//”开始到换行为止的所有内容均作为注释信息。

int age =12;   //定义一个age变量

（2）多行注释

“/**/”为多行注释的符号，符号“/*”和“*/”之间的所有内容均为注释信息，注释信息可以换行。

/*
注释信息1
注释信息2   
注释信息3
*/

• 在多行注释可以嵌套单行注释。
• 在多行注释里不可以嵌套多行注释。

（3）文档注释

“/** */”为文档注释的符号，符号“/**”与“*/”之间的内为文档注释内容。当文档注释出现在声明之前时，如类的声明、成员变量的声明、成员方法的声明等，会被javadoc文档工具读取作为javadoc文档的内容。