本帖最后由 xiekai_sjz 于 2018-9-7 14:36 编辑
day02 数据类型转换, 运算符, 方法入门
昨天我们学习了java的数据类型。java中分为基本数据类型和引用数据类型。昨天我们主要学习了基本数据类型，总共有byte, short, int , long, float, double, char, boolean这八种。我们今天来学习数据类型的转换和运算符，以及方法入门。
以下是今天的学习目标：
- 理解数据类型的强制转换
- 理解数据类型的自动转换
- 了解ASCII编码表
- 理解int类型和char类型的运算原理
- 理解运算符++ --的运算方式
- 理解+符号在字符串中的作用
- 理解比较运算符
- 理解逻辑运算符
- 掌握三元运算符的格式和计算结果
- 了解方法的概念
- 掌握无返回值无参数方法的定义格式
- 了解方法定义的注意事项
以下是今天的详细笔记：
数据类型转换自动类型转换
类型转换: 从一种数据类型转换为另一种数据类型
类型转换分为2种:
1. 自动类型转换(隐式): 数据范围从小到大进行转换, 自动完成
2. 强制类型转换(显式): 数据范围从大到小, 手动编写代码完成
[Java] 纯文本查看 复制代码 // 自动类型转换: 左边long = 右边int, 右边int自动提升为long类型然后赋值给左边
long num1 = 100;
double d = 100;
System.out.println(d); // 100.0
强制类型转换
// 格式
范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
// 示例
int num = (int) 10000L;
类型转换的注意事项
1. 强制类型转换一般不推荐使用，因为有可能发生精度损失, 或数据溢出。
2. byte/short/char 这三种类型都可以发生数学运算，例如加法"+".
3. byte/short/char 这三种类型在运算的时候，都会被首先提升成为 int 类型，然后再计算。
4. boolean 类型不能发生数据类型转换
[Java] 纯文本查看 复制代码 // 精度损失示例
int a = (int)3.14;
System.out.println(a); // 3
// 数据溢出示例
byte b = 127;
b = (byte)(b + 1);
System.out.println(b); // -128
byte b2 = -128;
b2 = (byte)(b2 - 1);
System.out.println(b2); // 127
在进行数学运算时, 自动类型转换的规则:
byte, short, char -> int -> long -> float -> double
[Java] 纯文本查看 复制代码 // 查看以下代码的问题
public class Demo {
public static void main(String[] args) {
byte b1 = 10;
byte b2 = 20;
byte sum1 =（byte）( b1 + b2); // byte + byte -> int + int = int
byte b3 = 10;
short s1 = 20;
byte sum2 = b3 + s1; // byte + short -> int + int = int
byte b4 = 10;
int i1 = 20;
byte sum3 = b4 + i1; // byte + int -> int + int = int
int i2 = 10;
long l1 = 20L;
long sum4 = i2 + l1; // int + long -> long + long = long
long l2 = 10L;
float f1 = 20F;
float sum5 = l2 + f1; // long + float -> float + float = float
int i3 = 10;
double d1 = 20.0;
double sum6 = i3 + d1; // int + double -> double + double = double
}
}
ASCII编码表
编码表: 数值和字符的对应关系表
ASCII : American Standard Code for Information Interchange，美国信息交换标准代码
ASCII编码表: 定义了一些控制字符, 大小写英文, 数字, 标点符号
常见字符对应数值:
'0' 48
'A' 65
'a' 97
运算符
算术运算符-四则运算和取余
算术运算符:
+: 加法
-: 减法
*: 乘法
/: 除法, 得到商
%: 取模, 得到余数
注意:
整数相除只能得到整数
要想得到小数, 需要有小数参与运算(利用自动类型转换)。例如
[Java] 纯文本查看 复制代码 int a = 10 / 3;
System.out.println(a); // 3
double d = 1.0 * 10 / 3;
System.out.println(d); // 3.3333333333335
算术运算符: 加号的多种用法
+的3种用途:
1. 对于数值是加法
2. 对于 char 类型，在计算之前， char 会被提升成为 int ，然后再按数值计算
3. 对于字符串 String ，加号代表字符串连接
[Java] 纯文本查看 复制代码 System.out.println("World" + "Hello"); // WorldHello
String str = "Java";
System.out.println(str + 20); // Java20
System.out.println(20 + str); // 20Java
System.out.println(str + 20 + 30); // Java2030
System.out.println(str + (20 + 30)); // Java50
System.out.println(20 + 30 + str); // 50Java
System.out.println("str=" + str); // str=Java
算术运算符-自增自减
++: 自增. 让变量值增加1
--: 自减. 让变量值减少1
自增自减放前放后的区别:
单独使用: 没有区别 i++;
混合使用:
++i: 先加后用
先将变量i值增加1, 然后使用增加后的变量值, 作为++i表达式的值
i++: 先用后加
先使用变量i本身的值作为i++表达式的值, 然后变量i再增加1
[Java] 纯文本查看 复制代码 // 前++和后++的执行流程
/*
混合使用:
++i: 先加后用
先将变量i值增加1, 然后使用增加后的变量值, 作为++i表达式的值
i++: 先用后加
先使用变量i本身的值作为i++表达式的值, 然后变量i再增加1
*/
public class Test {
public static void main(String[] args) {
// 第一个
int a = 0;
a = a++; // 后++: 先用后加
// 1. 先用a变量本身的值0作为a++表达式的值: a = 0;
// 2. 然后变量a再自增1, a++=1, 只是变量a自定, 和表达式无关 a=0; 此时a为1
// 3. a = 0; 赋值, a为0
System.out.println(a); // 0
// 第二个
int b = 0;
b = ++b; // 前++: 先加后用.
// 1. 先将变量b自增1为1
// 2. 然后用自定后的值, 作为++b表达式的值, b = 1;
// 3. 赋值, b就为1
System.out.println(b); // 1
// 第三个
int c = 10;
int result1 = ++c + c++;
// c 11 12
// 参加运算 11 11
/*
++c + c++
1. ++c: 前++. 先将变量c的值自增1为11, 然后再用自增后的值作为++c表达式的值 11 + c++
2. c++: 后++. 先用变量c本身的值作为c++表达式的值 11 + 11, 然后变量c再自增1为12
3. int result1 = 11 + 11; 赋值 reuslt1 = 22
*/
System.out.println(result1); // 22
System.out.println(c); // 12
// 第四个
int d = 10;
int result2 = d++ + ++d;
//d 11 12
//参加运算 10 12
/*
d++ + ++d:
1. d++: 后++. 先用变量d本身的值作为d++表达式的值 10 + ++d, 然后变量d再自增1为11
2. ++d: 前++. 先将变量d的值自增1为12, 然后再用自增后的值作为++d表达式的值: 10 + 12
3. int result2 = 10 + 12; 赋值 reusult2
*/
System.out.println(result2); // 22
System.out.println(d); // 12
}
}
赋值运算符
基本赋值运算符：
=: 将右侧的数据交给左侧的变量. int a = 30;
复合赋值运算符：
+=: 左边与右边相加, 将结果赋值给左边. a += 3; 相当于 a = (a的类型)(a + 3);
-=: 左边与右边相减, 将结果赋值给左边. b -= 4; 相当于 b = (b的类型)(b - 4);
*=: 左边与右边相乘, 将结果赋值给左边. c *= 5; 相当于 c = (c的类型)(c * 5);
/=: 左边与右边相除, 将结果赋值给左边. d /= 6; 相当于 d = (d的类型)(d / 6);
%=: 左边与右边取模, 将结果赋值给左边. e %= 7; 相当于 e = (e的类型)(e % 7);
注意事项：
1. 只有变量才能使用赋值运算符，常量不能进行赋值。10=30;
2. 复合赋值运算符其中隐含了一个强制类型转换。[Java] 纯文本查看 复制代码 // 以下代码是否正确?
byte b = 1;
b = b + 1; // 编译报错 byte + int -> int + int = int
byte bb = 1;
bb += 1; // bb = (byte)(bb + 1); byte + int -> int + int = int
比较运算符
比较运算符：也叫做关系运算符
>: 大于
<: 小于
>=: 大于等于
<=: 小于等于
==: 相等
!=: 不相等
注意事项：
1. 比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
2. 如果进行多次判断，不能连着写。
数学当中的写法，例如：1 < x < 3, 程序当中不允许这种写法。
1 < x 并且 x < 3
逻辑运算符
逻辑运算符:
&&: 与. 并且. 两边都为true才是true, 只要有一个false则为false
短路与. 如果左边能提前得出结果, 则不会执行右边的判断
||: 或. 或者. 两边只要有一个true则为true, 两边都为false则为false
短路或. 如果左边能提前得出结果, 则不会执行右边的判断
!: 非(取反).
注意事项：
1. 逻辑运算符只能用于boolean值。
2. 与、或需要左右各自有一个boolean值，但是取反只要有唯一的一个boolean值即可。
3. 与、或两种运算符，如果有多个条件，可以连续写。
两个条件：条件A && 条件B
多个条件：条件A && 条件B && 条件C
[Java] 纯文本查看 复制代码 /*
&&, || 短路效果: 如果左边能提前确定结果, 则右边不用执行
短路的区别:
&, &&: 结果一样, 只是&&具有短路效果, &没有
|, ||: 结果一样, 只是||具有短路效果, |没有
*/
public class Test {
public static void main(String[] args) {
// 双与 && 具有短路效果
int a = 10;
System.out.println(false && ++a < 100); // false && ... = false
System.out.println(a); // 10
// 单与 & 没有短路效果
int b = 10;
System.out.println(false & ++b < 100); // false & true = false
System.out.println(b); // 11
// 双或 || 具有短路效果 true || ...
int c = 10;
System.out.println(true || ++c < 100); // true || ... true
System.out.println(c); // 10
// 单或 | 没有短路效果
int d = 10;
System.out.println(true | ++d < 100); // true | true = true
System.out.println(d); // 11
}
}
数学公式的写法:
// 对于1 < x < 3的情况，应该拆成两个部分，然后使用与运算符连接起来
boolean b = 1 < x && x < 3;
字符范围的判断:
[Java] 纯文本查看 复制代码 // 由于char也可以用数值表示, 所以我们可以利用这一特点对某个字符是否属于小写英文, 大写英文, 数字来进行判断
// 判断符合小写英文字母
char ch = 'A';
boolean isLowerLetter = ch >= 'a' && ch <= 'z';
// 判断符合大写英文字母?
char ch = 'A';
boolean isLowerLetter = ch >= 'A' && ch <= 'Z';
// 判断符合数字?
char ch = '4';
boolean isLowerLetter = ch >= '0' && ch <= '9';
三元运算符
一元运算符：只需要一个数据就可以进行操作的运算符。例如：取反!、自增++、自减--
二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、赋值=
三元运算符：需要三个数据才可以进行操作的运算符。
三元运算符格式：
数据类型 变量名称 = 条件判断? 表达式A : 表达式B;
流程：
首先判断条件是否成立：
如果成立为true，那么执行表达式A, 并将表达式A的结果赋值给左侧的变量；
如果不成立为false，那么执行表达式B, 并将表达式B的结果赋值给左侧的变量；
注意事项：
1. 必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
2. 三元运算符的结果必须被使用。
[Java] 纯文本查看 复制代码 int a = 10;
int b = 20;
int max = a > b ? a : b;
System.out.println(max); // 20
String result = a == b? "相等" : "不相等";
System.out.println(result); // 不相等
方法入门
方法概念
方法: 实现某种功能的代码块
方法的作用:
将实现某种功能的代码聚合到一起, 便于重复使用, 提高代码的复用性, 提高可维护性
方法的定义
定义方法的格式：(格式可以参考main()方法)
[Java] 纯文本查看 复制代码 public static void 方法名称() {
方法体 // 也就是大括号当中可以包含任意条语句
}
public class Test {
public static void main(String[] args) {
eat();
}
public static void eat() {
// ...
}
}
注意事项：
1. 方法定义的先后顺序无所谓
2. 方法的定义不能产生嵌套包含关系
3. 方法定义好了之后，不会执行的。如果要想执行，一定要调用方法
方法的调用
调用方法格式：
方法名();
// 示例
public static void main(String[] args) {
// 在main方法中调用其他方法
方法名称();
}
[Java] 纯文本查看 复制代码 /*
需求:
定义4个方法: 农民farmer(), 商贩seller(), 厨师cook(), 我me().
方法内分别实现各自功能.
在main()方法中调用以上方法
*/
public class Test {
public static void main(String[] args) {
// 调用方法
farmer();
seller();
cook();
me();
}
// 农民
public static void farmer() {
System.out.println("种地");
System.out.println("除草");
System.out.println("收割");
}
// 商贩
public static void seller() {
System.out.println("低买");
System.out.println("高卖");
}
// 厨师
public static void cook() {
System.out.println("切菜");
System.out.println("上桌");
}
// 我
public static void me() {
System.out.println("吃");
System.out.println("付钱");
}
}
JDK9的JShell使用
JShell的使用:
进入: cmd窗口内输入jshell
退出: jshell中输入/exit
JShell适用于测试一些简单的代码片段
编译器的两点优化
1. byte/short/char
如果没有超过左侧的范围，编译器补上强转。byte b = 10;
如果右侧超过了左侧范围，那么直接编译器报错。
2. 编译器的常量优化
在给变量进行赋值时
如果右侧的表达式当中全都是常量，那么编译器javac将会直接将若干个常量表达式计算得到结果
如果表达式当中有变量参与，那么就不能进行这种优化了。
// 等号右边全都是常量，没有任何变量参与运算
short result = 5 + 8;
// 编译之后，得到的.class字节码文件当中相当于【直接就是】：
byte result = 12; // 右侧的常量结果数值，没有超过左侧范围，所以正确。
扩展
取模%操作的用途判断是否是奇数偶数 判断是否能被某个数整除 获取一个数的个位, 十位, 百位... 产生轮流的数值
[Java] 纯文本查看 复制代码 //判断是否是奇数偶数
x % 2 == 0 true是偶数, false是奇数
x % 2 == 1 true是奇数, false是偶数
4 % 2 = 0
3 % 2 = 1
2 % 2 = 0
1 % 2 = 1
0 % 2 = 0
// 判断是否能被某个数整除
x % 这个数 == 0 true则能被这个数整除
10 % 5 = 0
11 % 5 = 1
// 获取一个数的个位, 十位, 百位...
int i = 12345;
int ge = i % 10; // 12345% 10 = 5
int shi = i / 10 % 10; // 1234 % 10 = 4
int bai = i / 100 % 10; // 123 % 10 = 3
int qian = i / 1000 % 10; // 12 % 10 = 2
int wan = i / 10000 % 10; // 1 % 10 = 1
// 产生轮流的数值, 如产生3个不同的值轮流, 就用连续的数字%3
0 % 3 = 0;
1 % 3 = 1;
2 % 3 = 2;
3 % 3 = 0;
4 % 3 = 1;
5 % 3 = 2;
6 % 3 = 0;
|
|
收藏
淘帖
踩
