2022-12-15——Java中的数据类型和运算符

Java中的数据类型

数据存储的单位

1、比特（bit）：数据运算的最小存储单位
2、字节（byte）：数据的最小存储单位
3、字节和比特之间的相互转换
```
1 byte = 8 bit
1024 byte = 1KB
1024 KB = 1 MB
1024 MB = 1 GB
1024 GB = 1 TB
```

数据类型

• Java 的数据类型可以确定数据的范围
  • Java的数据类型可以分为基本数据类型和引用数据类型，这里暂时只讨论基本数据类型
  • Java的基本数据类型又分为数值类型、字符类型和布尔类型。
    ①、数值类型：又分为整数类型( byte、short、int、long)和浮点类型(float、double)
    ②、字符类型：char
    ③、布尔类型：boolean
  • 引用数据类型可分为类(String)、接口、数组、枚举、特殊值(null)。
    
    直接看代码：

public class Java04_BasicDataType {
    public static void main(String[] args) {
        // TODO Java数据的基本数据类型
        // TODO 1、整数类型
        // byte
        byte b = 10;
        // short
        short s = 10;
        // int
        int i = 10;
        // long
        long lon = 10;
        // TODO 2、浮点类型：含有小数点的数据类型
        // 按照精确度分为
        // TODO 默认情况下：小数点的数据会被识别为精度较高的双精度：double 类型的浮点数
        // float：单精度浮点类型，数据需要以 F或f 结尾。
        float f = 1.0f;
        // double：双精度浮点类型
        double db = 1.0;
        // TODO 3、字符类型：
        // 所谓字符类型，其实就是使用符号标识的文字内容
        char c = '@';
        // TODO 4、布尔类型：
        // true，false，用来标识判断条件是是否成i了，如果成立就是 true 如果不成立就是 false
        boolean bln = true;
    }
}

数据类型的转换

• 在Java中不同数据类型的变量之间不能相互赋值，否则就会报错。
• 在同等数据类型之中，数据的范围也是有所区别，数据范围大的变量不能赋值给数据范围小的变量，否则也会报错。
  • 数据范围（特指 数值类型）由小到大
    byte -> short -> int -> long -> float -> double
  • 对于一些特殊情况，可以进行强制数据类型转换
    语法结构：
    数据类型1 变量名1 = （数据类型1）变量名2；

// 代码 1
String name = "刻晴";
int num = 20;
String userName = name; // 同等数据类型之间可以互相赋值
age = name;				// 不同数据类型相互赋值就会报错

// 代码 2
byte b = 20;
short s = b;
int i = s;
long lon = i;
float f = lon;
double db = f;

int j = lon		// 数据范围大的也不能为数据范围小的赋值

// 强制类型转换
int i1 = (int)lon	// 强制数据类型转换，可能会超出范围的数据的丢失

Java中的运算符

• 概念： 所谓运算符，就是参与运算的符号。由Java定义，无法自行定义。
• 表达式： 表达式就是数据和运算符连接在一起的，符合Java语法规则的指令代码，称之为表达式
• Java中的运算符分为算数运算符和逻辑运算符

算数运算符

• 二元运算符： 需要两个元素参与的运算符，通常的算数运算符(+, - , * , / , %等)均为二元运算符。
  • 语法结构
    变量 = 元素1 （运算符）元素2
  • 二元运算的结果（变量）也是有数据类型的，这个数据类型取决于参与运算的元素类型最大的那一个，但使用的最小的元素类型时 int
  • 数据类型由小到大：byte -> shore -> int -> long -> float -> double
• 举个栗子

		System.out.println("1+2 = " + (1 + 2) );    // 3
        System.out.println("2-2 = " + (2 - 2) );   	// 0
        System.out.println("3*2 = " + 3 * 2 );    	// 6
        System.out.println("4/2 = " + 4 / 2 );    	// 2
        System.out.println("1/2 = " + 1 / 2 );    	// int / int => int 取 0
        System.out.println("1.0/2 = " + 1.0 / 2 );  // double / int => double 取 0.5
        System.out.println("5%2 = " +5 % 2 );     	// 1 取余，模运算
		byte b1 = 10;
        byte b2 = 20;
        byte sum = (byte)(b1 + b2);  
        // 理论上 byte + byte => byte ，但因最小使用元素类型是int，所以sum不能用byte修饰（强制转换）。
        System.out.println(sum);
		System.out.println(1 + 2 * 3);  	// 7 Java中同样有运算优先级的存在
        System.out.println((1 + 2) * 3);  	// 9 将想要运算的括起来，即可

• 一元运算符： 只需要一个元素参与的运算符 ++、--。
• ++ 自增运算符，运算方式取决于运算符位置，元素前，先自增后操作，在元素后，先操作，再自增；
• -- 自减运算符，运算方式取决于运算符位置，元素前，先自减后操作，在元素后，先操作，再自减；
• 举个栗子

        int i = 0;
        int j = i;
        i = i + 1;
        System.out.println("i = " + i); // i = 1
        System.out.println("j = " + j); // j = 0

        int i = 0;
        int j = i++;
        System.out.println("i = " + i); // i = 1
        System.out.println("j = " + j); // j = 0

        System.out.println(">>>>>>>>>>>");

        int i = 0;
        i = i + 1;
        int j = i;
        System.out.println("i = " + i); // i = 1
        System.out.println("j = " + j); // j = 1

        int i = 0;
        int j = ++i;
        System.out.println("i = " + i); // i = 1
        System.out.println("j = " + j); // j = 1

赋值运算符

• 单一的赋值运算符只有 "=" 如果元素进行操作后，将结果重新赋值给自己，那么就可以进行简化操作。即通过复合赋值运算符("+="、"-="、"*="、"/=")操作。
  注意： 使用符合赋值运算符，并不会改变其本身的数据类型(数据范围大小不变)，对于前面的二元表达式，其运算结果最小的元素范围是 int 但对于复合赋值运算符则不一定。
• 举个例子

byte b = 1;
// b = b + 10; // b + b1 的类型是 int
b += 10; // 这时候运算结果的类型就不会改变，仍然是 byte
System.out.println(b);

关系运算符

• 所谓关系运算符，就是用于比较两个数据之间的运算符。
  • 关系运算符语法结构：
    元素1(数据1、表达式1) 关系运算符[==、>、>=、<=、<、!=] 元素2(数据2、表达式2)。
  • 由关系运算符构成的表达式成为条件表达式、关系表达是的运算结果是布尔类型。
• 举个例子

        int i = 10;
        int j = 20;
        System.out.println(i == j); // false 判断元素 1，2 是否相等
        System.out.println(i != j); // true 判断元素 1，2 是否不相等
        System.out.println(i > j); // false 判断元素1是否大于元素2
        System.out.println(i >= j); // false 判断元素1是否大于等于元素2
        System.out.println(i <= j); // true 判断元素1是否小于等于元素2
        System.out.println(i < j); // true 判断元素1是否小于元素2

逻辑运算符

• 概念： 所谓逻辑运算符就是用于描述多个表达式之间关系的运算符
• 逻辑运算符语法结构：
  变量 = （数据1、条件表达式1） 逻辑运算符 （数据2、条件表达式2）
  • 变量布尔类型，因为条件表达式的运行结果就是布尔类型，所以逻辑运算的结果也是布尔类型。

逻辑与(&)运算

• 运算要求两个表达式都必须计算出结果，只有当连个表达式的结果都为 真(true)的时候，表达式的结果才为真true，否则均为假false
  • 即 true & true = true
  • 即 false & true = false
  • 即 true & false= false
  • 即 false & false= false

逻辑或(|)运算

• 运算要求两个表达式都必须计算出结果，只有当两个表达式的结果都为 假(false)的时候，表达式的结果才为假false，否则均为真true
  • 即 false | false = false
  • 即 true | false = true
  • 即 false| true = true
  • 即 true | true = true

短路与(&&)运算

• 概念： 根据与&运算因为只要有一个表达式为假false 运算结果就为假false那么只要第一个值为假false那么第二个关系表达式就不需要进行计算即可得出结果为假false；这就是短路与&&运算。
• 举个例子：

		int i = 10;
        boolean result = (i<10) && (++i > 5);
        System.out.println(result);     // false
        System.out.println(i);          // 10 因为 i<10 不成立，则 ++i 不会进行运算，结果i取10

短路或(||)运算

• 概念： 有了短路与&&运算，相应的也有短路或运算，根据或|运算只要第一个条件表达式结果为真true，第二个条件表达式就不需要进行计算即可得出结果为真true；这就是短路或||运算.
• 举个例子：

        boolean result2 = (i<10) || (++i > 5);
        System.out.println(result2);
        System.out.println(i);          // 11 因为 i<10 不成立，则 ++i 会直接参与运算，结果i取11

逻辑非(!)运算

• 概念： 条件表达式的结果和原结果相反。
• 直接看代码：

		System.out.println(i>=5);       // true
        System.out.println(!(i>=5));    // false

三元运算符

• 概念： 三个元素参与的运算符，这与Java的分支结构有关。
  • 语法结构：
    变量 = （条件表达式）? （任意表达式1） ： （任意表达式2）;
• ** 运算规则：** 根据条件表达式的结果决定变量的值，为真true则取任意表达式1 的值；为假false则取任意表达式2的值。
  看代码：

        int i = 10;
        int j = 20;

        int result = (i<20 && j>10) ? (i+1) : (j+1);

        System.out.println(result); // 11 因为 （i<20 && j>10）成立，则result取 i+1 = 11