Day03
数据类型转换之强制转换(显式转换)
- 大范围的数据类型，想要转为小范围数据类型，就要强制转换
- 格式:
- 小范围数据类型 新的名称 = (要转换的小范围数据类型)大范围的数据
- 强制转换的结果，可能跟你想的不太一样
代码
class Demo02 {
public static void main(String[] args) {
int i = 100;
//想要转为byte
//小范围数据类型 新的名称 = (要转换的小范围数据类型)大范围的数据
byte b = (byte)i;
System.out.println(b);
//byte的范围是 -128~127
//大的往小的去转的时候，要考虑是否装的下，装的下再转，装不下一般就别转了
int a = 256;
byte b2 = (byte)a;
System.out.println(b2);
float f = 1.9899f;
//所有的小数部分直接不保留
long l = (long)f;
System.out.println(l);
//强制转换的核心 (要转换的数据类型)要转换的数据
//此处的要转换的数据类型，可以是大的，也可以是小的
System.out.println((double)l);//将l提升为double类型
System.out.println((byte)l);//将l缩小了
}
}字符类型
- 使用单引号引起来的单个字符就是字符常量，对应数据类型就是char
- 在计算机中，所有的数据都是以数字形式来存储，字符也不例外
- 字符和计算机之间有一个对应关系，每个字符都有自己对应的一个数字
- 从字符到数字的过程，称之为编码
- 从数字到字符的过程，称之为解码
- 编码表，别称“字符集”，最原始的编码表，比较简单，只有英文和英文标点，叫做ASCII码表
- 每个国家都有自己的字符，中国的编码表GBK，GB2312，该编码表中前128个字符和ASCII码表都一致，表示一个英文占一个字节，表示一个中文占两个字节
- 统一的编码表：Unicode，表示所有的字符都是使用两个字节
- 万国码表：UTF-8，表示一个英文占一个字节，表示一个中文占三个字节
- 常见编码表的使用：
- Java中使用的是Unicode
- 在中国电脑上磁盘一般默认是GBK
- 网页上最多的是UTF-8
- Java中表示字符使用的是Unicode,表示一个字符的时候”\uXXXX”,表示任何字符，每一个X都代表一个十六进制的数字，\u代表的Unicode
代码
class Demo03 {
public static void main(String[] args) {
//字符 ------ 数字 编码
char c = '0'; //字符0对应的数字是48
System.out.println(c);
//数字 ------ 字符 解码
int i = 97;
char c2 = (char)i;
System.out.println(c2);
//a代表97
System.out.println('a' + 1);//a是字符类型 1是int类型 所以结果是int类型
//97是十进制 转为十六进制 97 / 16 = 6...1 对应十六进制就是61
//Unicode编码是使用四位十六进制数字表示任意字符 不够补0
// 0061
System.out.println('\u0061');
char c3 = '黄';
System.out.println((int)c3);//40644
//40644转为十六进制 9EC4
System.out.println("\u9EC4");
}
}
练习
使用Unicode编码，将自己的名字打印出来
class Demo04 {
public static void main(String[] args) {
char c = '田';
System.out.println((int)c);//30000 7530
char c2 = '恒';
System.out.println((int)c2);//24658 6052
System.out.println("\u7530\u6052");
}
}字符串
- 使用双引号引起来的字符序列，就是一个字符串类型的数据，字符串是一个引用数据类型，该字符串变量中存储的不是字符串本身，而是字符串在内存中的地址，所以被称为引用数据类型，对应的类型String
- 字符串可以和其他类型进行拼接，使用+
- +表示拼接，拼接之后，会把其他数据类型的数据，转为字符串类型，所有想要转为字符串的数据，都可以使用+和字符串进行拼接
代码
class Demo05 {
public static void main(String[] args) {
//name中存储的是，侯这个字符串常量在内存的地址
String name = "侯";
//根据name中存储的地址，找到田恒这个字符串取出
System.out.println(name);
int age = 80;
System.out.println(age);//age直接存储的是80这个值
//希望name和age拼接起来
//可以使用+
System.out.println("我的名字:" + name);
//age是int类型 前面是字符串类型
//正常的程序执行流程，是从左到右从上到下，依次运行
//当字符串和其他类型+运算的时候会把其他类型转为字符串类型
//然后进行拼接
System.out.println("我的年龄:" + age);
System.out.println("我的名字:" + name + "，我的年龄:" + age);
String str = "我的身高" + 159.9 + "mm";
System.out.println(str);
int a = 10;
int b = 20;
System.out.println("和为：" + a + b);
//当其他数据类型想要转为字符串的时候，但是又不想改变原有的内容
boolean boo = true;
String str2 = "" + boo;
System.out.println(str2);
}
}运算符
- 运算符：用来运算和操作数据的符号
- Java中的运算符分类：
- 算术运算符
- 逻辑运算符
- 比较运算符
- 三元运算符
- 赋值运算符
算术运算符
- +
- 字符串的拼接
- 求和
- 表示正数
- -
- 表示负数
- 求差
- *
- 求积
- /
- 求商
- %
- 求余数部分
代码
class Demo06 {
public static void main(String[] args) {
// +
int a = +20;//表示正数
int b = 30;
int sum = a + b;//表示求和
System.out.println("和为" + sum);//表示拼接
//-
int r = 100 - 50;//表示差
int c = -50;//表示负数
//*
r = 10 * 5;//求积
System.out.println(r);
// /
r = 10 / 5;
System.out.println(r);
//如果两边都是整数，结果一定是整数，小数部分不保留 不会四舍五入
r = 10 / 3;
System.out.println(r);
//如果两边有一边是小数，结果一定是小数
double r2 = 17 / 3.0;
System.out.println(r2);
// %
int m = 10 % 3;
System.out.println(m);
//10.3 / 2 = 5 还剩0.3不能被整除 这部分叫做余数
double d = 10.3 % 2;
System.out.println(d);
}
}赋值运算符
- 作用：把赋值运算符右边的数据，赋值给左边的变量
- 基本的赋值运算符： =
- +=
- -=
- *=
- /=
- %=
代码
class Demo07 {
public static void main(String[] args) {
//3是一个常量，等号的作用是将字面值常量3赋值给这个a这个变量存储
int a = 3;
int b = 5;
//想要计算 b + 2的值，计算完成之后b的值要是+2之后的结果
b = b + 2;//先算b + 2 b = 7
//简化该步骤
b += 2; //类似于 b = b + 2
System.out.println(b);
//-=
int c = 10;
//c = c - 5;
c -= 5;
//*=
int d = 3;
//d = d * 5;
d *= 5;
int e = 5;
e /= 2;//e = e / 2
double f = 10.3;
f %= 3;
System.out.println(f);
short s = 1;
//s = s + 1;
s += 1; //完整拆开 s = (short)(s + 1);
//默认隐含了一个强制转换
byte b2 = 127;
b2 += 1;
System.out.println(b2);
}
}自增自减运算符
- ++和--
- ++自增运算符 --自减运算符
- 作用：在某个变量的基础上再自增1或者自减1
- ++、--在单独作为一行使用的时候，++--在变量前变量后无任何区别
- ++在运算中，或者表达式中，++在变量前，先对变量+1，再取出变量的值进行运算，++在变量后，先取出变量的值进行运算，再进行+1
- --在运算中，或者表达式中，--在变量前，先对变量-1，再取出变量的值进行运算，--在变量后，先取出变量的值进行运算，再进行-1
代码
class Demo08 {
public static void main(String[] args) {
int a = 10;
//a++;
++a;//再单独作为一行使用的时候是没有任何区别的
System.out.println(a);
int b = 5;
//++在变量后，先取值，取值为5，将5给输出语句，再自增1
System.out.println(b++);//5
System.out.println(b);//6
//++在变量前，先自增1，值为7，再将7给输出语句 输出7
System.out.println(++b);//7
int m = 3;
// m 4 5 6
//sum 4 + 4 + 4 + 3 + 5
int sum = ++m + m + m++ + 3 + m++;
System.out.println(m);//6
System.out.println(sum);//20
int q = 5;
//q 4 3 2
//r 4 + 2 + 4 - 3 + 2
int r = --q + 2 + q-- -3 + --q;
System.out.println(q);//2
System.out.println(r);//9
}
}练习
- int a = 5763; 通过程序分别取出该数的个位、十位、百位、千位
- int m = 5; int n = m++ + --m + 3 - --m%2;
- int q = 4; int p = q++*2 + --q*3 + q--;
class Demo09 {
public static void main(String[] args) {
//1、int a = 5763; 通过程序分别取出该数的个位、
//十位、百位、千位
int a = 5763;
//个位 是属于不足十的部分，所以对十取余就可以了
int g = a % 10;
//十位 5763 让6变成个位 a / 10 % 10
int s = a / 10 % 10;
//百位 5763 让7变成个位 a / 100 % 10;
int b = a / 100 % 10;
//千位
int q = a / 1000;
System.out.println("个十百千" + g + s + b + q);
int m = 5;
//m 6 5 4
//n 5 + 5 + 3 - 4 % 2
int n = m++ + --m + 3 - --m%2;
System.out.println(m);//4
System.out.println(n);//13
int q = 4;
//q 5 4 3
//p 4 * 2 + 4*3 + 4
int p = q++*2 + --q*3 + q--;
System.out.println(q);//3
System.out.println(p);//24
}
}比较运算符
- 用于比较数据是否相等，或者大小关系的运算符，运算的结果boolean类型
- 分类
- 是否相等 == != 这两个符号可以比较任意数据类型
- 大小关系 > < >= <= 这四个只能比较数值类型(整数、小数、字符)
- 判断左边的值与右边的值是否满足某种关系
代码
class Demo09 {
public static void main(String[] args) {
//1、int a = 5763; 通过程序分别取出该数的个位、
//十位、百位、千位
int a = 5763;
//个位 是属于不足十的部分，所以对十取余就可以了
int g = a % 10;
//十位 5763 让6变成个位 a / 10 % 10
int s = a / 10 % 10;
//百位 5763 让7变成个位 a / 100 % 10;
int b = a / 100 % 10;
//千位
int q = a / 1000;
System.out.println("个十百千" + g + s + b + q);
int m = 5;
//m 6 5 4
//n 5 + 5 + 3 - 4 % 2
int n = m++ + --m + 3 - --m%2;
System.out.println(m);//4
System.out.println(n);//13
int q = 4;
//q 5 4 3
//p 4 * 2 + 4*3 + 4
int p = q++*2 + --q*3 + q--;
System.out.println(q);//3
System.out.println(p);//24
}
}逻辑运算符
- 用来处理逻辑运算的符号
- 逻辑值：就是boolean类型的数据，真真假假就是所说的逻辑
- & | !
- & 逻辑与：同真为真，否则为假
- true & true true
- true & false false
- false & true false
- false & false false
- | 逻辑或：同假为假，否则为真
- true | true true
- true | false true
- false | true true
- false | false false
- ! :遇真为假，遇假为真
- !false true
- !true false
代码
class Demo11 {
public static void main(String[] args) {
//逻辑与 同真为真否则为假
boolean b = false & true;
System.out.println(b);
//false代表了一个逻辑值，有些式子最终的结果也是逻辑值，也可以参与运算
int a = 10;
b = a > 5 & a < 20; // 5<a<20
System.out.println(b);
//逻辑或 | 同假为假 否则为真
b = false | true;
System.out.println(b);
// ! 遇真为假 遇假为真
b = !false;
System.out.println(b);
}
}三元(目)运算符
- 元：可以操作的数据的个数
- 三元运算符：可以操作三个数据的运算符
- 格式：
- 布尔表达式1 ? 表达式2 : 表达式3;
- 表达式：Java中由常量或者变量组成的具有值的式子就是表达式
- 布尔表达式1: 这个式子必须返回的结果为boolean类型，true或者false
- 表达式2和3:可以是任意数据类型，一般建议2和3的类型要一致
- 执行流程：
- 计算布尔表达式1的值,是true还是false
- 如果结果为true，此时选择表达式2的值，作为整个式子的结果
- 如果结果为false，此时选择表达式3的值，作为整个式子的结果
- 最终的结果：由表达式2和3中产生
代码
class Demo12 {
public static void main(String[] args) {
//布尔表达式1 ? 表达式2 : 表达式3;
/*
需求
int a = 5;
int b = 10;
通过三元运算符求出其中的最大值
比较a和b的大小关系
a > b 成立 结果a
a > b 不成立 结果b
布尔表达式1: a > b
表达式2: 如果计算结果为true，选择表达式2的值 a
表达式3: 如果计算结果为false，选择表达式3的值 b
*/
int a = 59;
int b = 10;
int max = a > b ? a : b;
System.out.println(max);
//三元运算符最终一定会由结果产出，产出的值一定是从表达式2和3中选择
//所以接收结果要考虑表达式2和3的类型
//完整格式：表达式2和3的数据类型 新变量名 = 布尔表达式1 ? 表达式2 : 表达式3;
//改变需求，想要最终输出 是前一个数字大，还是后一个数字大
String str = a > b ? "前一个数字大" : "后一个数字大";
System.out.println(str);
//System.out.println(a > b ? "前一个数字大" : 1);
}
}练习
- 通过三元运算符，判断一个数是奇数还是偶数
- 通过三元运算符，比较两个小数是否相等，结果要求返回 “相等” “不相等”
- 通过三元运算符，获取三个整数的最大值
代码
class Demo13 {
public static void main(String[] args) {
/*
1、通过三元运算符，判断一个数是奇数还是偶数
首先得有一个数
奇数偶数取决于是否能被2整除
a % 2 == 0 等于0表示是偶数 否则是奇数
int a = 5;
System.out.println(a % 2 == 0 ? "偶数": "奇数");
2、通过三元运算符，比较两个小数是否相等，结果要求返回 “相等” “不相等”
首先准备两个小数
double a = 3.33;
double b = 3.44;
String str = a == b ? "相等" : "不相等";
System.out.println(str);
*/
//3、通过三元运算符，获取三个整数的最大值
int a = 5;
int b = 10 ;
int c = 8;
//先求出两个整数的最大值
//int max = a > b ? a : b;
//拿着两个整数的最大值和第三个数比较
//max = max > c ? max : c;
int max = (a > b ? a : b) > c ? (a > b ? a : b) : c;
System.out.println("最大值" + max);
}
}进制
- 计数和进位的制度，几进制就是逢几进一
- 生活中最常见的就是十进制
- 七进制：星期 逢七进一
- 十二进制：月份 逢十二进一
- 计算机中常用的进制
- 进制名称 使用符号
- 二进制 0b
- 八进制 0
- 十进制 无符号
- 十六进制 0x
- 注意:
- 除了十进制以外其他的进制数据都需要指明采用的进制数，需要在数值前面加上对应的符号
- 十六进制，从10开始使用字母表示
- a 10
- b 11
- c 12
- d 13
- e 14
- f 15
代码
class Demo14 {
public static void main(String[] args) {
//二进制
System.out.println(0b111);
int i = 0b111;
System.out.println(i);
//八进制
System.out.println(0101);
//十六进制
System.out.println(0x101);
}
}进制转换
其他进制转十进制
- 转换的原因：生活中和实际项目开发中，常用的是十进制
- 转换的方式：基数乘以系数的权次幂 求和
- 基数: 指定进制的每一位数
- 系数：进制数
- 权次幂:基数的数据位数 从右往左第一位是0，第二位是1....
代码
class Demo15 {
public static void main(String[] args) {
/*
二进制转十进制
0b1101
基数 1 1 0 1 基数要和每一个系数的权次幂相乘，再求和
系数 二进制 系数就是2
权次幂 3 2 1 0
1 * 2^3 + 1*2^2 + 0*2^1 + 1*2^0 = 8 + 4 + 0 + 1 = 13
八进制转十进制
0703
基数 7 0 3
系数 八进制 系数就是8
权次幂 2 1 0
7*8^2 + 0*8^1 + 3*8^0 = 7 * 64 + 0 + 3 = 448 + 3 = 451
十六进制转十进制
0x3ac
基数 3 a c
系数 十六进制 系数就是16
权次幂 2 1 0
3*16^2 + a * 16^1 +c*16^0 = 768 + 160 + 12 = 940
*/
}
}练习
1、0xaa 0x10c 0x301
2、077 0170 0345
3、0b101101 0b111011 0b1010110
代码
class Demo16 {
public static void main(String[] args) {
/*
1、
0xaa
a a
16
1 0
10 * 16 + 10 = 170
0x10c
1 0 c
16
2 1 0
1*256 + 0 + 12 = 268
0x301
3 0 1
3*256 + 0 + 1 = 769
2、077
7 7
7*8 + 7 = 63
0170
1 7 0
64 + 7*8 + 0 = 120
0345
3 4 5
3*64 + 4*8 + 5 = 192 + 32 + 5 = 229
3、
0b101101
32 + 0 + 8 + 4 + 0 + 1 = 45
0b111011
32 + 16 + 8 + 0 + 2 + 1 = 59
0b1010110
64 + 0 + 16 + 0 + 4 + 2 = 86
*/
}
}
2093
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
