Java基础——初始Java（2）数据类型+运算符

文章目录

• 前言
• 一、数据类型
• • 1. Java中的数据类型
  • 2. 字符串类型
  • 3. 变量的作用域
  • 4. 常量
  • 5. 类型转换
  • 6. 数值提升
  • 7. int和String之间的相互转换
  • • int转String
    • String转int
• 二、运算符
• • 1. 基本运算符
  • 2. 复合运算符
  • 3. 自增自减（++,--)
  • 4. 关系运算符
  • 5. 逻辑运算符
  • 6. 位运算符
  • 7. 移位运算符
  • 8. 三目运算符
  • 9. 运算符的优先级

前言

本文章主要是 写了数据类型和运算符中 在Java中和C语言中有差别的地方
有些地方略过了哦

一、数据类型 1. Java中的数据类型

1. 八种基本数据类型
   ① 整型:byte,short,int,long
   ② 浮点:float,double
   ③ 字符:char
   ④ 布尔:boolean
   只有这八种数据类型有包装类
2. 引用类型
   ① String
   ② 数组
   ③ 类
   ④ 接口
   ⑤ 枚举
   如何看是不是引用？

看变量中存放的是不是地址！

2. 字符串类型

在C语言中，没有专门的字符串类型
我们利用字符数组定义字符串
而在Java中 有专门的字符串类型String
String就是一种引用类型

注意

1. Java中严格区分大小写
2. 单引号 -->字符
   双引号–> 字符串

注意问题

• 两个字符串相加就是拼接字符串

3. 变量的作用域

在Java中，没有所谓的全局变量的概念
Java中变量分为

1. 成员变量

   • 普通成员变量–定义在类的内部，方法的外部
   • 静态成员变量

2. 局部变量

   • 作用范围：代码块内
   • 局部变量优先（找最近的{})

4. 常量

常量分为

1. 字面值常量
   如下：

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

2. final修饰的变量 —>常量（相当于C中const）
   被final修饰的变量具有了常属性，不可以在修改

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

常量和变量的区别：

• 变量
  程序运行的时候可以改变的量，在程序运行的时候才能知道里面的值是几
• 常量
  在程序编译的时候，就已经确定其值是多少了，只能初始化一次！因为在编译的时候就需要确定值是多少

5. 类型转换

其实C语言是一个相对弱类型的语言
在C中，long类型可以赋值给int类型
顶多就会警告一下（大字节赋值给小字节 可能损失精度）
在Java中，严令的错误！
long类型无法赋值给int类型
但是int类型可以赋值给long类型

也就是说：
不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型, 反之则不行

解决方法：
强制类型转换
强转的注意事项：

1. 强转也是有风险的，可能带来精度的损失
2. 强转的前提是 都是同一种类型
   比如都是数值型
   如果是一个int类型转成boolean 也是不可以的！！

6. 数值提升

C由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short 这种低于
4 个字节的类型, 会先提升成 int, 再参与计算 --（整型提升）
注意：整型提升针对的是 变量

byte a = 1;
byte b = 2;
byte c = a + b;//报错！
// 因为a和b都被提升到了int类型
// 所以int类型无法赋值给byte类型

数值提升还有一种情况

即使大于4字节，也会把小的类型强制转换为大的类型

int a = 10;
long b = 20
int c = a + b;

因为 a和b在运算的 时候 a会提升为long类型
所以a+b的结果就是long类型，long类型赋值给一个int类型 就会出错！

正确写法：(强制类型转换）

int c = (int)(a+b);

如果是常量：

byte a = 1 + 2;

这样就不会报错，因为1和2都是常量，编译的时候 1 + 2 就已经编译成3了
这句代码就相当于byte a = 3;
而3 没超过byte的数值表示范围，所以是正确的

整型提升的作用：
提升效率

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

1. String str1 = String.valueOf(num);

2.String str2 = num + "" (隐式类型转换）

String转int

1. Integer.parseInt()

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

2. Integer.valueOf()

int num = Integer.valueOf(str);

使用Integer.valueOf()的时候，总是会有警告：
Integer.valueOf(xxx)内的装箱冗余
这是因为，valueOf内部使用了parseInt()的方法
如下是valueOf的内部实现：

public static Integer valueOf(String s) throws NumberFormatException {
     return Integer.valueOf(parseInt(s, 10));
}

所以编译器觉得有些冗余 就会给你警告

注意：这些都是因为存在包装类
基本数据类型都有包装类

两种特殊的是char 和 int
他们的包装类分别是 Character 和 Integer
其余的都是首字母直接大写
如：long --> Long

二、运算符 1. 基本运算符

+ - * / %
基本运算符没什么好说的
除法需要注意：除数不能为0，否则会抛出异常，程序中止

与C语言不同的是取余%运算 在Java中存在小数取余

11.5 % 2 —> 输出 1.5

2. 复合运算符

+=
看这样一个代码

short s = 10;
s = s + 10;

这里会发生错误，因为10是整型
运算的时候 短整型s会发生整型提升而变成int类型，所以需要强制类型转换
-> s=(short)(s+10)
但是Java中的符合运算符有另一个作用：
自动进行类型转换

short s = 10;
s += 10;

这样就不会报错了

3. 自增自减（++,–)

这里和C一样 就不赘述了

4. 关系运算符

== , != ,>=,<=,>,<
关系运算符的结果都是布尔表达式
{true,flase}

注意这里只能写

if(true || flase){
//...
//...
}

不能存在 if(0) || if(1) 这是C中的写法 Java中不可！

5. 逻辑运算符

&& 逻辑与：[表达式1]&&[表达式2]
短路：如果表达式1为假，就不执行表达式2了

10 > 20 && 10 / 0 == 0;
这样并不会报错
因为 10> 20 为假 直接短路了
10/0根本不会执行！

|| 逻辑或：[表达式1] || [表达式12]
短路：如果表达式1为真， 就不执行表达式2了

注意 这两个左右都是布尔表达式

! 非运算：只能跟布尔表达式 ，不能是整型的0/1 代表假或真

6. 位运算符

和C语言一样
简单说一下

&：按位与 — 对应位都是1结果就是1
|：按位或 ---- 对应位只有有1结果就是1
^：按位异或 — 对应位不同结果就是1，一样就是0
~：按位取反 — 1–>0, 0–>1

7. 移位运算符

<<: 左移 - - 右边补0
>>: 右移 - - 左边补符号位
>>>: 无符号右移 - - - 不管符号位是啥，左边都补0，没有无符号左移，因为右边没符号位

8. 三目运算符

表达式1？表达式2：表达式3
注意：表达式1 必须是布尔表达式

9. 运算符的优先级

不用记忆运算符的优先级，只需要根据自己的逻辑来加括号就可以了