# 【变量、类型转换、运算符】
##### 今日复习指南
~~~
1.变量【重点: 用30分钟】
Demo01BianLiang.java
Demo02BianLiang.java
2.运算符【重点: 用1个小时】
Demo11Operator.java
Demo12Operator.java
Demo13Operator.java
Demo14Operator.java
Demo15Operator.java
Demo16Operator.java
Demo17Operator.java
练习写代码时,必要的注释是需要的,但是千万不要像响哥一样写的这么详细,只要自己理解就ok了
3.数据类型转换【难点非重点: 理解,用30分钟】 大体看看
~~~
##### 今日内容介绍
~~~
变量【重点】
数据类型转换【难点非重点: 理解】
运算符【重点】
~~~
### 第一章 变量和数据类型【重要】
##### 2.1 变量概念及分类
~~~
数学中有个常数的概念:
y = x + 10; //整数数字10是不可以发生变化的
b = a + 6.6; //小数数字6.6是不可以发生变化的
数学中的数字(常数)是有分类的,对应java中的常量也是有分类的
x,y是可以发生变化的
x: 2 y: 12
x: 6 y: 16
...
x,y中的数据是可以发生变化的,而且x,y内部的数据也是有类型(整数)
a,b是可以发生变化的
a: 2.2 b: 8.8
a: 3.3 b: 9.9
...
a,b中的数据是可以发生变化的,而且a,b内部的数据也是有类型(小数)
像x,y,a,b这样的东西,里面是可以存储数据的,而且内部的数据是有具体的类型的,把这样的东西叫做变量(理解为小的容器,只能存储一个数据)
为什么变量会有很多分类?
不同类型的变量,占用的字节数(空间)不同,导致取值范围不同,使用场景不一样
1.变量概念: 在程序的执行过程中,其值可以在一定范围内发生改变的量
2.分类(四类八种):
(1)整数
byte 占1个字节 取值范围 -128到127
short 占2个字节 取值范围 正负3万多
int 占4个字节 取值范围 正负21亿 整数常量默认是int类型
long 占8个字节 取值范围 大概19位数字 表示long类型的数据时,建议右键添加字母L/l
(2)小数
float 占4个字节 表示float类型的数据时,建议右键添加字母F/f
虽然float占4个字节,但是由于内部采用科学计数法,取值范围远远大于占用8个字节的long类型
double 占8个字节 小数常量默认是double类型
(3)字符:
char 占2个字节 取值范围0到65535
(4)布尔:
boolean 占1个字节 取值只有true,false
~~~
##### 2.2 变量定义格式图解分析
~~~
变量的理解
1.变量的本质就是内存中的一块空间,空间的大小由数据类型决定
2.要想找到变量的内存空间,必须给这块空间起个名字,叫做变量名称
3.变量对应的内存空间中必须有数据才可以使用,向变量内存空间中,存储数据的过程叫做初始化/赋值
变量定义格式一(挖一个坑,同时种一个萝卜):
数据类型 变量名称 = 数据值;//挖一个坑,同时种一个萝卜
变量定义格式二(先挖一个坑,然后种一个萝卜):
数据类型 变量名称;//先挖一个坑
变量名称 = 数据值;//然后种一个萝卜
变量定义格式三(挖多个坑,同时向每个坑中种一个萝卜):
数据类型 变量名称1 = 数据值1,变量名称2 = 数据值2 ... ;
变量定义格式四(先挖多个坑,然后向每个坑中种一个萝卜):
数据类型 变量名称1 ,变量名称2 ... ;//先挖多个坑
变量名称1 = 数据值1;//然后向每个坑中种一个萝卜
变量名称2 = 数据值2;
//....
~~~
##### 图解:
##### 2.3 定义8种变量
~~~
/*
变量定义的四种格式
*/
public class Demo01BianLiang {
public static void main(String[] args){
/*
变量定义格式一(挖一个坑,同时种一个萝卜):
数据类型 变量名称 = 数据值;//挖一个坑,同时种一个萝卜
*/
//挖一个byte类型(占1个字节)的坑,给这个坑起个名字叫a,同时把数字10放入这个坑中
byte a = 10;
System.out.println(a);//打印名称为a的坑中的内容
a = 20;//把数字20放入名称为a的坑中,原来的数据被替换调用
System.out.println(a);//打印名称为a的坑中的内容
System.out.println("--------------------------------");
/*
变量定义格式二(先挖一个坑,然后种一个萝卜):
数据类型 变量名称;//先挖一个坑
变量名称 = 数据值;//然后种一个萝卜
*/
short b;//挖一个short类型(占2个字节)的坑,给这个坑起个名字叫b
b = 30;//把数字30放入名称为b的坑中
System.out.println(b);//打印名称为b的坑中的内容
System.out.println("--------------------------------");
/*
变量定义格式三(挖多个坑,同时向每个坑中种一个萝卜):
数据类型 变量名称1 = 数据值1,变量名称2 = 数据值2 ... ;
*/
//挖两个个int类型(占4个字节)的坑,一个坑起个名字叫c,一个坑起个名字叫d,分别向每个坑中放入数据
int c = 40, d = 50;
System.out.println(c);//打印名称为c的坑中的内容
System.out.println(d);//打印名称为d的坑中的内容
System.out.println("--------------------------------");
/*
变量定义格式四(先挖多个坑,然后向每个坑中种一个萝卜):
数据类型 变量名称1 ,变量名称2 ... ;//先挖多个坑
变量名称1 = 数据值1;//然后向每个坑中种一个萝卜
变量名称2 = 数据值2;
//....
*/
//挖两个long类型(占8个字节)的坑,一个坑起个名字叫e,一个坑起个名字叫f
long e,f;
e = 60L;//把数字60放入名称为e的坑中
f = 70L;//把数字70放入名称为f的坑中
System.out.println(e);//打印名称为e的坑中的内容
System.out.println(f);//打印名称为f的坑中的内容
System.out.println("HelloWorld");
}
}
~~~
~~~
/*
其它类型变量的定义
*/
public class Demo02BianLiang {
public static void main(String[] args){
//定义float类型的变量a,初始化值6.6F
float a = 6.6F;
System.out.println(a);//打印变量a中的内容
//定义double类型的变量b,初始化值8.8
double b = 8.8;
System.out.println(b);//打印变量b中的内容
//定义char类型的变量ch,初始化值'a'
char ch = 'a';
//char ch = 'ab';//错误: ''中不能写两个及以上的字符
//char ch = '';//错误: ''中不能没有字符
System.out.println(ch);//打印变量ch中的内容
//定义boolean类型的变量c,初始化值true
boolean c = true;
c = false;//把false赋值给变量c,原来的值将被覆盖
System.out.println(c);//打印变量c中的内容
}
}
~~~
##### 2.4 变量的注意事项
变量定义的注意事项: 1.定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。 因为整数默认是int类型，整数太大可能超出int范围。 2.定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。 因为浮点数的默认类型是double， double的取值范围是大于float的，类型不兼容。
3.变量名称：在同一个大括号范围内，变量的名字不可以相同。 4.变量赋值：定义的变量，不赋值不能使用。
~~~
/*
变量定义的注意事项:
1.变量名称：在同一个大括号范围内，变量的名字不可以相同。
2.变量赋值：定义的变量，不赋值不能使用。
*/
public class Demo03Notice {
public static void main(String[] args){
//定义int变量a,初始值10
int a = 10;
System.out.println(a);//打印变量a中的内容
//错误: 不能在同一个{}中定义同名的变量
//int a = 20;
//System.out.println(a);//打印变量a中的内容
//定义int变量b,未赋值
int b;
//错误: b中没有内容,不能使用
//System.out.println(b);//打印变量b中的内容
b = 30;//把数字30存入变量b中
System.out.println(b);//打印变量b中的内容
}
}
~~~
~~~
/*
变量定义的注意事项:
1.定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。
因为整数默认是int类型，整数太大可能超出int范围。
2.定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。
因为浮点数的默认类型是double， double的取值范围是大于float的，类型不兼容。
*/
public class Demo04Notice {
public static void main(String[] args){
//定义long变量a,初始值6000000000: 60亿
//long a = 6000000000;//错误: 整数6000000000默认是int类型,但是已经远远的超出了int的取值范围21亿
//System.out.println(a);//打印变量a中的内容
long b = 6000000000L;//正确: 整数常量后面+L,类型就是long类型
System.out.println(b);//打印变量b中的内容
System.out.println("-------------------");
//定义float变量f,初始值8.8
//错误: 大萝卜不能直接放入小坑中
//float f = 8.8;//错误: 小数常量8.8,默认是double类型,占8个字节,不能放入占4个字节的坑中
//System.out.println(f);//打印变量f中的内容
float g = 8.8F;//正确: 小数常量后面+F,类型就是float类型
System.out.println(g);//打印变量g中的内容
}
}
~~~
##### 2.5 标识符的含义及注意事项
~~~
标识符:
1.概念: 程序中起名字的地方(类名,方法名称,变量名)
2.命名规则： 硬 性 要 求
标识符可以包含 英文字母26个(区分大小写) 、 0-9数字 、 $（美元符号） 和 _（下划线） 。
标识符不能以数字开头。
标识符不能是关键字。
3.命名规范： 软 性 建 议
类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）。
Demo01BianLiang
Demo02BianLiang
Demo03BianLiangNotice
Demo04BiaoShiFu
方法名规范： 首字母小写，后面每个单词首字母大写（小驼峰式）。
getMin(...){...}
getMax(...){...}
变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）。
num
value
maxValue
~~~
~~~
public class Demo05BiaoShiFu {
public static void main(String[] args){
int b2$_a;//正确的
//int b2$_%a;//错误的,不能包含%
//int 2b;//错误:不能以数字开头
//int public;//错误:不能是关键字
int ageOfMyGirlFriend = 18;
System.out.println(ageOfMyGirlFriend);
//不建议
int ageofmygirlfriend = 28;
System.out.println(ageofmygirlfriend);
}
}
~~~
### 第二章 数据类型转换【理解】
##### 3.1 自动类型转换【从小到大自动】
~~~
Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。
举例:
int + int 两个都是int,类型一直,可以直接计算,结果是int
int + long 类型不一致,可以把int转换成long(从小到大,自动完成,不需要代码特殊处理: 自动类型转换)
int + long 类型不一致,可以把long转换成int(从大到小,不会自动完成,需要代码特殊处理: 强制类型转换)
1.自动类型转换概念:
取值范围小的数据或者变量,可以直接赋值给取值范围大的变量(小萝卜可以直接放入大坑中)
2.特点:
(1)自动完成的,不需要代码的特殊处理
(2)byte/short/char类型数据,只要参加运算会自动转换为int类型
(3)byte、short、char-->int-->long-->float-->double
举例:
有一个byte类型(1个字节)的数字5: 00000101
byte类型自动类型转换成short类型(2个字节):
在数字的左侧补充1个字节的0,由于补充的都是0,所以数字的大小不变,还是5
00000000 00000101
byte类型自动类型转换成int类型(4个字节):
在数字的左侧补充3个字节的0,由于补充的都是0,所以数字的大小不变,还是5
00000000 00000000 00000000 00000101
byte类型自动类型转换成long类型(8个字节):
在数字的左侧补充7个字节的0,由于补充的都是0,所以数字的大小不变,还是5
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101
总结(打肿脸充胖子):
根据需求在数字的左侧补充若干字节的0,由于补充的都是0,所以数字的大小不变,但是占用的空间发生了变化
~~~
~~~
/*
自动类型转换
1.自动类型转换概念:
取值范围小的数据或者变量,可以直接赋值给取值范围大的变量(小萝卜可以直接放入大坑中)
2.特点:
(1)自动完成的,不需要代码的特殊处理
(2)byte/short/char类型数据,只要参加运算会自动转换为int类型
(3)byte、short、char-->int-->long-->float-->double
*/
public class Demo06Convert {
public static void main(String[] args){
int i = 1;
byte b = 2;
/*
b是byte类型,i是int类型,不一致
byte类型只要参加运算,会自动转换为int类型
byte类型(占1个字节)的b,自动转换为int类型(占4个字节:左侧补充3个字节的0,大小仍然是2)
byte + int ==> int + int ==> 两个int相加,结果是int类型(4个字节),
但是左侧变量x是byte类型(1个字节)
错误: 右侧是int类型,左侧变量是byte类型,无法赋值(大萝卜,不能直接放入小坑当中)
目前解决方案: 把左侧的坑变大 把左侧的byte类型的变量,改成int类型变量
*/
//byte x = b + i;
/*
b是byte类型,i是int类型,不一致
byte类型只要参加运算,会自动转换为int类型
byte类型(占1个字节)的b,自动转换为int类型(占4个字节:左侧补充3个字节的0,大小仍然是2)
byte + int ==> int + int ==> 两个int相加,结果是int类型(4个字节),
正好左侧变量y是int类型(4个字节),可以完成赋值
*/
int y = b + i;
System.out.println(y);
}
}
~~~
~~~
/*
自动类型转换
*/
public class Demo07Convert {
public static void main(String[] args){
int i = 1;
double d = 2.5;
/*
d是double类型,i是int类型,不一致
int类型会自动转换为double类型,在数字后面加上.0 1==>1.0
int + double ==> double + double ==> 两个double相加,结果是double类型(8个字节),
但是左侧变量x是int类型(4个字节)
错误: 右侧是double类型,左侧变量是int类型,无法赋值(大萝卜,不能直接放入小坑当中)
目前解决方案: 把左侧的坑变大 把左侧的int类型的变量,改成double类型变量
*/
//int x = i + d;
/*
d是double类型,i是int类型,不一致
int类型会自动转换为double类型,在数字后面加上.0 1==>1.0
int + double ==> double + double ==> 两个double相加,结果是double类型(8个字节),
正好左侧变量x是double类型(8个字节),可以完成赋值
*/
double x = i + d;
System.out.println(x);
}
}
~~~
##### 3.2 强制类型转换【从大到小强制】
~~~
1.强制类型转换概念:
取值范围大的数据或者变量,不能够直接赋值给取值范围小的变量,
要想赋值,必须进行强制类型转换(大萝卜不能直接放入小坑中)
2.格式:
转后类型 变量名称 = (转后类型)转前数据/转前变量;
举例:
有一个long类型(8个字节)的数字5:
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101
long类型强制类型转换成int类型(4个字节):
砍掉左侧的四个字节内容,由于砍掉的内容都是0,不会影响原有数据的大小
00000000 00000000 00000000 00000101
long类型强制类型转换成short类型(2个字节):
砍掉左侧的六个字节内容,由于砍掉的内容都是0,不会影响原有数据的大小
00000000 00000101
long类型强制类型转换成byte类型(1个字节):
砍掉左侧的七个字节内容,由于砍掉的内容都是0,不会影响原有数据的大小
00000101
总结:
根据需求,砍掉左侧若干字节的内容,如果砍掉的都是0,对原数据没有任何影响,只要砍掉的内容中包含1,就会影响原有数据的大小
~~~
~~~
/*
1.强制类型转换概念:
取值范围大的数据或者变量,不能够直接赋值给取值范围小的变量,
要想赋值,必须进行强制类型转换(大萝卜不能直接放入小坑中)
2.格式:
转后类型 变量名称 = (转后类型)转前数据/转前变量;
*/
public class Demo08Convert {
public static void main(String[] args){
short s = 1;
/*
s是short类型,1是int类型,不一致
short类型只要参加运算,会自动转换为int类型
short类型(占2个字节)的s,自动转换为int类型(占4个字节:左侧补充2个字节的0,大小仍然是1)
short + int ==> int + int ==> 两个int相加,结果是int类型(4个字节),
但是左侧变量s是short类型(2个字节)
错误: 右侧是int类型,左侧变量是short类型,无法赋值(大萝卜,不能直接放入小坑当中)
目前解决方案: 强制类型转换,把右侧的int类型结果强制转换成short类型
*/
//s = s + 1;
/*
把s+1的最终的int类型的结果数据,强制转换成short类型(砍掉左侧的两个字节的0)
int类型结果: 00000000 00000000 00000000 00000010
强制转换后的short类型结果: 00000000 00000010
*/
s = (short)(s + 1);
System.out.println(s);
}
}
~~~
~~~
/*
强制类型转换
问题: 可能会损失精度
*/
public class Demo09Convert {
public static void main(String[] args){
/*
右侧1.5是double类型占8个字节(大萝卜),
左侧的变量int类型占4个字节(小坑)
问题:
大萝卜不能直接放入小坑中
解决方案: 强制类型转换
*/
//int i = 1.5;
//小数强制类型转换成整数: 直接砍掉小数部分,所以会损失精度
int j = (int)1.5;
System.out.println(j);//
}
}
~~~
##### 图解(其它案例):
##### 3.3 ASCII码表
~~~
计算机是一个二货,只能存储0和1,所以存储到计算机中的所有内容都会转换成0和1进行存储
所以我们在计算机中存储的字符也不例外,也需要把字符转换成0和1进行存储
问题: 如何把字符转换成0和1呢?
解决方案:
使用ASCII编码表: 存储字符和数字对应关系的一张表格
存储字符时：需要查找ASC码表,找到字符对应的数字,将数字转换为二进制数存放到计算机中
'a' ---> 97 ---> 1100001 小写字母对应的int数字是连续的
'A' ---> 65 ---> 1000001 大写字母对应的int数字是连续的
'0' ---> 48 ---> 110000 数字字符对应的int数字是连续的
使用字符时：将对应的二进制数转换为十进制 找到ASC表中对应的字符 显示出来
1100001 ---> 97 ---> 'a'
1000001 ---> 65 ---> 'A'
110000 ---> 48 ---> '0'
~~~
##### 3.4 int类型和char类型的运算原理
~~~
public class Demo10Char {
public static void main(String[] args){
//定义char类型的变量ch,初始值'A'
char ch = 'A';
System.out.println(ch);//'A'
/*
byte/short/char类型数据,只要参加运算会自动转换为int类型
char类型数据和int类型数据一起运算
会把char类型的数据自动类型转换为int类型
问题:
如何把char类型的'A'转换成int类型呢?
答案:
查看ASCII码表: 'A' --> 65
char + int ==> int + int ==> 65 + 1 ==>66
*/
System.out.println(ch+1);//66
/*
byte/short/char类型数据,只要参加运算会自动转换为int类型
把ch+1的结果数据66强制类型转换成char类型
问题:
如何把int转换为对应的char类型呢?
答案:
查看ASCII码表: 66 --> 'B'
*/
System.out.println((char)(ch+1));//'B'
}
}
~~~
### 第三章 运算符
##### 4.1 算术运算符加减乘除
~~~
1.运算符：对常量或者变量进行操作/运算的符号
2.表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。
3.数学运算符:
(1)+: 加法运算
(2)-: 减法运算
(3)*: 乘法运算
(4)/: 除法运算
/*
算数运算符
1.运算符：对常量或者变量进行操作/运算的符号
2.表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。
3.数学运算符:
(1)+: 加法运算
(2)-: 减法运算
(3)*: 乘法运算
(4)/: 除法运算
数学中的除法运算: 被除数 ÷ 除数 = 商(/: 取的是商) .... 余数
*/
public class Demo11Operator {
public static void main(String[] args){
int a = 10,b = 20;
System.out.println(a + b);//打印变量a和b中数据的和: 10 + 20 结果: 30
System.out.println(a - b);//打印变量a和b中数据的查: 10 - 20 结果: -10
System.out.println(a * b);//打印变量a和b中数据的积: 10 * 20 结果: 200
System.out.println(b / a);//打印变量b和a中数据的商: 20 / 10 结果: 2
//int/int ==> 结果一定是int类型
System.out.println(3/2);//1
//double/int ==> double/double ==> double
System.out.println(3.0/2);//1.5
}
}
~~~
##### 4.2 算术运算符%
~~~
/*
%运算符: 取余数运算符
数学中的除法运算: 被除数 ÷ 除数 = 商(/: 取的是商) .... 余数(%: 取的是余数)
作用:
1.判断数字的奇偶性
偶数: 可以被2整除 余数是0
奇数: 不可以被2整除 余数是1
2.判断一个数字能否被另一个数字整除
思考:
结合/和%,来计算一个四位数字的每位数字
1234:
个位: 4
十位: 3
百位: 2
千位: 1
*/
public class Demo12Operator {
public static void main(String[] args){
System.out.println(12%2);//0: 说明12是偶数
System.out.println(13%2);//1: 说明13是奇数
System.out.println(100%25);//0: 说明100可以被25整除
System.out.println(120%25);//20: 说明100不可以被25整除
}
}
~~~
##### 4.3 算术运算符+的特殊用法
当+前面是字符串时 +相当于做字符串拼接 "5 + 5" + 5 + 5 => 5+5 = 55
~~~
/*
算术运算符+的特殊用法
1.进行数学中的加法运算
2.+的前后 有字符串,此时+不再代表数学中的加法运算,代表字符串的连接
*/
public class Demo13Operator {
public static void main(String[] args){
System.out.println(5+5);//10
/*
byte/short/char类型数据,只要参加运算会自动转换为int类型
char + int ==> int + int ==> int
需要查看ASCII码表,把字母'A'转换成对应的数字65
*/
System.out.println('A'+5);//'A'+5 ==> 65 + 5 ==> 70
/*
byte/short/char类型数据,只要参加运算会自动转换为int类型
char + char ==> int + int
需要查看ASCII码表,把字母'A'转换成对应的数字65
需要查看ASCII码表,把字母'B'转换成对应的数字66
*/
System.out.println('A'+'B');//'A'+'B' ==> 65 + 66 ==> 131
System.out.println("HelloWorld");
System.out.println("Hello"+"World");//此处+代表字符串的连接: 把World连接到Hello的后面
/*
表达式"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="+(5+5)变为了:"5+5="+10
此处+前面是一个字符串,所以+代表字符串的连接: "5+5=10"
*/
System.out.println("5+5="+(5+5));//5+5=55
}
}
~~~
##### 4.4 赋值运算符
~~~
= 赋值 a=10，将10赋值给变量a
+= 加后赋值 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
~~~
~~~
public class Demo14Operator {
public static void main(String[] args){
int a;//定义int变量a
a = 10;//把数字10赋值给变量a
System.out.println(a);//打印变量a中的值
int b = 20, c = 30;
b += c;// b = b + c
System.out.println(b);//打印变量b中的值: 50
System.out.println(c);//打印变量c中的值: 30
int d = 5, e = 3;
d %= e;// d = d % e ==> 5 % 3: 2
System.out.println(d);//打印变量d中的值: 2
System.out.println(e);//打印变量e中的值: 3
}
}
~~~
##### 4.5 赋值运算符的特点
~~~
/*
赋值运算符的特点
1.+=,-=,*=,/=,%= 如果计算结果的数据类型和左侧变量的数据类型不一致,会自动进行隐藏的强制类型转换
2.整数常量只要不超出所赋值的变量的取值范围,就可以直接赋值,内部隐藏强制类型转换
*/
public class Demo15Operator {
public static void main(String[] args){
short s = 1;
/*
s是short类型,1是int类型,不一致
short类型只要参加运算,会自动转换为int类型
short类型(占2个字节)的s,自动转换为int类型(占4个字节:左侧补充2个字节的0,大小仍然是1)
short + int ==> int + int ==> 两个int相加,结果是int类型(4个字节),
但是左侧变量s是short类型(2个字节)
错误: 右侧是int类型,左侧变量是short类型,无法赋值(大萝卜,不能直接放入小坑当中)
目前解决方案: 强制类型转换,把右侧的int类型结果强制转换成short类型
*/
//s = s + 1;
//目前解决方案: 强制类型转换,把右侧的int类型结果强制转换成short类型
//s = (short)(s+1);
/*
把short类型s的值和int类型1相加
结果是int类型的2,再赋值给short类型的s的时候,会帮助我们进行强制类型转换
*/
s += 1;//等价于s = (short)(s+1);
System.out.println(s);
/*
右侧100是int类型,占四个字节
左侧变量b是byte类型,占1个字节
按照道理讲: 大萝卜是不能直接放入小坑中的
目前运行代码发现没有问题:
原因: 整数常量只要不超出所赋值的变量的取值范围,就可以直接赋值,内部隐藏强制类型转换
int类型100: 00000000 00000000 00000000 01100100
强制转换成byte: 砍掉左侧三个字节的0,数字大小没变
01100100
*/
byte b = 100;//内部: byte b = (byte)100;
System.out.println(b);
}
}
~~~
##### 4.6 自增自减运算符
~~~
/*
自增(++)和自减(--)运算符
1.作用: 就是让变量的值增加1(++)或者减少1(--)
2.使用格式:
(1)可以写在变量的前面: ++a,--a
(2)可以写在变量的后面: a++,a--
以下以++为例
3.使用方式:
(1)单独使用: 不和其它操作(赋值/打印)一起进行运算
++写在变量的前面和++写在变量的后面: 效果是一样的,都是让变量的值增加1
(2)混合使用: 和其它操作(赋值/打印)一起进行运算
++写在变量的前面和++写在变量的后面: 有重大区别
++写在变量的前面: 先++后使用 先把变量的值增加1,然后再使用变量增加1之后的结果数据
++写在变量的后面: 先使用后++ 先使用变量中的值(此时还没有增加1),然后把变量的值增加1
最常用的:
a++和a--
*/
public class Demo16Operator {
public static void main(String[] args){
int a = 2;
++a;//单独使用: a = a + 1
System.out.println(a);//3
int b = 2;
b++;//单独使用: b = b + 1
System.out.println(b);//3
System.out.println("-------------");
int c = 2;
/*
++和=一起构成了混合运算
因为++在变量c的前面,所以先把变量c的值增加1,c增加1之后的结果数据3,
然后把c增加1之后的结果数据3赋值给变量d,所以d的值是3
*/
int d = ++c;
System.out.println(c);//3
System.out.println(d);//3
System.out.println("-------------");
int e = 2;
/*
++和=一起构成了混合运算
因为++在变量e的后面,所以先使用e的值(没有增加1之前的值)2赋值给变量f,所以f的值是2
然后e的值增加1,变为3
*/
int f = e++;
System.out.println(e);//3
System.out.println(f);//2
}
}
~~~
~~~
/*
自增自减运算符的练习
*/
public class Demo17Operator {
public static void main(String[] args){
int x = 4;
/*
表达式(x++)+(++x)+(x*10): 从左向右计算
先计算x++: 因为++在x的后面,所以先使用x的值4,和后面的内容进行加法运算,然后x的值增加1,变成5
(x++)+(++x)+(x*10)==> 4 + (++x)+(x*10): 注意 这个式子中x的值5
再计算(++x): 因为++在x的前面,所以x的值先增加1变为6,然后再使用结果数据6
4 + (++x)+(x*10) ==> 4 + 6 + (x*10): 注意 这个式子中x的值6
4 + 6 + (x*10) ==> 4 + 6 + 6*10 = 70
*/
int y = (x++)+(++x)+(x*10);
System.out.println("x="+x);//6
System.out.println("y="+y);//70
}
}
~~~
## 总结
~~~
能够说出8种基本数据类型
1.整数: byte,short,int,long
2.小数: float,double
3.字符: char
4.布尔: boolean
能够完成变量的定义及输出
int a = 10;
sout(a);
int b = 20, c = 30;
sout(b);
sout(c);
int d;
d = 50;
sout(d);
int e,f;
e = 60;
f = 70;
sout(e);
sout(f);
能够知道类型转换的格式和顺序【小到大自动，大到小强制】
从小到大: 自动类型转换 不需要代码干预
从大到小: 强制类型转换
把long类型的数据强制转换为int类型
转换后类型 变量名称 = (转后类型)转前数据/变量;
long num = 100L;
int a = (int)num;
能够说出常见的运算符有哪几种
+,-,*,/(商),%(余数)
能够知道除法和取余的区别
5 ÷ 2 = 2(商: /) ....1(余数: %)
能够完成字符和字符串的加
+的特殊用法
1.数学中的加法运算: int + int ,int + char, char + char
2.字符串的连接
+前面或者后面有字符串时,此时+代表字符串连接,把后面的内容连接到前面的串的后面
"hello"+5: "hello5"
5+"hello": "5hello"
5+5+"hello": 10 + "hello" ==> "10hello"
~~~
