【运算符、键盘录入、类型转换】
今日内容介绍
运算符【重点】 键盘录入【重点】 数据类型转换【难点非重点: 理解】
学习目标
能够获取键盘录入的数据完成各种数学运算 能够知道类型转换的格式和顺序 能够说出常见的运算符有哪几种 能够知道除法和取余的区别 能够完成字符和字符串的加法 能够知道&&和&的区别 能够使用三元运算符完成获取两个数中较大值 能够使用键盘录入数据并完成两个数据求和
第一章 运算符【重点中的重点】
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
}
}
