【运算符、键盘录入、类型转换】
今日内容介绍
运算符【重点】 键盘录入【重点】 数据类型转换【难点非重点: 理解】
学习目标
能够获取键盘录入的数据完成各种数学运算 能够知道类型转换的格式和顺序 能够说出常见的运算符有哪几种 能够知道除法和取余的区别 能够完成字符和字符串的加法 能够知道&&和&的区别 能够使用三元运算符完成获取两个数中较大值 能够使用键盘录入数据并完成两个数据求和
第一章 运算符【重点中的重点】
1.1 算术运算符加减乘除
1.运算符:对常量或者变量进行操作/运算的符号 2.表达式:用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。 3.数学运算符: (1)+: 加法运算 (2)-: 减法运算 (3)*: 乘法运算 (4)/: 除法运算 被除数 ÷ 除数 = 商(/: 获取除法运算中的商) ... 余数(%: 获取除法运算中的余数)
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 } }
1.1.1 算术运算符%
%运算符(取余数运算符) %的作用: 1.判断数字的奇偶性 偶数(可以被2整除): 数字%2 的 结果是0 奇数(不可以被2整除): 数字%2 的 结果不是0 ==> 结果是1 2.判断一个数字能否被另外一个数字整除 结果为0: 说明可以被整除 结果不为0: 说明不可以被整除
package com.itheima03_suanshu; /* %(取余数)运算符 被除数 ÷ 除数 = 商(/:获取的是除法运算中的商) ... 余数(%:获取的是除法运算中的余数) 总结: /和%都是做数学中的除法运算,只不过/获取到的是除法运算中的商,%获取到的是除法运算中的余数 作用: 1.判断数字的奇偶性: 偶数: 可以被2整除,余数是0 奇数: 不可以被2整除,余数是1 2.判断一个数字能否被另一个数字整除 结果是0: 可以被整除 结果不是0: 不可以被整除 思考: int变量num中存储四位数字1234,利用/和%计算个位十位百位千位? 个位: 4 十位: 3 百位: 2 千位: 1 */ public class Demo04Operator { public static void main(String[] args) { System.out.println(16 % 2);//0: 说明16是偶数 System.out.println(21 % 2);//1: 说明21是奇数 System.out.println(100 % 25);//0: 说明100可以被25整除 System.out.println(111 % 25);//11: 说明111不可以被25整除 } }
/* 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); } }
1.1.2 算术运算符+的特殊用法
+的作用 1.完成数学中的加法运算 2.完成字符串的连接(拼接): 如果+的左右两边出现字符串
package com.itheima03_suanshu; /* +的作用 1.完成数学中的加法运算: +左右两边都是数字或者字符 2.完成字符串的连接(拼接): 如果+的左右两边出现字符串 */ public class Demo05Operator { public static void main(String[] args) { System.out.println(5 + 5);//10 System.out.println(5 + "HelloWorld");//5HelloWorld System.out.println("HelloWorld" + 5);//HelloWorld5 System.out.println("Hello" + "World");//HelloWorld /* 表达式"5+5=" + 5 + 5: 从左向右执行 先计算表达式"5+5=" + 5: +号左侧是字符串"5+5=",右侧是数字5,此处+号代表字符串的连接 表达式"5+5=" + 5的结果: "5+5=5" 再计算表达式"5+5=5" + 5: +号左侧是字符串"5+5=5",右侧是数字5,此处+号代表字符串的连接 最终结果: "5+5=55" */ System.out.println("5+5=" + 5 + 5);//5+5=55 /* 表达式"5+5=" + (5 + 5): 从左向右执行 但是优先计算()中的内容,先计算表达式(5 + 5): 结果是10 再计算表达式"5+5=" + 10: +号左侧是字符串"5+5=",右侧是数字10,此处+号代表字符串的连接 最终结果: "5+5=10" */ System.out.println("5+5=" + (5 + 5));//5+5=10 } }
1.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.==: 表示的是判断是否相同
//赋值运算符 public class Demo04FuZhi { public static void main(String[] args) { //定义2个int变量并初始化 int a = 30, b = 20; a += b;//a = a + b System.out.println(a);//50 System.out.println(b);//20 System.out.println("----------"); //定义2个int变量未初始化 int c, d; c = 100; d = 25; c /= d;//c = c / d System.out.println(c);//4 System.out.println(d);//25 System.out.println("----------"); int e = 100, f = 25; e %= f;//e = e % f System.out.println(e);//0 System.out.println(f);//25 } }
1.3 自增自减运算符
/* 自增(++)自减(--)运算符 1.作用: 就是让变量的值增加1(++)或者减少1(--) 2.使用格式: (1)可以写在变量的前面: ++a,--a (2)可以写在变量的后面: a++,a-- 3.使用注意事项: (1)单独使用:++或者--自己独占一行,没有其它多余的操作 此时: 前++和后++效果一样,都是让变量的值增加1 前--和后--效果一样,都是让变量的值减少1 (2)混合使用: ++或者-- 和其它操作(赋值/打印)一起进行运算 将产生重大区别: ++/--写在前面【先++/--,再使用】: 先把变量值增加1(++)或者减少1(--),然后把变量增加1(++)或者减少1(--)的结果进行其它运算 ++/--写在后面【先使用,再++/--】: 先使用变量增加1(++)或者减少1(--)之前的数据,然后变量的值再增加1(++)或者减少1(--) 4.注意: 虽然++和--可以写出非常非常复杂的表达式,那些是研究生们研究的问题 我们最常用的就是: a++: 变量a的值增加1 a--: 变量a的值减少1 */
public class Demo05ZiZeng { public static void main(String[] args) { int a = 1; //单独使用 a++;//等价于: a = a + 1 System.out.println(a);//2 int b = 1; //单独使用 ++b;//等价于: b = b + 1 System.out.println(b);//2 int c = 2; //单独使用 c--;//等价于: c = c - 1 System.out.println(c);//1 int d = 2; //单独使用 --d;//等价于: d = d - 1 System.out.println(d);//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 } }
1.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 } }
1.5 逻辑运算符
举例: 咱们班哥们在黑马学习java,顺利毕业,高薪就业,找到了对象,谈了好长时间,需要谈婚论嫁 到你对象家和准岳母谈判: 准岳母: 小伙子呀,你呢? 必须得有房(条件1:true/false), 而且呢,你呀,还得有车(条件2:true/false),然后你们的婚事才能决定下来(结果: true/false) 总结: 像上面的两个/多个条件必须都得成立,结果才成立 只要有一个条件不成立,结果就不成立,此时这多个条件使用逻辑与&来连接 准岳母: 小伙子呀,你呢? 要么有房(条件1:true/false),要么有车(条件2:true/false), 然后你们的婚事才能决定下来(结果: true/false),使用逻辑或运算符|连接多个条件 总结: 像上面的两个/多个条件只要有一个条件成立,结果就成立 如果所有条件都不成立,那么结果就不成立,此时这多个条件使用逻辑或|来连接 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 } }
1.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 } }
1.6 三元运算符格式
1.格式: 数据类型 变量名称 = 布尔表达式1 ? 表达式2 : 表达式3; 注意: ?号前面的式子的结果必须是布尔类型 2.执行流程: (1)计算布尔表达式1的结果,看是true,还是false (2)如果布尔表达式1的结果是true,取表达式2的结果赋值给左侧的变量 (3)如果布尔表达式1的结果是false,取表达式3的结果赋值给左侧的变量
执行流程图解:
1.6.1 三元运算符的练习之两个和尚
需求: 一座寺庙里住着两个和尚,已知他们的身高分别为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); } }
第二章 数据输入(应用)
2.1 键盘录入的基本使用
数据输出: 把程序的运行结果输出到控制台,从而显示到屏幕上 数据输入: 获取键盘录入的数据到程序中,从而在程序中对数据进行相关的运算 问题1: 键盘录入很常用,如果每个程序员自己实现将非常麻烦,所以JDK的开发人员帮助我们实现了获取键盘录入数据的功能,把该功能定义到一个叫做Scanner的类中,同时把这个Scanner类放入java.util包中 问题2: 如何使用jdk中的某个包中的某个类呢? java中数据类型分为基本类型(四类八种)和引用类型,对于引用类型的使用有固定的三个步骤 然后键盘录入java.util.Scanner类也是一个引用类型,使用也有固定的三个步骤 键盘录入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范围)
2.2 键盘录入的理解
import java.util.Scanner;//导包 public class Demo09Scanner { public static void main(String[] args) { //(1)导包: import java.util.Scanner //(2)创建键盘录入Scanner类的对象sc Scanner sc = new Scanner(System.in); //(3)使用使用Scanner类的对象sc获取键盘录入的两个整数数字 System.out.println("请输入第一个整数数字: "); //获取到键盘录入的int数字,赋值给变量a int a = 1000; //(4)把整数数字输出到控制台 System.out.println("您输入的第一个整数数字: " + a); System.out.println("请输入第二个整数数字: "); //获取到键盘录入的int数字,赋值给变量b int b = sc.nextInt(); //(4)把整数数字输出到控制台 System.out.println("您输入的第二个整数数字: " + b); } }
2.3 键盘录入的练习
/* 键盘录入练习 需求: 获取键盘录入的两个整数(int类型)数字,在控制台输出求和的结果。 实现步骤: 1.导包(找到我们要所以的键盘录入功能): import java.util.Scanner 2.创建键盘录入Scanner类的对象sc: Scanner sc = new Scanner(System.in); 3.获取键盘录入的两个int数字,分别保存到两个int变量a和b中 4.计算变量a和b的和,保存到int变量sum中 5.打印sum的值 注意事项: 不用自己手动导包,自己写import java.util.Scanner; (1)正确的写出Scanner类的前几个字母,根据提示,选择Scanner类,会自动导包 建议使用 (2)正确的写出Scanner类的名字,如果没有提示: 快捷键alt + / */
import java.util.Scanner;//导包 public class Demo10ScannerSum { public static void main(String[] args) { //1.导包(找到我们要所以的键盘录入功能): import java.util.Scanner //2.创建键盘录入Scanner类的对象sc: Scanner sc = new Scanner(System.in); Scanner sc = new Scanner(System.in); //3.获取键盘录入的两个int数字,分别保存到两个int变量a和b中 System.out.println("请输入第一个整数数字: "); int a = sc.nextInt(); System.out.println("请输入第二个整数数字: "); int b = sc.nextInt(); //4.计算变量a和b的和,保存到int变量sum中 int sum = a + b; //5.打印sum的值 System.out.println(a + " 和 " + b + " 这两个数字的和: " + sum); } }
第三章 数据类型转换【理解】
3.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); } }
3.2 强制类型转换【从大到小强制】
1.强制类型转换概念: 取值范围大的数据或者变量,不能直接赋值给取值范围小的变量, 必须进行强制类型转换(大萝卜不能直接放入小坑当中) long类型的888: 888-256-512 00000000 00000000 00000000 00000000 00000000 00000000 00000011 0111 1000 强制类型转换为byte类型: 01001111: 120 long num = 888L; 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); } }
3.3 ASCII码表
计算机是一个二货,只能存储0和1,所以存储到计算机中的所有内容都会转换成0和1进行存储 所以我们在计算机中存储的字符也不例外,也需要把字符转换成0和1进行存储 问题: 如何把字符转换成对应的0和1进行存储呢? 解决方案: 编码表:就是将人类的文字和一个十进制数进行对应起来组成一张表格。 存储字符时:需要查找ASC码表,找到字符对应的数字,将数字转换为二进制数存放到计算机中 使用字符时:将对应的二进制数转换为十进制 找到ASC表中对应的字符 显示出来 总结: 存储字符时: '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'
3.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 } }