Java基础学习——变量和运算符
学习目标：
- 必须掌握基本数据类型
- 必须掌握变量的定义和赋值
- 掌握什么是表达式
- 掌握基本数据类型的自动转换
- 掌握基本数据类型的自动提升
- 掌握基本数据类型的强制转换
- 掌握算术运算符的使用
- 了解什么是前置++和后置++的区别
- 掌握赋值运算符的使用，以及它的底层含义
- 掌握比较运算符的使用
- 必须掌握三元运算符的语法和使用
- 掌握逻辑运算符的使用（常用 && 、|| 、！）
- 了解位与（&）和短路与（&&）的区别，记住结论使用&&即可
- 了解运算符的优先级
学习内容：
-
数据类型
-
常量
-
变量的定义和使用
-
基本数据类型的转换
-
算术运算符
-
赋值运算符
-
比较运算符
-
三元运算符
-
逻辑运算符
学习时间：
一天
学习产出：
例如：
- 技术笔记 2 遍
- CSDN 技术博客 1 篇
2.Java入门基础下
2.1数据类型、常量、变量
2.1.1常量（掌握）
常量，程序中固定不变化的值。
常量分类：
-
字面量：就表示直接给出的一个值（可以是整数、小数、字符串等等），也有人称之为直接量。如：整数常量1，2，3，小数常量3.14等。
-
使用final定义的变量
2.1.2数据类型（重点）
生活中，数据都是有类型这个概念的，比如张三18岁，18这个数字就是整型的，买了2.5斤菜，2.5就是小数类型的，在Java中每一个数据都有数据类型。
常用的整数类型是int和long，byte和short基本不用，常用的小数类型是double，float基本不用。因为double是双精度的，在实际开发中表示精确的小数我们使用BigDecimal类。
8种基本数据类型的范围和站内存大小（了解）：
8位数据为例：
2进制的11111111表示-1，10000000表示-128，所以负数范围-128~ -1；2进制00000000表示0，01111111表示127，所以正数范围0~ 127。合起来就是-128~ 127，找一下规律发现是- 2的（8-1）次方~2的（8-1）次方-1，那么就可以得到任何位数的范围
byte：
- byte数据类型是8位、有符号的，以二进制补码表示的整数；
- 最小值是 -128（-2^7）；
- 最大值是 127（2^7-1）；
- 默认值是 0；
- byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
- 例子：byte a = 100，byte b = -50。
short：
- short数据类型是16位、有符号的以二进制补码表示的整数
- 最小值是 -32768（-2^15）；
- 最大值是 32767（2^15 - 1）；
- Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
- 默认值是 0；
- 例子：short s = 1000，short r = -20000。
int：
int数据类型是32位、有符号的以二进制补码表示的整数；
-
最小值是 -2,147,483,648（-2^31）；
-
最大值是 2,147,483,647（2^31 - 1）；
-
一般地整型变量默认为 int 类型；
-
默认值是 0 ；
-
例子：int a = 100000, int b = -200000。
long: -
long的数据类型64位、有符号的以二进制补码表示的整数；
-
最小值是 -2,147,483,648（-2^31）；
-
最大值是 2,147,483,647（2^31 - 1）；
-
一般地整型变量默认为 int 类型；
-
默认值是 0 ；
-
例子：int a = 100000, int b = -200000。
float： -
float的数据类型是单精度、32位、符合IEEE 754标准的浮点数；
-
float 在储存大型浮点数组的时候可节省内存空间；
-
默认值是 0.0f；
-
浮点数不能用来表示精确的值，如货币；
-
例子：float f1 = 234.5f。
double: -
double数据类型是双精度、64位、符合 IEEE 754 标准的浮点数；
-
浮点数的默认类型为 double 类型；
-
double类型同样不能表示精确的值，如货币；
-
默认值是 0.0d；
-
例子：
double d1 = 7D ;
double d2 = 7.;
double d3 = 8.0;
double d4 = 8.D;
double d5 = 12.9867;
7 是一个 int 字面量，而 7D，7. 和 8.0 是 double 字面量。
boolean:
- boolean数据类型表示一位的信息；
- 只有两个取值：true 和 false；
- 这种类型只作为一种标志来记录 true/false 情况；
- 默认值是 false；
- 例子：boolean one = true。
char:
char类型是一个单一的16位Unicode字符；
-
最小值是 \u0000（即为 0）；
-
最大值是 \uffff（即为 65535）；
-
char 数据类型可以储存任何字符；
-
例子：char letter = ‘A’;。
注意： -
整数类型默认是int类型，小数类型默认是double类型
-
表示long类型常量，要加L或者l，建议加L
-
表示float类型常量，要加F或者f，建议加F
-
字符表示Unicode（万国码）编码表中的每一个符号，每个符号使用单引号引起来，其中前128个符号和ASCII表相同，如下图。
-
boolean类型适用于逻辑运算，一般用于流程控制。
-
引用类型先不管，先记住String这个类，表示字符串类型就可以了，所谓字符串就是多个字符合在一起，每个字符串使用双引号引起来。
-
整数常量，所有整数，如1、2、3、100、200等
-
小数常量，所有小数，如1.2、2.7、3.14等
-
字符常量，0~65535之间的整数或用单引号括起来的符号如，‘A’、‘a’、‘龙’等
-
布尔常量，只有true和false，分别表示对与错
-
字符串常量，使用双引号括起来的内容如：“Will”、“wolfcode”等
需求：定义每一种数据类型的常量
public class TypeDemo{
public static void main(String[] args){
//byte类型常量
System.out.println(20);
//short类型常量
System.out.println(20);
//int类型常量
System.out.println("十进制" + 20);
System.out.println("二进制" + 0B00010100);
System.out.println("八进制" + 024);
System.out.println("十六进制" + 0x14);
//long类型常量,使用L后缀
System.out.println(20L);
//float类型常量,使用F后缀 精度7
System.out.println(3.14F);
//double类型常量 精度15
System.out.println(3.14);
//char类型常量
System.out.println(65);
System.out.println('A');
// 编译报错 有仅有一个字符
//System.out.println('');
//System.out.println('AB');
//boolean类型常量
System.out.println(true);
System.out.println(false);
//String类型常量
System.out.println("你好");
// 内容为空
System.out.println("");
}
}
2.1.3.变量（重点）
内存如同酒店
数据各式各样，要先根据数据的需求（即类型）为申请一块合适的空间
变量是存储数据的一个基本单元
变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。
内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来存储该类型数据，没有固定值，并可以重复使用。
可以往该区域存储数据，修改里面的数据，也可以获取里面的数据。
变量的特点：
- 占据着内存中的某一块存储区域
- 该区域有自己的名称（变量名）和类型（数据类型）
- 可以被重复使用
- 该区域的数据可以在同一类型范围内不断变化
- 语法格式：
数据类型 变量名 赋值符号 常量值；
2.1.3.2 变量定义和赋值（重点）
记：语法格式
- money：变量名，钱的意思， 见名知意
- =：赋值运算符，后面会讲，意思是将右边的值赋值给左边的变量
- 1000：一个整数类型的值，如果是其他类型
public class Demo{
public static void main(String[] args) {
//方式一，在声明时同时赋值（推荐）
//数据类型 变量名 = 初始化值；
//定义一个int类型的变量，初始化值为1000.
int money1 =1000;
System.out.println(money1);
//方式二，先定义变量，再赋值
//数据类型 变量名；如：int money2;
//变量名=常量值；如：money2=2000;
int money2;
money2=2000;
System.out.println(money2);
//修改money2量的值为2020；
money2= 2020;
System.out.println(money2);
}
}
使用变量注意：
- 变量必须先声明，并且初始化后才能使用
- 定义变量必须有数据类型
- 对于long和float类型来说，字母后缀L和F不要丢掉
- 变量值不能超过变量类型范围 变量从开始定义到所在的花括号结束之内可以使用，离开花括号就不能使用了(局部变量)
- 同一作用域内，变量名不能重复定义
- 同一类型串联简写 （int a,b,c;在赋值 或者int a = 10,b = 20,c = 30;）
需求：定义每一种数据类型的变量（演示）
public class VarDemo{
public static void main(String[] args) {
//byte类型变量
byte b = 20;
System.out.println(b);//20
//short类型变量
short s = 20;
System.out.println(s);//20
//int类型变量
int i = 20;
System.out.println(i);//20
//long类型变量,使用L后缀
long l = 20L;
System.out.println(l);//20
//float类型变量,使用F后缀
float f = 3.14F;
System.out.println(f);//3.14
//double类型变量
double d = 3.14;
System.out.println(d);//3.14
//char类型变量
char c = 'A';
System.out.println(c);//A
//boolean类型变量
boolean bb = true;
System.out.println(bb);//true
//String类型变量
String str = "你好";
System.out.println(str);//你好
}
}
需求：交互两个相同类型变量的值
1、把num1的值存储到临时变量temp中去
2、把num2的值赋给num1变量
3、把temp存储的值赋给num2变量
public class ChangVarDemo{
int num1 = 10;
int num2 =20;
System.out.println("num1=" + num1);
System.out.println("num2=" + num2);
//--------------------------------
//交互操作
int temp =num1;
num1 = num2;
num2 =temp;
//--------------------------------
System.out.println("num1=" + num1);
System.out.println("num2=" + num2);
}
}
2.2 表达式（掌握）
表达式（expression），是由数字、运算符、括号、常量、变量等以能求得结果的组合。
表达式举例（下列a、b、x、y、z都表示变量）。
- a+b
- 3.14+a
- (x+y)*z+100
通常等号左边的是变量，右边的是表达式
变量=表达式；
数据类型 变量 赋值符号 表达式；
int a =2;
int b =3;
int ab=a+b;
String ab="zhangsan"+a+b;
2.3 基本数据类型转换（掌握）
在8大基础数据类型中，boolean不属于数值类型，所以不参与转换，其他类型的转换规则如下图。一般的，byte、short、char三种类型相互之间一般不参与转换操作。
按照转换方式，有两种（注意：boolean类型不参与转换）：
自动类型转换：范围小的数据类型直接转换成范围大的数据类型，小–>大。
强制类型转换：范围大的数据类型强制转换成范围小的数据类型，大–>小。
问题：三个大小不同容器，能相互把水倒给对方吗？
科普了解:
float占4个字节为什么比long占8个字节大？
--->因为底层的实现方式不同
浮点数的32位并不是简单直接表示大小，而是按照一定标准分配的。
第1位，符号位，即S
接下来8位，指数域，即E。
剩下23位，小数域，即M，取值范围为[1 ,2 ) 或[0 , 1)
然后按照公式：V = (-1) ^ s * M * 2 ^ E
也就是说浮点数在内存中的32位不是简单地转换为十进制，而是通过公式（科学计数法）来计算而来，通过这个公式 虽然只有4个字节，但浮点数最大值要比长整型（long）的范围要大。
2.3.1 自动类型转换（掌握）
自动转换类型，也称为“隐式类型转换”，就是把范围小的数据类型直接转成范围大的数据类型。
转换规则：byte、short、char–>int–>long–>float–>double
低------------------------------------------------------>高
byte，short，char-->int-->long-->float-->double
注意事项：byte、short、char相互之间不转换，他们参与运算首先转换为int类型
语法格式：范围大的数据类型 变量 =范围小的数据类型值；
语法举例：
public class TypeConvertDemo1{
public static void main(String[] args) {
//把int类型变量转为long类型
long longNumber = 17;//整数默认为int类型
//把long类型变量转为float类型
float f1 =longNumber;
//把float类型变量转为double类型
double d=f1;
//定义两个int类型的变量
int a1=2;
int a2=3;
int c1=a1+a2;
//定义一个byte类型，一个int类型
byte b2=2;
int b3=3;
System.out.println(b2+b3);
//byte、short、char类型参与运算时把自己提升为int类型
//byte d1 =b2+c2//编译报错
int d3=b2+c2;//编译通过
}
}
2.3.2 自动类型提升（掌握）
当一个算术表达式中，包含多个基本数据类型的常量或变量（boolean除外）时，整个算术表达式的结果类型将出现自动提升，其规则是：
所有的byte、short、char类型被自动提升到int类型，再参与运算
整个表达式的最终结果类型，被提升到表达式中类型最高的类型
计算机的底层会用一个数字（二进制）来表示字符A（65）一旦char类型参与数学运算，就会自动转换为数字
char c='A';
int i=c+10;
System.out.println(i);
byte b =22;
b=b+11;//编译出错，此时结果类型为int
b=(byte)(b+11);
double d1=123+1.1F+3.14+99L;
结论：算数表达式结果的类型就是其中范围最大的数据类型。
2.3.3 强制类型转换（掌握）
强制类型转换，也称为“显示类型转换”，就是把范围大的数据类型强制转换成范围小的数据类型。
语法格式：
范围小的数据类型 变量 = (范围小的数据类型)范围大的数据类型值；
int i =(int)3.14f;
注意：一般情况下不建议使用强转，因为强转有可能损失精度。
public class TypeConvertDemo2{
public static void main(String[] args) {
int a = 2;
byte b = 3;
//自动类型转换
int c = a + b;
//强制类型转换
byte d = (byte) (a + b);
//把double转换为int类型
int i = (int)3.14;
System.out.println(i);//小数位舍掉
int num = (int) 80,0000,0000L;
System.out.println(num);//数据溢出
}
}
ASCII字符码表：是数组和字符对照关系，0-127十进制对应的字符，是美国信息交换标准代码
Unicode万国码表：也是数组和字符对照关系，开头仍是0-127部分，但从128开始就包含有更多的字符
这张表要记住的几个符号，A在码表的顺序是65，a在码表的顺序是97。
不同数据类型的常量：
2.4运算符
对常量和变量进行操作的符号称为运算符
常用运算符：
-
算术运算符
-
赋值运算符
-
比较运算符
-
逻辑运算符
-
三元运算符
2.4.1 算术运算符（掌握）
用来四则运算的符号，和小学学习的加减乘除无异。
2.4.1.1 加减乘除余（了解）
对于字符串而言，+符号表示连接操作，任何类型的数据和字符串相连接，结果都是字符串。
public class ArithmeticOperatorsDemo1{
public static void main(String[] args) {
// 定义两个变量
int a = 10;
int b = 5;
System.out.println(a + b);//15
System.out.println(a - b);//5
System.out.println(a * b);//50
System.out.println(a / b);//2
//取模，求余数
System.out.println(10 % 5);
System.out.println(10 % 3);
System.out.println(7 + 8 + "Hello");//15Hello
System.out.println("Hello" + 7 + 8);//Hello78
System.out.println(8765 / 1000 * 1000);//8000
//System.out.println(10 / 0);//除数为0,报错：ArithmeticException
}
}
2.4.1.2 自增和自减（掌握）
自增：++，递增操作符，使变量值增加1，有前置和后置之分，只能操作变量。
自减：-- ，递减操作符，使变量值减去1，有前置和后置之分，只能操作变量。
自增和自减具体操作是一样的，仅仅是一个是加1，一个是减1而已，现在单讲++。
代码 result ++和 ++result，结果都是result变量的值加1。
唯一的区别是：
-
前置（++result）: 表示对result加1之后的结果进行运算
-
后置（result++）: 表示对result变量加1之前的值（原始值）进行运算。
如果仅仅执行简单的递增操作（只写result++或++result），那么选用任意一个都可以。
public class ArithmeticOperatorsDemo2{
public static void main(String[] args) {
int num1 = 10;
System.out.println("num1=" +num1);//num1 = 10
++ num1;
System.out.println("num1=" +num1);//num1 = 11
num1 ++;
System.out.println("num1=" +num1);//num1 = 12
int a1 = 5;
int b1 = ++ a1;
System.out.println("a1=" + a1 + ",b1=" + b1);//a1=6,b1=6
int a2 = 5;
int b2 = a2 ++;
System.out.println("a2=" + a2 + ",b2=" + b2);//a2=6,b2=5
}
}
比较权威的解释：
-
++a表示取a的地址，增加它的内容，然后把值放在寄存器中；
-
a++表示取a的地址，把它的值装入寄存器，然后增加内存中的a的值；
如果不理解什么是寄存器，简单记住，都可以表示当前变量自身加1，区别是
-
前置++：先增加后使用
-
后置++：先使用后增加
2.4.2 赋值运算符（掌握）
public class AssigningOperatorDemo {
public static void main(String[] args) {
// 把常量17赋值给int类型的变量a
int a = 17;
System.out.println("a=" + a);
// += 把左边和右边的数据进行运算，最后赋值左边变量
a += 10;// 相当于a = a + 10
System.out.println("a=" + a);
short s = 5;
s += 2; //底层相当于 s = (short) (s + 2)
System.out.println("s=" + s);
}
}
2.4.3 比较运算符（掌握）
用于比较两个变量或常量之间的大小关系，其结果是boolean类型（要么为true，要么为false）。
其操作格式为:
boolean result = 表达式A 比较运算符 表达式B；
注意：>=符号，表示大于或者等于。
public class ComparisonOperatorDemo {
public static void main(String[] args) {
//直接操作常量
System.out.println(10 > 5);//true
System.out.println(10 >= 5);//true
System.out.println(10 >= 10);//true
System.out.println(10 < 5);//false
System.out.println(10 <= 5);//false
System.out.println(10 <= 10);//true
System.out.println(10 == 10);//true
System.out.println(10 != 10);//false
//使用变量操作
int a = 10;
int b = 5;
boolean result = a > b;
System.out.println(result);//true
}
}
2.4.4 三元运算符（掌握)
三元运算符，表示有三个元素参与的表达式，所以又称为三目运算符，其语义表示if-else（如果什么情况就做什么，否则做什么）。
语法格式：数据类型 变量 =boolean表达式？结果A：结果B；
-
如果boolean表达式结果：
-
为true，则三元运算符的结果是结果A；
-
为false，则三元运算符的结果是结果B；
注：
- 三元运算符必须定义变量接受运算的结果，否则报错
- 三元运算符结果的类型由结果A和结果B来决定的，结果A和结果B的类型是相同的。
需求1：判断一个数99是不是偶数,打印对应的结果
public class TernaryOperatorDemo1{
public static void main(String[] args) {
// 是否被2整除
int a = 99;
String result = a % 2 == 0 ? "偶数" : "奇数";
System.out.println(result); // 奇数
}
}
需求2：求99和20两个数中的最大值
public class TernaryOperatorDemo2{
public static void main(String[] args) {
int a = 99;
int b = 20;
int result = a > b ? a : b;
System.out.println("最大值："+result);
}
}
需求3：一共55条数据，每页10条数据，一共分多少页
分析：totalCount和pageSize相除 如果能除尽 取商，反之取商+1
public class TernaryOperatorDemo3{
public static void main(String[] args) {
int totalCount =54;
int pageSize=10;
int totalPage = totalCount % pageSize ==0
? totalCount / pageSize
: totalCount / pageSize +1;
System.out.println(totalPage);
}
}
2.4.5逻辑运算符（掌握）
逻辑运算符用于连接两个boolean表达式，结果也是boolean类型的。
语法格式：boolean result = boolean表达式A 逻辑运算符 boolean表达式B；
boolean b = 10 <20 s逻辑运算符 20>10;
运算规则如下：
规律：
- 与：有false则false
- 或：有true则true
- 非：取反，！true则false,！false则true
- 异或：^ 相同则false,不同则true
2.4.5.1 基本使用（掌握）
public class LogicalOperatorDemo1 {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;
//与操作
System.out.println((a > b) & (a > c)); // false & false
System.out.println((a > b) & (a < c)); // false & true
System.out.println((a < b) & (a > c)); // true & false
System.out.println((a < b) & (a < c)); // true & true
//或操作
System.out.println((a > b) | (a > c)); // false | false
System.out.println((a > b) | (a < c)); // false | true
System.out.println((a < b) | (a > c)); // true | false
System.out.println((a < b) | (a < c)); // true | true
//相反操作
System.out.println((a > b)); // false
System.out.println(!(a > b)); // !false
}
}
2.4.5.2 &和&&的区别（掌握)
& ：&左边表达式无论真假，&右边表达式都进行运算；
&& ：如果&&左边表达式为真，&&右边表达式参与运算，否则&&右边表达式不参与运算，故称短路与。
| 和 || 的区别同理，||，左边为真，右边不参与运算。
public class LogicalOperatorDemo2 {
public static void main(String[] args) {
System.out.println(false & 1 / 0 == 1);//报错，说明右边执行了
System.out.println(false && 1 / 0 == 1);//不报错，说明右边没有执行
System.out.println(true | 1 / 0 == 1);//报错，说明右边执行了
System.out.println(true || 1 / 0 == 1);//不报错，说明右边没有执行
}
}
上述代码，一行一行的测试，测试完，注释该行代码。
2.4.6 运算优先级
表达式的运算都是有优先级的，基本上和数学中的优先级类似，这里需要注意的是，赋值符号。
注意：赋值符号最后运算的，并且是从右向左运算的。
