001-Java基础

FangYiHeng_

已于 2023-12-24 23:04:43 修改

阅读量841

点赞数 15

分类专栏： JavaSE 文章标签： java

于 2023-12-08 20:30:25 首次发布

本文链接：https://blog.csdn.net/Fang_Jason/article/details/134882988

版权

JavaSE 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1 基本数据类型

1.1 整数类型：byte、short、int、long

在这里插入图片描述

注意事项：
定义 long 类型的变量，赋值时需要以"l"或"L"作为后缀。
Java 程序中变量通常声明为 int 型，除非不足以表示较大的数，才使用 long。
Java 的整型常量默认为 int 型。

字节（Byte）：是计算机用于计量存储容量的基本单位，一个字节等于 8 bit。
位（bit）：是数据存储的最小单位。二进制数系统中，每个 0 或 1 就是一个位，叫做 bit （比特），其中 8 bit 就称为一个字节(Byte)。
转换关系：
8 bit = 1 Byte
1024 Byte = 1 KB
1024 KB = 1 MB
1024 MB = 1 GB
1024 GB = 1 TB

1.2 浮点类型：float、double

在这里插入图片描述

浮点型常量有两种表示形式：
十进制数形式。如：5.12F、512.0f、 .512F (必须有小数点）
科学计数法形式。如：5.12e2（5.12十二次方）、512E2、100E-2

float：单精度，尾数可以精确到 7 位有效数字。很多情况下，精度很难满足需求。
double：双精度，精度是 float 的两倍。通常采用此类型。
定义 float 类型的变量，赋值时需要以"f"或"F"作为后缀。
定义 double 类型的变量，赋值时可以以"d"或"D"作为后缀，但有无后缀名无所谓。
Java 的浮点型常量默认为 double 型。

1.3 字符类型：char

char 型数据用来表示通常意义上“字符”（占 2 字节）
Java 中的所有字符都使用 Unicode 编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
字符型变量的三种表现形式
形式 1：使用单引号(’ ')括起来的单个字符。例如：char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;
形式 2：直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中， XXXX 代表一个十六进制整数。例如：\u0023 表示 ‘#’。
形式 3：Java 中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’; \n表示换行符。

转义字符	说明	Unicode 表示方式
\n	换行符	\u000a
\t	制表符	\U0009
\'‘	双引号字符	\u0022
\’	单引号字符	\u0027
\\	反斜线字符	\u005c
\b	退格符	\u0008
\r	回车符	\u000d

1.4 布尔类型：boolean

boolean 类型用来判断逻辑条件，一般用于流程控制语句中：

if 条件控制语句；
while 循环控制语句；
for 循环控制语句；
do-while 循环控制语句；

boolean 类型数据只有两个值：true、false，无其它：

不可以使用 0 或非 0 的整数替代 false 和 true，这点和 C 语言不同。
拓展：Java 虚拟机中没有任何供 boolean 值专用的字节码指令，Java 语言表达所操作的 boolean 值，在编译之后都使用 java 虚拟机中的 int 数据类型来代替：true 用 1 表示，false 用 0 表示。——《java 虚拟机规范 8 版》

2 基本数据类型的基本运算规则

2.1 自动类型提升

规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型。

基本数据类型的转换规则如图所示：

当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时

int i = 'A'; // char 自动升级为 int，其实就是把字符的编码值赋值给变量 i 
double d = 10; // int 自动升级为 double

当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算。
```
int i = 1;
double d = 1.0;
double sum = i + d; // 混合运算，升级为 double
System.out.println(sum); // 2.0
```

当 byte,short,char 数据类型的变量进行算术运算时，按照 int 类型处理。

char c1 = '0';
char c2 = 'A';
int i = c1 + c2; // 至少需要使用 int 类型来接收
System.out.println(c1 + c2); // 113

2.2 强制类型转换

规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型。

格式：小类型变量名 = (小类型) 大类型数据;

当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会损失精度或溢出。

int i = (int) 3.14;
System.out.println(i); // 3 --> 精度损失
/*
	int 类型范围 -2^31~2^31
	byte 类型范围 -128~127
	int 类型 200 已经超出了 byte 范围
*/
byte b = (byte) 200;
System.out.println(b); // -56 --> 溢出

当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是没有风险的，通常省略。
声明 long 类型变量时，可以出现省略后缀的情况。float 则不同。

2.3 基本数据类型与 String 的运算

String 不是基本数据类型，属于引用数据类型。
使用一对""来表示一个字符串，内部可以包含 0 个、1 个或多个字符。
声明方式与基本数据类型类似。例如：String str = “方以恒”

任意八种基本数据类型的数据与 String 类型只能进行连接“+”运算，且结果一定也是 String 类型。

System.out.println("abc" + 1 + 2); // abc12

System.out.println(1 + 2 + "abc" ); // 3abc

int num = 10;
boolean b1 = true;
String s1 = "abc";
System.out.println(s1 + num + b1); // abc10true

String 类型不能通过强制类型()转换，转为其他的类型。

3 运算符（Operator）

分类	运算符
算术运算符（7 个）	+、-、*、/、%、++、–
赋值运算符（12 个）	=、+=、-=、*=、/=、%=、>>=、<<=、>>>=、 &=等
关系运算符（6 个）	>、>=、<、<=、==、!=
逻辑运算符（6 个）	&、\|、^、!、&&、\|\|
位运算符（7 个）	&、\|、^、~、<<、>>、>>>（没有 <<<）
条件运算符（1 个）	(条件表达式) ? 结果1 : 结果2

3.1 算术运算符

public class ArithmeticOperator {
    public static void main(String[] args) {
        // “除法运算”结构需要有小数，就要有小数参与运算
        System.out.println(10 / 4); // 2
        System.out.println(10.0 / 4); // 2.5
        System.out.println(4 / 10); // 0

        System.out.println(5 % 2); // 1
        System.out.println(5 % -2); // 1
        System.out.println(-5 % 2); // -1
        System.out.println(-5 % -2); // -1
        System.out.println(1 % 2); // 1 

        String str = "Java";
        System.out.println(5 + 20 + str); // 25Java
        System.out.println(str + 5 + 20); // Java520

        int a = 1, b = 1;
        System.out.println(a++); // 1
        System.out.println(--b); // 0

        int c = 1;
        int d = c++;
        System.out.println(c); // 2
        System.out.println(d); // 1

        int e = 1;
        int f = ++e;
        System.out.println(e); // 2
        System.out.println(f); // 2
        /*
        	a++，先运算后自增
        	++a，先自增后运算
        */
    }
}

public class ArithmeticOperator {
    public static void main(String[] args) {       
        int a1 = 10;
        int b1 = 5;
        int c1 = a1++ + a1--;
        int d1 = --b1 + ++b1;
        System.out.println(a1); // 10
        System.out.println(b1); // 5
        System.out.println(c1); // 21
        System.out.println(d1); // 9
        
        int a2 = 5;
        int b2 = 4;
        int c2 = a2++ + --b2 + a2-- - b2-- + b2;
        /*
        *   int a2 = 5 6 5
        *   int b2 = 4 3 2
        *   int c2 = 5 + 3 + 6 - 3 + 2 = 13
        * */
        System.out.println(a2); // 5
        System.out.println(b2); // 2
        System.out.println(a2++); // 5
        System.out.println(--b2); // 1
        System.out.println(c2); // 13
    }
}

3.2 赋值运算符

基本赋值运算符：=
- 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换的原则进行处理。
- 支持连续赋值。
扩展赋值运算符： +=、 -=、*=、 /=、%=

+=：将符号左边的值和右边的值进行相加操作，再把结果的类型强制转化为符号遍的类型，最后将结果赋值给左边的变量。

其它扩展赋值运算符以此类推。
```
public class AssignmentOperator {
    public static void main(String[] args) {
        int num = 10;
        num += 1;
        System.out.println(num); // 11
    }
}
```

3.3 关系运算符

比较运算符的结果都是 boolean 型，也就是要么是 true，要么是 false；
<、>=、<= ：只适用于基本数据类型（除 boolean 类型之外）；
==、!= ：适用于基本数据类型和引用数据类型；
比较运算符“==”不能误写成“=”。

3.4 逻辑运算符

&和&&：表示"且"关系，当符号左右两边布尔值都是 true 时，结果才能为 true。否则，为 false。
|和||：表示"或"关系，当符号两边布尔值有一边为 true 时，结果为 true。当两边都为 false 时，结果为 false。
!：表示"非"关系，当变量布尔值为 true 时，结果为 false。当变量布尔值为 false 时，结果为 true。
^：当符号左右两边布尔值不同时，结果为 true。当两边布尔值相同时，结果为 false。

区分“&”和“&&”：
相同点：如果符号左边是 true，则二者都执行符号右边的操作。
不同点：&：如果符号左边是 false，则继续执行符号右边的操作；&&：如果符号左边是 false，则不再继续执行符号右边的操作。

区分“|”和“||”：
相同点：如果符号左边是 false，则二者都执行符号右边的操作。
不同点：| ：如果符号左边是 true，则继续执行符号右边的操作；|| ：如果符号左边是 true，则不再继续执行符号右边的操作。

public class LogicOperator {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c = 5;

        // & 和 && 的区别
        System.out.println("& 和 && 的区别");
        System.out.println((a > b) & (a++ > c));
        System.out.println("a = " + a); // a = 4
        System.out.println((a > b) && (a++ > c));
        System.out.println("a = " + a); // a = 4
        System.out.println((a == b) && (a++ > c));
        System.out.println("a = " + a); // a = 5

        // | 和 || 的区别
        System.out.println("| 和 || 的区别");
        System.out.println((a > b) | (a++ > c));
        System.out.println("a = " + a); // a = 6
        System.out.println((a > b) || (a++ > c));
        System.out.println("a = " + a); // a = 6
        System.out.println((a == b) || (a++ > c));
        System.out.println("a = " + a); // a = 7
    }
}

3.5 位运算符

左移（<< ）运算规则：在一定范围内，数据每向左移动一位，相当于原数据 * 2^次方。（正数、负数都适用）
- 3 << 4 类似于 3 * 2⁴ = 48
- -3 << 4 类似于 -3 * 2⁴ = 48
右移（>>）运算规则：在一定范围内，数据每向右移动一位，相当于原数据 / 2^次方，如果不能整除，向下取整。（正数、负数都适用）
- 69 >> 4 类似于 69 / 2⁴ = 4
- -69 >> 4 类似于 -69 / 2⁴ = -5
无符号右移（>>>）运算规则：往右移动后，左边空出来的位直接补 0。（正数、负数都适用）
- 69 >>> 4 // 结果：4
- -69 >>> 4 // 结果：268435451
按位与（&）运算规则：对应位都是 1 才为 1，否则为 0。
- 9 & 7 // 结果：1
- -9 & 7 // 结果：7
按位或（|）运算规则：对应位只要有 1 即为 1，否则为 0。
- 9 | 7 // 结果：15
- -9 | 7 // 结果：-9
按位异或（^）运算规则：对应位一个为 1 一个为 0，才为 1，否则为 0。
- 9 ^ 7 // 结果：14
- -9 ^ 7 // 结果：-16
按位取反（~）运算规则：对应位为 1，则结果为 0；对应位为 0，则结果为 1。
- ~9 // 结果：-10
- ~-9 // 结果：8

3.6 三元运算符

// 数值类型取决于`值1`和`值2`的数值类型
数据类型 变量名 = 关系表达式  值1 : 值2;

// 判断三个数的最小值
int a = 60, b = 70, c = 80;
int min = a > b ? (b > c ? c : b) : (a > c ? c : a)
System.out.println(min); // 60

3.7 运算符优先级

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。

在这里插入图片描述

4 ASCII 码

5 键盘输入 Scanner

键盘输入代码的四个步骤：

导包：import java.util.Scanner;
创建 Scanner 类型的对象：Scanner sc = new Scanner(System.in);
调用 Scanner 类的相关方法（next() / nextXxx()），来获取指定类型的变量；
释放资源：sc.close()。

Scanner sc = new Scanner(System.in);

System.out.println("请输入姓名：");
String name = sc.next();
System.out.println("姓名：" + name);

System.out.println("请输入年龄：");
int age = sc.nextInt();
System.out.println("姓名：" + age);

System.out.println("请输入语文成绩：");
double score = sc.nextDouble();
System.out.println("语文成绩：" + score);

sc.close();

FangYiHeng_

关注

15
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
001-Java基础

=：将符号左边的值和右边的值进行相加操作，再把结果的类型强制转化为符号遍的类型，最后将结果赋值给左边的变量。当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会。当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时。规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型。规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型。按位与（&）运算规则：对应位都是 1 才为 1，否则为 0。
复制链接

扫一扫