初识Java以及一些常见的数据类型与运算符(下)

文章目录

• • 初识Java以及一些常见的数据类型与运算符(下)
  • • 1.布尔类型变量
    • 2.字符串类型变量（重点）
    • 3.变量的作用域
    • 4.变量的命名规则
    • 5.常量
    • • 5.1 字面值常量
      • 5.2 final关键字修饰的常量
    • 6.类型转换
    • 7.数值提升
    • 8.int和String之间的相互转换
    • 9.算术运算符
    • 10.关系运算符
    • 11.逻辑运算符
    • 12.位运算符
    • 13.条件运算符
    • 14.小结
    • 13.条件运算符
    • 14.小结

初识Java以及一些常见的数据类型与运算符(下) 1.布尔类型变量

基本语法格式：

boolean 变量名 = 初始值

代码示例：

boolean flg=true;
System.out.println(flg);
        
boolean flg2=false;
System.out.println(flg2);

注意事项：

1. boolean类型的变量只有两种取值，true表示真，false表示假。
2. Java的boolean类型和int不能相互转换，不存在1表示true，0表示false这样的用法。
3. boolean类型有些JVM的实现是占一个字节，有些是占1个比特位，这个没有明确规定。

2.字符串类型变量（重点）

把一些字符放到一起就构成了字符串

基本语法格式：

String 变量名 = "初始值"；

代码示例：

String name = "zhangsan";
System.out.println(name);

注意事项：

1. Java使用双引号+若干字符的方式表示字符串字面值。
2. 和上面的类型不同，String不是基本类型，而是引用类型（后面重点解释）。
3. 字符串中的一些特定的不太方便直接表示的字符需要进行转义。

转义字符示例：

//创建一个字符串 My name is "张三"
String name = "My name is "张三"";

转义字符有很多，其中比较常见的如下：

转义字符	解释
n	换行
t	水平制表符
’	单引号
"	双引号
\	反斜杠

字符串+操作，表示字符串拼接：

public class TestDemo {
    public static void main(String[] args) {
        String name = "zhangsan";
        System.out.println(name);

        //注意问题：
        System.out.println("hello"+"world");
        System.out.println("hello"+10+20);//其他数据类型和字符串使用+拼接，结果就是一个字符串
        System.out.println(10+20+"hello");//30hello
        System.out.println("hello"+(10+20));
        System.out.println(10+""+20+"hello");

        //a=10,b=20
        System.out.println("a="+10+",b="+20);
    }

以上代码说明，当一个+表达式存在字符串的时候，都是执行字符串的拼接行为，因此我们可以很方便的使用System.out.println同时打印多个字符串或数字。

3.变量的作用域

也就是变量能生效的范围，一般是变量定义所在的代码块（大括号）

class Test{
    public static void main(String[] args) {
        {
            int x = 10;
            System.out.println(x);//编译通过
        }
        System.out.println(x);//编译失败，找不到变量x
    }
}

4.变量的命名规则

硬性指标：

1. 一个变量名只能包含数字，字母，下划线，美元符号（$）。
2. 数字不能开头。
3. 变量名大小写敏感的，即num和Num是两个不同的变量。

注意：虽然语法上也允许使用中文/美元符号（$）命名变量，但是强烈不推荐这样做。

软性指标：

1. 变量名要具有描述性，见名知意。
2. 变量名不宜使用拼音（但是不绝对）。
3. 变量名的词性推荐使用名词。
4. 变量命名推荐小驼峰命名法，当一个变量名由多个单词构成的时候，除了第一个单词之外，其他单词首字母大写。

小驼峰命名示例：

int maxValue = 100;
String studentName = "张三";

5.常量

上面讨论的都是各种规则的变量，每种类型的变量也对应着一种相同类型的常量。

常量指的是运行时类型不能发生改变。

常量主要有以下两种体现形式：

5.1 字面值常量

10              //int 字面值常量（十进制）
010             //int 字面值常量（八进制）由数字0开头
0x10            //int 字面值常量（十六进制）由数字0x开头
10L             //long 字面值常量。也可以写作10l（小写的L）
1.0             //double 字面值常量。也可以写作1.0d或者1.0D
1.5e2           //double 字面值常量。科学计数法表示，相当于1.5*10^2
1.0f            //float 字面值常量。也可以写作1.0F
true            //boolean 字面值常量。同样的还有false
'a'             //char 字面值常量。单引号中只能有一个字符
"abc"           //String 字面值常量。双引号中可以有多个字符

5.2 final关键字修饰的常量

final int a = 10;
a = 20;   //编译出错。提示无法为最终变量a分配值

常量不能在程序运行过程中发生修改。

6.类型转换

Java作为一个强类型编程语言，当不同类型之间的变量相互赋值的时候，会有严格的校验。

先看以下几个代码场景：

int 和long/double相互赋值

int a = 10;
long b =20;
a = b;     //编译出错，提示可能会损失精度
b = a;     //编译通过

int a = 10;
double b = 1.0;
a = b;     //编译出错，提示可能会损失精度
b = a;     //编译通过

long 表示的范围更大，可以将int赋值给long，但是不能将long赋值给int。

double 表示的范围更大，可以将int赋值给double，但是不能将double赋值给int。

结论：不同数字类型的变量之间赋值，表示范围更小的类型能隐式转换成范围较大的类型，反之则不行。

int 和boolean相互赋值

int a = 10;
boolean b = true;
b = a;     //编译出错，提示不兼容的类型
a = b;     //编译出错，提示不兼容的类型

int 字面值常量给byte赋值

byte a = 100;     //编译通过
byte b = 256;     //编译报错，提示从int转换到byte可能会有损失

注意：byte表示的数据范围是-128 -> +127，256已经超过范围，而100还在范围之内。

结论：使用字面值常量赋值的时候，Java会自动进行一些检查校验，判断赋值是否合理。

使用强制类型转换

int a = 0;
double b = 10.5;
a = (int)b;

int a = 10;
boolean b = false;
b = (boolean)a;    //编译出错，提示不兼容的类型。

结论：使用（类型）的方式可以将double类型强制转换成int。但是

1. 强制类型转换可能会导致精度丢失。如刚才的例子中，赋值之后，10.5就变成10了，小数点后面的部分丢失了
2. 强制类型转换不是一定能成功，互不相干的类型之间无法强转。

类型转换小结

1. 不同数字类型的变量之间赋值，表示范围更小的类型能隐式转换成范围较大的类型。
2. 如果需要把范围大的类型赋值给范围小的，需要强制类型转换，但是可能精度丢失。
3. 将一个字面值常量进行赋值的时候，Java会自动针对数字范围进行检查。

7.数值提升

int 和long混合运算

int a = 10;
long b = 20;
int c = a + b;    //编译出错，提示将long转换成int会丢失精度
long d = a + b;

结论：当int和long混合运算的时候，int会提升成long，得到的结果仍然是long类型，需要使用long类型来接收结果。如果非要用int来接收结果，就需要使用强制类型转换。

byte 和byte的运算

byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);    //编译报错，不兼容的类型：从int转换到byte可能会有损失

结论：byte和byte都是相同类型，但是出现编译报错。原因是，虽然a和b都是byte，但是计算a+b都是会先提升成int，再进行计算，得到的结果也是int,这时赋给c，就会出现上述错误。

由于计算机的CPU通常是按照4个字节为单位从内存中读写顺序。为了硬件上实现方便，诸如byte和short这种小于4个字节的类型，会先提升成int，再参与计算。

正确的写法：

byte a = 10;
byte b = 20;
byte c = (byte)(a + b);
System.out.println(c);

类型提升小结：

1. 不同类型的数据混合运算，范围小的会提升成范围大的。
2. 对于short,byte这种比4个字节小的类型，会先提升成4个字节的int，再运算。

8.int和String之间的相互转换

int转成String

int num = 10;
//方法1
String str1 = num + "";
//方法2
String str2 = String.valueOf(num);

String转成int

String str = "100";
int num = Integer.parseInt(str);

9.算术运算符

基本四则运算符+ - * / %

规则比较简单，值得注意的是除法：

1. int/int结果还是int，需要使用double来计算。

int a = 1;
int b = 2;
System.out.println(a / b);
//结果为0

2. 0不能作为除数

int a = 1;
int b = 0;
System.out.println(a / b);
//运行结果
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at TestDemo.main(TestDemo.java:12)

3. %表示取余，把仅仅可以对int求模，也能对double来求模

System.out.println(11.5%2);
//运行结果
1.5

---

增量赋值运算符+= -= *= /= %=

int a = 10;
a += 1;    //等价于a = a + 1;
System.out.println(a);

short s = 10;
s = (short)(s + 9);    //直接写成s = s + 9;会报错，因为short类型会强制转换成int类型
s += 9;    //自动强制类型转换
System.out.println(s);

---

自增/自减运算符++ --

int a=10;
int i1=a++;    //先使用 后++
System.out.println(a);
System.out.println(i1);

int c=10;
int i2=++c;    //先++ 后使用
System.out.println(c);
System.out.println(i2);
//运行结果
11 10 11 11

结论：

1. 如果不取自增运算的表达式的返回值，则前置自增和后置自增没有区别。
2. 如果取自增运算的表达式的返回值，则前置自增的返回值是自增之后的值，后置自增的返回值是自增之前的值。

10.关系运算符

关系运算符主要有六个：

== ！= < > <= >=

int a = 10;
int b = 20;
System.out.println(a == b);
System.out.println(a != b);
System.out.println(a < b);
System.out.println(a > b);
System.out.println(a <= b);
System.out.println(a >= b);

注意：关系运算符的表达式返回值都是boolean类型。

11.逻辑运算符

逻辑运算符主要有三个：

&& || !

注意：逻辑运算符的操作数（操作数往往是关系运算符的结果）和返回值都是boolean。

逻辑与 &&

规则：两个操作数都为true,结果为true，否则结果为false。

int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b && b < c);

逻辑或 ||

规则：两个操作数都为false,结果为false，否则结果为true。

int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b || b < c);

逻辑非 ！

规则：操作数为true,结果为false，操作数为false，结果为true（这是个单目运算符，只有一个操作数）。

int a = 10;
int b = 20;
System.out.println(!(a < b));

短路求值

&&和||遵守短路求值的规则

System.out.println(10 > 20 && 10 / 0 == 0);    //打印 false
System.out.println(10 < 20 || 10 / 0 == 0);    //打印 true

我们都知道，计算10 / 0会导致程序抛出异常。但是上面的代码却能正常运行，说明10 / 0并没有真正参与运算。

结论：

1. 对于&&，如果左侧表达式值为false，则表达式的整体一定是false，无需计算右侧表达式。
2. 对于||，如果左侧表达式值为true，则表达式的整体一定是true，无需计算右侧表达式。

12.位运算符

Java中对数据的操作的最小单位不是字节，而是二进制位。

位运算符主要有四个：

& | ~ ^

位操作表示按二进制位运算。计算机中都是使用二进制来表示数据的（01构成的序列）。

**按位与 &：**如果两个二进制位都是1，则结果为1，否则结果为0。

int a = 10;
int b = 20;
System.out.println(a & b);

进行按位运算，需要先把10和20转成二进制，分别为1010和10100

**按位或 |：**如果两个二进制位都是0，则结果为0，否则结果为1。

int a = 10;
int b = 20;
System.out.println(a | b);

运算方式和按位与类似。

**按位取反 ~：**如果该位为0则转为1，如果该位为1则转为0。

int a = 0xf;
System.out.printlf("%xn",~a);

**按位异或 ^：**如果两个数字的二进制位相同，则结果为0，相异则结果为1。

int a = 0x1;
int b = 0x2;
System.out.printf("%xn",a ^ b);

13.条件运算符

条件运算符只有一个：

表达式1 ? 表达式2 ： 表达式3

当表达式1的值为true时，整个表达式的值为表达式2的值；当表达式1的值为false时，整个表达式的值为表达式3的值。

也是Java中唯一一个三目运算符，是条件判断语句的简化写法。

//求两个数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;

14.小结

1. %操作在Java中也能针对double来计算。
2. 需要区分清楚前置自增和后置自增之间的区别。
3. 由于Java是强类型语言，因此对于类型检查较严格，因此像&&之类的运算操作数必须是boolean。
4. 要区分清楚&和|什么时候是表示按位运算，什么时候表示逻辑运算。

整体来看，Java的运算符的基本规则和C语言基本一致。
为1。

int a = 0x1;
int b = 0x2;
System.out.printf("%xn",a ^ b);

13.条件运算符

条件运算符只有一个：

表达式1 ? 表达式2 ： 表达式3

当表达式1的值为true时，整个表达式的值为表达式2的值；当表达式1的值为false时，整个表达式的值为表达式3的值。

也是Java中唯一一个三目运算符，是条件判断语句的简化写法。

//求两个数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;

14.小结

1. %操作在Java中也能针对double来计算。
2. 需要区分清楚前置自增和后置自增之间的区别。
3. 由于Java是强类型语言，因此对于类型检查较严格，因此像&&之类的运算操作数必须是boolean。
4. 要区分清楚&和|什么时候是表示按位运算，什么时候表示逻辑运算。

整体来看，Java的运算符的基本规则和C语言基本一致。