02 IDEA的安装与运算符。
一、IDEA的安装
1.1 IDEA首次驱动
查看文件夹 IDEA操作文档\01_首次驱动项目和模块的创建.docx文件
一.相关概念:
1.项目: project
2.模块: module
3.java源代码存放位置:src
4.包(文件夹): package 相当于文件夹，一般使用倒置的域名如（com.baidu.项目名）
5.java程序: 类,接口,抽象类等
二.操作步骤:
1.在某个盘符下创建一个名称为myprojects的文件夹,用来存储多个项目的
2.在myprojects文件夹下创建一个名称为javase410的项目
3.在javase410的项目中创建名称为day01/day02的Java模块
4.在day01/day02模块的src下创建名称为itheima01的包
5.在itheima01包中创建HelloWorld类
三.注意:
1.不管是项目,模块,src,包在系统中的体现形式都是文件夹
2.但是src是创建模块后自动生成的,不需要自己创建
3.源代码必须写在src下才能运行,其它位置不可以
1.2 快捷键
1. psvm + 回车 main方法
2. sout + 回车 输出语句
3. ctrl + d 复制当前行
4. ctrl + y 删除当前行
5. ctrl + / 单行注释
6. ctrl + shift + / 多行注释
7. ctrl + alt + L 格式化代码(和QQ中的热键冲突,必须把QQ中的热键取消)
8. ctrl+shift+回车 自动补全代码
9. Alt + shift + ↑/↓ 将当前代码向上移动或者是向下移动
10. shift+回车 向下添加一行
11. ctrl+alt+回车 向上添加一行
12. alt+鼠标选中多行 可以对多行进行同时操作
13. alt+/ 自动（搜索）补全代码
14. alt+回车 代码修正提示
15. ctrl+r 替换
16. 变量.sout 自动生成输出语句输出该变量
17. new ....().var 自动生成变量
18. new ....()写完后 alt + 回车 自动生成变量
19. 数字.fori 生成从小到大的for循环
20. 数字.forr 生成从大到小的for循环
如33.fori --------->for (int i = 0; i < 33; i++) {
}
33.forr --------->for (int i = 33; i > 0; i--) {
}
21. alt+insert 创建类/包/接口
22.ctrl+P 查看方法的参数列表
23.ctri+alt+m 抽取方法
24.ctrl+n 查看jdk中类的源代码 输入类名------->如果显示的没有要看的类---->再次ctrl+n
25.ctrl+f12 在源代码中查找方法 输入方法名---->在下面的显示列表中选定方法，然后点击回车
26.alt + insert --> getter and setter --> 选定成员变量 给所有private修饰的成员变量提供getter和setter方法
27.空参构造快捷键: alt + insert --> Constructor 提供空参构造方法(必须提供)和满参构造方法(可选的)
满参构造快捷键: alt + insert --> Constructor --> 选择成员变量
28.ctrl+shift+u 大小写转换
29.集合对象.fori 正着遍历
30.集合对象.forr 倒着遍历
31.itli 生成遍历集合的for循环，内部会获取元素
32.itar 生成遍历数组的for循环，内部会获取元素
二、运算符
2.1 算术运算符
2.1.1 算术运算符加减乘除
package com.itheima03_suanshu;
/*
算术运算符
1.运算符：对常量或者变量进行操作/运算的符号
2.表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。
3.数学运算符:
(1)+: 加法运算
(2)-: 减法运算
(3)*: 乘法运算
(4)/: 除法运算
被除数 ÷ 除数 = 商(/:获取的是除法运算中的商) ... 余数
注意：整数相除，得到结果一定是整数
小数相除，得到的结果一定是小数
*/
public class Demo03Operator {
public static void main(String[] args) {
//定义2个int变量,并初始化
//int a = 30;
//int b = 20;
int a = 30, b = 20;
System.out.println(a + b);//30+20:50
System.out.println(a - b);//30-20:10
System.out.println(a * b);//30*20:600
System.out.println(a / b);//30/20: 1
}
}
2.1.2 算术运算符%
%(取余数)运算符
被除数 ÷ 除数 = 商(/:获取的是除法运算中的商) ... 余数(%:获取的是除法运算中的余数)
总结:
/和%都是做数学中的除法运算,只不过/获取到的是除法运算中的商,%获取到的是除法运算中的余数
练习
/*
int变量num中存储四位数字1234,利用/和%计算个位十位百位千位?
个位: 4
十位: 3
百位: 2
千位: 1
总结:
个位: num%10
十位: num/10%10
百位: num/100%10
千位: num/1000%10 如果确定是四位数字,可以省略%10
*/
public class Demo03Lianxi {
public static void main(String[] args) {
//定义int变量num,并初始化
int num = 1234;
//计算个位
int ge = num % 10;//把表达式num % 10的计算结果保存到int变量ge中
//计算十位
int shi = num / 10 % 10;
//计算百位
int bai = num / 100 % 10;
//计算千位
int qian = num / 1000 % 10;
//此处 + 号 代表 字符串的连接
System.out.println("个位: " + ge);
System.out.println("十位: " + shi);
System.out.println("百位: " + bai);
System.out.println("千位: " + qian);
}
}
2.1.3 算术运算符+的特殊用法
+的作用:
1.完成数学中的加法运算
2.完成字符串的连接(拼接): 如果+的左右两边出现字符串
注意：
字符串拼接时是从左向右运行的。
如果字符和（整数或者小数）进行+拼接操作的时候会将字符转换为ASCII码再和整数进行算术运算
System.out.println(6+3+"你好") ------------>结果是 9你好
System.out.println(666+"你好"+666)--------->结果是 666你好666
System.out.println("你好"+666+666)--------->结果是 你好666666
System.out.println('A'+66+"你好")---------->结果是 131你好
System.out.println('a'+3.8+"你好")--------->结果是 100.8你好
System.out.println('你'+3.8+"你好")-------->结果是 20323.8你好
2.2 赋值运算符
+= 加后赋值 a+=b，将a+b的值给a a = a + b
-= 减后赋值 a-=b，将a-b的值给a a = a - b
*= 乘后赋值 a*=b，将a×b的值给a a = a * b
/= 除后赋值 a/=b，将a÷b的商给a a = a / b
%= 取余后赋值 a%=b，将a÷b的余数给a a = a % b
注意:
1.=: 表示的是赋值运算
2.==: 表示的是判断是否相同
2.3 自增自减运算符
自增(++)自减(--)运算符
1.作用: 就是让变量的值增加1(++)或者减少1(--)
2.使用格式:
(1)可以写在变量的前面: ++a,--a
(2)可以写在变量的后面: a++,a--
3.使用注意事项:
(1)单独使用:++或者--自己独占一行,没有其它多余的操作
此时:
前++和后++效果一样,都是让变量的值增加1
前--和后--效果一样,都是让变量的值减少1
(2)混合使用: ++或者-- 和其它操作(赋值/打印)一起进行运算
将产生重大区别:
++/--写在前面【先++/--,再使用】:
先把变量值增加1(++)或者减少1(--),然后把变量增加1(++)或者减少1(--)的结果进行其它运算
++/--写在后面【先使用,再++/--】:
先使用变量增加1(++)或者减少1(--)之前的数据,然后变量的值再增加1(++)或者减少1(--)
public class Demo06ZiZeng {
public static void main(String[] args) {
int a = 1;
/*
因为++在变量a的前面,先把变量a的值增加1,变量a的值变成2,
然后再使用变量a增加1之后的结果2赋值给变量b,所以变量b的值是2
*/
int b = ++a;
System.out.println(a);//2
System.out.println(b);//2
int c = 1;
/*
因为++在c变量c的后面,先使用变量c增加1之前的值1,赋值给变量d,
所以d的值是1,然后c的值增加1,c变成2
*/
int d = c++;
System.out.println(c);//2
System.out.println(d);//1
}
}
练习
计算打印出来的i的值。
public class Demo04Scanner {
public static void main(String[] args) {
/*
需要先计算表达式i++的结果，因为++在后面，所以先使用i的值0，作为i++表达式的结果。
之后i的值增加，i变成1。最后将i++的表达式的结果0赋值给i，所以最终i的值为0.
i的变化为： 0-------> 1 --------->0
*/
int i = 0;
i = i++;
i = i++;
i = i++;
i = i++;
System.out.println(i);
}
}
2.4 关系运算符
1.作用:
用来比较两个数据之间的大小关系,结果是boolean类型的数据
2.特点:
关系表达式不管写的多么复杂,或者多么简单,最终结果要么是true(成立),要么是false(不成立)
3.分类:
== a==b， 判断a和b的值是否相等，成立为true，不成立为false
> a>b， 判断a是否大于b，成立为true，不成立为false
>= a>=b， 判断a是否大于或者等于b，成立为true，不成立为false
< a<b， 判断a是否小于b，成立为true，不成立为false
<= a<=b， 判断a是否小于或者等于b，成立为true，不成立为false
！= a!=b， 判断a和b的值是否不相等，成立为true，不成立为false
4.注意:
1.=: 表示的是赋值运算
2.==: 表示的是判断是否相同
//关系表达式
public class Demo06GuanXi {
public static void main(String[] args) {
int a = 10, b = 20;
System.out.println(a > b);//10 > 20: false
System.out.println(a >= b);//10 >= 20: false
System.out.println(a < b);//10 < 20: true
System.out.println(a <= b);//10 <= 20: true
System.out.println(a != b);//10 != 20: true
System.out.println(a == b);//10 == 20: false
//把变量b的值赋值给变量a,然后再打印a的值
System.out.println(a = b);//20
}
}
2.5 逻辑运算符
1.作用:
用来连接多个布尔表达式的,结果也是布尔类型
2.分类:
(1)逻辑与(&:shift+7)【有false，则false】:
表示并且的意思,同时成立的意思
多个条件都为true,结果才为true
多个条件只要有一个为false,结果就是false
(2)逻辑或(|:shift+\)【有true，则true】:
表示或者的意思
多个条件只要有一个为true,结果就是true
多个条件都是false,结果就是false
(3)逻辑异或(^:shift+6): 目前暂时不用
相同为false,不同为true
(4)逻辑非(!:shift+1):
!true: 就是false
!false: 就是true
//逻辑运算符
public class Demo07LuoJi {
public static void main(String[] args) {
int a = 10, b = 20, c = 30;
System.out.println((a > b) & (a > c));//false & false --> false
System.out.println((a < b) & (a < c));//true & true --> true
System.out.println((a > b) & (a < c));//false & true --> false
System.out.println((a < b) & (a > c));//true & false --> false
System.out.println("-------------------");
System.out.println((a > b) | (a > c));//false | false --> false
System.out.println((a < b) | (a < c));//true | true --> true
System.out.println((a > b) | (a < c));//false | true --> true
System.out.println((a < b) | (a > c));//true | false --> true
System.out.println("-------------------");
System.out.println((a > b) ^ (a > c));//false ^ false --> false
System.out.println((a < b) ^ (a < c));//true ^ true --> false
System.out.println((a > b) ^ (a < c));//false ^ true --> true
System.out.println((a < b) ^ (a > c));//true ^ false --> true
System.out.println("-------------------");
System.out.println(!true);//false
System.out.println(!false);//true
System.out.println(a != b);//true
System.out.println(!(a == b));//!false --> true
}
}
2.5.1 逻辑运算符的短路效果
1.基本使用
(1)短路逻辑与(&&): 左侧为false,右侧不进行计算
(2)短路逻辑或(||): 左侧为true,右侧不进行计算
2.使用区别:
(1)&&和&: 最终的结果是相同的,但是&&具有短路的效果,效率高
(2)||和|: 最终的结果是相同的,但是||具有短路的效果,效率高
3.注意:
以后实际学习/开发过程中,需要连接多个条件时,强烈建议使用&& 或者 ||
public class Demo08DuanLu {
public static void main(String[] args) {
int a = 1;
/*
表达式(3 < 2) && (++a) > 1: 从左向右计算
先计算表达式3<2的结果:false
对于&&而言,左侧为false,已经决定了最终的结果为false,&&的右侧不再计算,
所以a的值没有变化,还是1
*/
System.out.println((3 < 2) && ((++a) > 1));//false
System.out.println(a);//1
int b = 1;
/*
表达式(3 < 2) & (++b) > 1: 从左向右计算
先计算表达式3<2的结果:false
对于&而言,虽然左侧为false,已经决定了最终的结果为false,
但是仍然要计算&的右侧的表达式,导致b的值增加1,b变成2
*/
System.out.println((3 < 2) & ((++b) > 1));//false
System.out.println(b);//2
System.out.println("--------------");
int c = 1;
/*
表达式(3 > 2) || (++c) > 2: 从左向右计算
先计算表达式3 > 2的结果:true
对于||而言,左侧为true,已经决定了最终的结果为true,||的右侧不再计算,
所以c的值没有变化,还是1
*/
System.out.println((3 > 2) || ((++c) > 2));//true
System.out.println(c);//1
int d = 1;
/*
表达式(3 > 2) | (++d) > 2: 从左向右计算
先计算表达式3>2的结果:true
对于|而言,虽然左侧为true,已经决定了最终的结果为true,
但是仍然要计算|的右侧的表达式,导致d的值增加1,d变成2
*/
System.out.println((3 > 2) | ((++d) > 2));//true
System.out.println(d);//2
}
}
2.6 三元运算符格式
1.格式:
数据类型 变量名称 = 布尔表达式1 ？ 表达式2 ： 表达式3；
注意：
？号前面的式子的结果必须是布尔类型
2.执行流程:
（1）计算布尔表达式1的结果，看是true，还是false
（2）如果布尔表达式1的结果是true，取表达式2的结果赋值给左侧的变量
（3）如果布尔表达式1的结果是false，取表达式3的结果赋值给左侧的变量
练习
需求：
一座寺庙里住着两个和尚，已知他们的身高分别为150cm、210cm，请用程序实现获取这两个和尚的最高身高。
实现步骤:
1.定义两个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
2.用三元运算符获取两个和尚的较高身高值，并用临时身高变量保存起来。
3.输出结果
public class OperatorTest02 {
public static void main(String[] args) {
//1.定义两个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
int h1 = 150;
int h2 = 210;
//2.用三元运算符获取两个和尚的较高身高值，并用临时身高变量保存起来。
int maxH = h1 > h2 ? h1 : h2;
//3.输出结果
System.out.println("两个和尚的最大身高:" + maxH);
}
}
三、键盘录入
导入class类时，同一个包内的class可以相互使用
键盘录入Scanner类的使用:
1.导包(找到我们要使用的东西) import 引入
格式: import 包名.类名;
Scanner类的导包: import java.util.Scanner;
2.创建对象
格式: 类名 对象名 = new 类名(参数列表...);
解释:
(1)类名: class关键字后面指定的名字
(2)对象名: 就是我们前面用的变量名,是一个标识符(符合命名规则)
(3)=: 赋值的过程
(4)new: 开辟内存空间创建对象的过程
(5)参数列表: 根据需求指定
创建Scanner类的对象:
Scanner sc = new Scanner(System.in);
注意: ()中的System.in目前是固定写法,就业班详细学习
3.使用对象:
sc.nextInt(): 获取键盘录入的整数数字(int范围)
sc.nextDouble(): 获取键盘录入的小数数字(double范围)
package com.itheima01; //定义包
import java.util.Scanner; //导包
public class Demo04Scanner {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//也可以 new Scanner(System.in).var 然后点回车 再对标识符进行修改
System.out.println("请输入一个整数：");
int a = sc.nextInt();
System.out.println("输入的整数为：" + a);
System.out.println("请输入一个小数：");
double b = sc.nextDouble();
System.out.println("输入的小数为：" + b);
System.out.println("请输入一个布尔值：");
boolean c = sc.nextBoolean();
System.out.println("输入的布尔值为：" + c);
System.out.println("请输入字符串：");
String d = sc.next(); //不能包括空格，见到空格就代表输入结束，就算空格后面还有数据也不算了。
//String d = sc.nextLine(); // 获取一行数据，输入回车结束
System.out.println("输入的字符串为：" + d);
}
}
练习
输入两个整数，将这两个整数的值进行交换。
package com.itheima01; //定义包
import java.util.Scanner; //导包
public class Demo04Scanner {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
int a = sc.nextInt();
System.out.println("请再输入一个整数：");
int b = sc.nextInt();
a = b^a; // 这里的^代表的是逻辑异或
b = b^a;
a = a^b;
System.out.println("交换之后第一个整数为：" + a);
System.out.println("交换之后第二个整数为：" + b);
}
}
四、数据类型转换
4.1 自动类型转换【从小到大自动】
Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。
举例:
int + int: 类型一致,可以直接计算
int + long: 类型不一致,不可以直接计算
解决方案一:
int + long --> long + long : 转换后类型一直,可以直接计算
把int类型转换成long类型,从小到大,叫做自动类型转换(自动完成)
解决方案二:
int + long --> int + int: 转换后类型一直,可以直接计算
把long类型转换成int类型,从大到小,叫做强制类型转换(不会自动完成,必须手动处理)
1.自动类型转换概念:
取值范围小的数据/变量,可以直接赋值给取值范围大的变量(小萝卜可以直接放入大坑中)
2.特点:
(1)是自动完成的,不需要代码的特殊处理
(2)byte/short/char类型,至少会自动类型转换为int类型
(3)转换规则: byte、short、char-->int-->long-->float-->double
总结:
整个表达式中的所有类型,都会自动转换成表达式中最大的类型,结果也是最大的类型
举例:00000000
有一个byte类型(1个字节)的数字5: 00000101
byte类型自动类型转换成short类型(2个字节):
在左侧补充一个字节的0,因为补充的是0,对于原有数据大小没有影响
00000000 00000101
byte类型自动类型转换成int类型(4个字节):
在左侧补充三个字节的0,因为补充的是0,对于原有数据大小没有影响
00000000 00000000 00000000 00000101
byte类型自动类型转换成long类型(8个字节):
在左侧补充七个字节的0,因为补充的是0,对于原有数据大小没有影响
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101
总结(打肿脸充胖子):
根据需求在左侧补充若干个字节的0,因为补充的是0,对于原有数据大小没有影响
package com.itheima02_zhuanhuan;
//自动类型转换练习一
public class Demo01Convert {
public static void main(String[] args) {
int i = 1;
byte b = 2;
/*
b是byte类型(占1个字节),i是int类型(占4个字节),类型不一致,
会发生自动类型转换,把byte类型的b,转换成int类型(左侧补充3个字节的0)
byte类型的b的2: 00000010
int类型的b的2: 00000000 00000000 00000000 00000010
byte + int --> int + int --> int
结果为int类型(占4个字节),不能直接赋值给左侧byte类型(占1个字节)的变量
一句话: 大萝卜不能直接放入小坑中
解决方案:
1.把坑变大: 把左侧的byte类型变量,改成int类型变量
2.把萝卜变小: 强制类型转换
*/
//byte x = b + i; //报错
/*
b是byte类型(占1个字节),i是int类型(占4个字节),类型不一致,
会发生自动类型转换,把byte类型的b,转换成int类型(左侧补充3个字节的0)
byte类型的b的2: 00000010
int类型的b的2: 00000000 00000000 00000000 00000010
byte + int --> int + int --> int
结果为int类型(占4个字节),可以直接赋值给左侧int类型(占4个字节)的变量
*/
int y = b + i;
System.out.println(y);
}
}
package com.itheima02_zhuanhuan;
//自动类型转换练习二
public class Demo02Convert {
public static void main(String[] args){
int i = 1;
double d = 2.5;
/*
d是double类型(占8个字节),i是int类型(占4个字节),类型不一致,
会发生自动类型转换,把int类型的i,转换成double类型
int类型i的值1,转换成double类型i的值1.0
double + int --> double + double --> double
结果为double类型(占8个字节),不能直接赋值给左侧int类型(占4个字节)的变量
一句话: 大萝卜不能直接放入小坑中
解决方案:
1.把坑变大: 把左侧的int类型变量,改成double类型变量
2.把萝卜变小: 强制类型转换
*/
//int x = d + i; //报错
//System.out.println(x);
/*
d是double类型(占8个字节),i是int类型(占4个字节),类型不一致,
会发生自动类型转换,把int类型的i,转换成double类型
int类型i的值1,转换成double类型i的值1.0
double + int --> double + double --> double
结果为double类型(占8个字节),可以直接赋值给左侧double类型(占8个字节)的变量
*/
double y = d + i;
System.out.println(y);
}
}
4.2 强制类型转换【从大到小强制】
1.强制类型转换概念:
取值范围大的数据或者变量,不能直接赋值给取值范围小的变量,
必须进行强制类型转换(大萝卜不能直接放入小坑当中)
long类型的847: 847-256-512
00000000 00000000 00000000 00000000 00000000 00000000 00000011 01001111
强制类型转换为byte类型:
01001111: 79
long num = 847L;
byte b = (byte)num;//把num强制类型转换成byte类型,砍掉左侧的7个字节的内容
2.格式:
转后类型 变量名称 = (转后类型)转前数字/变量;
3.问题:
可能损失精度
举例:00000000
有一个long类型(8个字节)的数字5:
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101
long类型强制类型转换成int类型(4个字节):
砍掉左侧的四个字节的内容,目前砍掉都是0,对数据大小没有影响,只要砍掉的有1,就会影响数据大小
00000000 00000000 00000000 00000101
long类型强制类型转换成short类型(2个字节):
砍掉左侧的六个字节的内容,目前砍掉都是0,对数据大小没有影响,只要砍掉的有1,就会影响数据大小
00000000 00000101
long类型强制类型转换成byte类型(1个字节):
砍掉左侧的七个字节的内容,目前砍掉都是0,对数据大小没有影响,只要砍掉的有1,就会影响数据大小
00000101
总结:
根据需求,砍掉左侧的若干字节的内容,如果砍掉都是0,对数据大小没有影响,
只要砍掉的有1,就会影响数据大小
package com.itheima02_zhuanhuan;
//强制类型转换练习一
public class Demo03Convert {
public static void main(String[] args){
//short类型变量，内存中占2个字节
short s = 1;
/*
s是short类型(占2个字节),1是int类型(占4个字节),类型不一致,
会发生自动类型转换,把short类型的s,转换成int类型(左侧补充2个字节的0)
short类型s的1: 00000000 00000001
int类型的s的1: 00000000 00000000 00000000 00000001
short + int --> int + int --> int
结果为int类型(占4个字节),不能直接赋值给左侧short类型(占2个字节)的变量
一句话: 大萝卜不能直接放入小坑中
解决方案:
1.把坑变大: 把左侧的short类型变量,改成int类型变量
2.把萝卜变小: 强制类型转换
*/
//s = s + 1; //报错
//System.out.println(s);
/*
s是short类型(占2个字节),1是int类型(占4个字节),类型不一致,
会发生自动类型转换,把short类型的s,转换成int类型(左侧补充2个字节的0)
short类型s的1: 00000000 00000001
int类型的s的1: 00000000 00000000 00000000 00000001
short + int --> int + int --> int
结果为int类型(占4个字节),不能直接赋值给左侧short类型(占2个字节)的变量
但是把int类型的结果数据强制类型转换为short类型(砍掉左侧的2个字节的内容)
int类型的结果2: 00000000 00000000 00000000 00000010
强转成short类型的结果2: 00000000 00000010
*/
s = (short)(s + 1);
System.out.println(s);
}
}
package com.itheima02_zhuanhuan;
//强制类型转换练习二
public class Demo04Convert {
public static void main(String[] args){
/*
小数数字1.5是double类型(占8个字节),不能直接赋值给左侧的int变量(占4个字节)
一句话: 大萝卜不能直接放入小坑中
解决方案:
1.把坑变大: 把左侧的short类型变量,改成int类型变量
2.把萝卜变小: 强制类型转换
*/
//int j = 1.5; //报错
//System.out.println(j);
/*
小数数字1.5是double类型(占8个字节),不能直接赋值给左侧的int变量(占4个字节)
但是我们把数字1.5强制类型转换成int类型(直接砍掉小数部分)
*/
int i = (int)1.5;
System.out.println(i);
}
}
//强制类型转换练习三
public class Demo04Scanner {
public static void main(String[] args) {
short s = 30;
int i = 50;
s += i; //这里的s+=i 相当于s = (short)(s+i)
System.out.println("s="+s); //80
}
}
4.3 ASCII码表
计算机是一个二货,只能存储0和1,所以存储到计算机中的所有内容都会转换成0和1进行存储
所以我们在计算机中存储的字符也不例外,也需要把字符转换成0和1进行存储
问题: 如何把字符转换成对应的0和1进行存储呢?
解决方案:
编码表：就是将人类的文字和一个十进制数进行对应起来组成一张表格。
存储字符时：需要查找ASCII码表,找到字符对应的数字,将数字转换为二进制数存放到计算机中
使用字符时：将对应的二进制数转换为十进制 找到ASCII码表中对应的字符 显示出来
总结:
存储字符时:
'a' --> 97 --> 1100001 26个小写字母的ASCII码值是连续的,相差1
'A' --> 65 --> 1000001 26个大写字母的ASCII码值是连续的,相差1
'0' --> 48 --> 110000 10个数字字符的ASCII码值是连续的,相差1
小写字母的ASCII码值比对应的大写字母多32
使用字符时
1100001 --> 97 --> 'a'
1000001 --> 65 --> 'A'
110000 --> 48 --> '0'
4.4 int类型和char类型的运算原理
package com.itheima02_zhuanhuan;
//char和int之间的运算原理
public class Demo05Char {
public static void main(String[] args) {
char ch = 'a';
System.out.println(ch);//a
/*
ch是char类型,1是int类型,不一致,会发生自动类型转换
byte/short/char类型,至少会自动类型转换为int类型
把char类型转换成int类型
问题:
如何把char类型自动转换成int类型呢?
查看ASCII码表
'a' --> 97
char + int --> int + int --> int
'a' + 1 --> 97 + 1 --> 98
*/
System.out.println(ch + 1);//98
/*
ch是char类型,1是int类型,不一致,会发生自动类型转换
byte/short/char类型,至少会自动类型转换为int类型
把char类型转换成int类型
char + int --> int + int --> int
'a' + 1 --> 97 + 1 --> 98
但是最终把int类型的结果强制类型转换为char类型
问题:
如何把int类型的结果强制类型转换为char类型?
查看ASCII码表:
98 --> 'b'
*/
System.out.println((char)(ch + 1));//b
}
}
浙公网安备 33010602011771号