Java: 数据类型与变量和运算符

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello World!");
        System.out.println(20);
        System.out.println(3.14);
        System.out.println('a');
        System.out.println(true);
        System.out.println(false);
    }
}

我们要注意的是，字符串、整形、浮点型、字符型以及布尔型，在Java中都称为数据类型。

二.数据类型

在Java中数据类型主要分为两类：基本数据类型和引用数据类型。

而基本数据类型又分为四类八种：

四类：整型、浮点型、字符型以及布尔型

八种：是根据四类所得出的。

整型分为：字节型，短整形，整型，长整型。
浮点型分为：单精度浮点数和双精度浮点数。
字符型：字符型。
布尔型：布尔型。

数据类型	关键字	内存占用	范围
字节型	byte	1 字节	-128 ~ 127
短整型	short	2 字节	-32768 ~ 32767
整型	int	4 字节	-2^31~2^31-1
长整型	long	8 字节	-2^63~2^63-1
单精度浮点数	float	4 字节	有范围，一般不关注
双精度浮点数	double	8 字节	有范围，一般不关注
字符型	char	2 字节	0 ~ 65535
布尔型	boolean	没有明确规定	true 和 false

我们发现在Java中相较于C语言多了一个字节型，并且字符型的大小变为了2个字节。

那么什么是字节呢？

我们知道字节是计算机中表示空间大小的基本单位，而计算机使用二进制表示数据，并且我们认为 8 个二进制位(bit) 为一个字节(Byte)。

但在这里我们还有一些注意事项：

在Java中：

不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节。
整形和浮点型都是带有符号的。（默认是有符号的数)
整型默认为int型，浮点型默认为double。（例如：4默认就是int型，3.14默认为double型）
字符串属于引用类型。

三.变量

在程序中，除了有始终不变的常量外，有些内容可能会经常改变，比如：人的年龄、身高、成绩等，对于这些经常改变的内容，在Java程序中，称为变量。而数据类型就是用来定义不同种类变量的。

1.语法格式

定义变量的语法格式为：

数据类型变量名 = 初始值;

2.整型变量

(1).整型变量

public class Test {
    public static void main(String[] args) {
        int a=10;
        System.out.println(a);
    }
}

注意：在Java中变量必须初始化，如果没有合适的初始值可以先赋成0.

如果我们没有赋初值的话，我们的代码就会出现错误。

对于int类型我们还有一些注意事项：

int不论在何种系统下都是4个字节
在给变量设置初始值时，值不能超过int的表示范围，否则会导致溢出
int的包装类型为 Integer

(2). 长整型变量

public class Test {
    public static void main(String[] args) {
       long a=100L;
       long b=200l;
        System.out.println(a);
        System.out.println(b);
    }
}

对于长整型变量，我们需要在我们赋的值后面加上L或者l,但更加推荐使用L，因为l,有时我们对于l和1，不好区分。

对于long类型我们还有一些注意事项：

长整型不论在那个系统下都占8个字节
long的包装类型为Long

(3).短整型变量

public class Test {
    public static void main(String[] args){
        short a=10;
        System.out.println(a);
    }
}

对于short类型我们还有一些注意事项：

short在任何系统下都占2个字节
使用时注意不要超过范围
short的包装类型为Short

(4).字节型变量

public class Test {
    public static void main(String[] args) {
        byte a=5;
        System.out.println(a);
    }
}

对于byte类型我们还有一些注意事项：

byte在任何系统下都占1个字节
字节的包装类型为Byte

3.浮点型变量

(1).双精度浮点型

public class Test {
    public static void main(String[] args) {
        double a=5.0;
        System.out.println(a);
    }
}

接下来我们看一段代码

我们发现并没有输出我们想要的2.5，这是因为在 Java 中, int 除以 int 的值仍然是 int(会直接舍弃小数部分)。如果想得到 2.5, 需要使用 double 类型计算.

当然，我们知道int 类型的数例如5 就一定是5，而我们的浮点数类型，例如1.1就一定是1.1吗？

其实不是的，让我们来看下面这段代码。

我们发现我们得到的值其实并不是我们想的1.21，而是在后面还有值，这其实是因为浮点数类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。

对于double类型我们还有一些注意事项：

double在任何系统下都占8个字节
浮点数与整数在内存中的存储方式不同，不能单纯使用 2^n的形式来计算
double的包装类型为Double

(2).单精度浮点型

public class Test {
    public static void main(String[] args) {
        float a=3.14f;
        System.out.println(a);
    }
}

对于float变量，我们需要在我们赋的值后面加上F或者f.

对于float类型我们还有一些注意事项：

float在任何系统下都占4个字节
float的包装类型为Float
同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 float. float的包装类型为Float

4.字符型变量

public class Test {
    public static void main(String[] args) {
        char a='a';
        char b='1';//数字字符
        System.out.println(a);
        System.out.println(b);
    }
}

注意事项：

在Java 中使用单引号 + 单个字母的形式表示字符字面值
计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文。
char的包装类型为Character

5.布尔型变量

布尔类型常用来表示真假,真为true,假为false.

public class Test {
    public static void main(String[] args) {
        boolean a=true;
        boolean b=false;
        System.out.println(a);
        System.out.println(b);
    }
}

对于boolean类型我们还有一些注意事项：

Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.
Java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令，在 Oracle公司的虚拟机实现中，boolean占1个字节。
boolean的包装类型为Boolean。

四.类型转换

在Java中，当参与运算数据类型不一致时，就会进行类型转换。

Java中类型转换主要分为两类：自动类型转换(隐式) 和强制类型转换(显式)。

1.自动类型转换(隐式)

自动类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。

特点：数据范围小的转为数据范围大的时会自动进行。

2.强制类型转换(显式）

强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。

特点：数据范围大的到数据范围小的。

public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 100L;
        a = (int)b;
        System.out.println(a);
    }
}

注意：强制类型转换不一定能成功，不相干的类型不能互相转换

对于布尔类型，不能对他进行强制类型转换，因为int类型和boolean类型不相干。

注意：将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查

public class Test {
    public static void main(String[] args) {
        int a=128;
        byte b=10;
        b=(byte)a;
        System.out.println(b);
    }
}

byte的范围为-128~127，当我们要赋得值超过这个范围时，就不会得到我们想要得值。我们发现我们超过这个范围得大小为1，我们可以把byte范围看成下面得图，我们就可以知道打印得值为-128.

五.类型提升

不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。

int与long之间：int会被提升为long：

byte与byte的运算：

我们发现这其实是有错误的，然而如果我们改成int类型得话就不会发生错误。

这其实是因为虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a 和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.

总结：

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

六.字符串类型

在Java中使用String类定义字符串类型

public class Test {
    public static void main(String[] args) {
        String a="hello";
        String b="world";
        System.out.println(a);
        System.out.println(b);
        System.out.println(a+b);//拼接两个字符串
    }
}

在一些特殊得情况下，我们需要然int类型和String类型互相转换

1.int 转成 String

有两种方式：

public class Test {
    public static void main(String[] args) {
        //方法一：
        int a=10;
        String b=a+"";
        System.out.println(b);
        //方法二：
        System.out.println("-----------------");
        String c=String.valueOf(a);
        System.out.println(c);
    }
}

2.String 转成 int

public class Test {
    public static void main(String[] args) {
        String a = "100";
        int num1 =Integer.valueOf(a);
        int num2 = Integer.parseInt(a);
        System.out.println(num1);
        System.out.println(num2);
    }
}

但其实，valueOf和parseInt这两没有区别，我们可以找到valueOf他的原码。

他其实就是调用parseInt，所以其实我们就使用parseInt就可以了。

七.运算符

1. 什么是运算符

对操作数进行操作时的符号，不同运算符操作的含义不同。

作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。Java中运算符可分为以下：算术运算符(+ - * /)、关系运算符(< > ==)、逻辑运算符、位运算符、移位运算符以及条件运算符等。

2.算术运算符

**（1）.基本四则运算符：加减乘除模+， -， *， /， %**

public class Test {
    public static void main(String[] args) {
        int a = 5;
        int b = 2;
        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);
    }
}

但是，在这其中，我们得除运算，并没有得到我们想要得2.5，这样我们该怎么办呢？

其实很简单，只需要让他们其中一个数变成浮点数即可。

public class Test {
    public static void main(String[] args) {
        int a = 5;
        int b = 2;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a*1.0 / b);
        System.out.println(a % b);
    }
}

（2）.增量运算符 +=， -=， *=， %=

public class Test {
    public static void main(String[] args) {
        int a = 5;
        a += 2;
        System.out.println(a);
        a -= 2;
        System.out.println(a);
        a *= 2;
        System.out.println(a);
        a /= 2;
        System.out.println(a);
        a %= 2;
        System.out.println(a);
    }
}

（3).自增/自减运算符 ++ --

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b=a++;
        System.out.println(b);
        System.out.println(a);
        a=1;
        int c=++a;
        System.out.println(c);
        System.out.println(a);
    }

}

对于前置++是先赋值后+1，后置++是先+1后赋值

其他注意事项：

如果单独使用，【前置++】和【后置++】没有任何区别
只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改

3.关系运算符

关系运算符主要有六个: == != < > = ，其计算结果是 true 或者 false 。

public class Test {
    public static void main(String[] args) {
        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);

    }
}

4.逻辑运算符

逻辑运算符	语法
逻辑与 &&	表达式1 && 表达式2
逻辑或 \|\|	表达式1 \|\| 表达式2
逻辑非 !	! 表达式

逻辑与 &&：两个表达式都为真，结果才是真，只要有一个是假，结果就是假。
逻辑或 ||：左右表达式至少有一个位真，则结果为真，都为假，结果就是假。
逻辑非 !：真变假，假变真。

短路求值：

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

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

所以我们可以得到我们得结论：

对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式
对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式.

5.位运算符

位运算符	语法
按位与 &	A&B
按位或 \|	A\|B
按位取反 ~	A~B
4. 按位异或 ^	A^B

按位与 &: 全1为1，有0为0
按位或 |: 有1为1，全0为0
按位取反 ~: 1转0，0转1
按位异或 ^: 相同为0，相异为1

6.移位运算

在Java中，移位运算符有三个: << , >> , >>>，都是二元运算符，且都是按照二进制比特位来运算的.

左移 <<: 最左侧位不要了, 最右侧补 0.

右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

无符号右移 >>>: 最右侧位不要了, 最左侧补 0.

注：没有“无符号左移”，“<<<”.

注意:

左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.

7.条件运算符

表达式1 ? 表达式2 : 表达式3

当表达式1 的值为 true 时, 整个表达式的值为表达式2 的值;
当表达式1 的值为 false 时, 整个表达式的值为表达式3 的值.

8.运算符的优先级

在一条表达式中，各个运算符可以混合起来进行运算，但是运算符的优先级不同，比如：* 和 / 的优先级要高于 + 和 - ，如果我们在写代码得时候不注意观察和判断，就会让我们得代码结果出现错误。

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = a + (b - a) >> 1;
        System.out.println(c);

    }

我们知道（）的优先级最大先执行b-a等于10，而+得优先级高于>>,所以执行a+10=20，最后执行右移，根据上面我们知道右移一位相当于除上2，所以我们得结果应为10.