变量
通过一张不完整的房屋租赁合同，引出变量。
案例：张三需要租赁李四的房屋，租赁合同如下：
上述合同，相当不正规，因为正规的合同上，租客和房东都是有变动的，不能写死，在整个合同中应该 是使用甲方来表示房东，乙方来表示租客，只会在最后的时候签名甲方是谁，乙方是谁。
变量概述
表示存储空间，可用来存放某一类型的常量，没有固定值，并可以重复使用。变量是内存中一块区域，可以往该区域存储数据，修改里面的数据，也可以获取里面的数据。
变量的特点：
(1)占据着内存中的某一块存储区域
(2)该区域有自己的名称（变量名）和类型（数据类型） 可以被重复使用
(3)该区域的数据可以在同一类型范围内不断变化
变量定义和赋值
1.定义一个int类型变量，并赋值。
public class Demo01 {
public static void main(String[] args) {
/**
* 方式一：先定义 后赋值
* 语法：数据类型 变量名;
* 变量名 = 常量值;
*/
int age;
age = 21;
System.out.println(age);
/**
* 方式二：定义同时赋值
* 语法： 数据类型 变量名 = 初始化值;
*/
String name = "BanQ";
System.out.println(name);
}
}
控制台输出：
21
BanQ
使用变量注意：
(1)变量必须先声明，并且初始化后才能使用定义变量必须有数据类型；
(2)变量从开始定义到所在的花括号结束之内可以使用，离开花括号就不能使用了同一作用域内，变量名不能重复定义；
以上面的代码为例：
String，表示类型，这里可以写任何的类型；
name：变量名，和我们的姓名一样理解；
=：赋值运算符，意思是将右边的值赋值给左边的变量“BanQ”。
2.定义每一种数据类型的变量。
public class Demo02 {
public static void main(String[] args) {
//byte类型变量
byte byteVar = 1;
System.out.println(byteVar);
//short类型变量
short shortVar = 2;
System.out.println(shortVar);
//int类型变量
int intVar = 3;
System.out.println(intVar);
//long类型变量
long longVar = 4L;
System.out.println(longVar);
//float类型变量
float floatVar = 0.5F;
System.out.println(floatVar);
//double类型变量
double doubleVar = 0.6;
System.out.println(doubleVar);
//char类型变量
char charVar = '7';
System.out.println(charVar);
//boolean类型变量
boolean booleanVar = true;
System.out.println(booleanVar);
//String类型变量
String stringVar = "8";
System.out.println(stringVar);
}
}
控制台输出：
1 2 3 4 0.5 0.6 7 true 8
3.交换两个相同类型变量的值。
(1)把num1的值存储到临时变量temp中去；
(2)把num2的值赋给num1变量；
(3)把temp存储的值赋给num2变量。
public class Demo03 {
public static void main(String[] args) {
int num1 = 10;
int num2 = 20;
System.out.println("交换前num1：" + num1);
System.out.println("交换前num2：" + num2);
//交换操作
int temp;
temp = num1;
num1 = num2;
num2 = temp;
System.out.println("交换后num1：" + num1);
System.out.println("交换后num2：" + num2);
}
}
控制台输出：
交换前num1：10
交换前num2：20
交换后num1：20
交换后num2：10
表达式
表达式（expression），是由数字、运算符、括号、常量、变量等以能求得结果的组合。
表达式举例（下列a、b、x、y、z都表示变量）。
(1)a + b
(2)3.14 + a
(3)(x + y) * z + 100
基本数据类型转换
在8大基本数据类型中，boolean不属于数值类型，所以不参与转换，其他类型的转换规则如下图。一般的，byte、short、char三种类型相互之间一般不参与转换操作。
按照转换方式，有两种（注意：boolean类型不参与类型转换）：
自动类型转换：范围小的数据类型直接转换成范围大的数据类型，小->大。
强制类型转换：范围大的数据类型强制转换成范围小的数据类型，大->小。
自动类型转换
自动类型转换，也称为“隐式类型转换，就是把范围小的数据类型直接转换成范围大的数据类型。
转换规则：byte、short、char—>int—>long—>float—>double
注意事项：byte、short、char相互之间不转换，他们参与运算首先转换为int类型
语法格式：范围大的数据类型 变量 = 范围小的数据类型值；
public class Demo04 {
public static void main(String[] args) {
// int类型 -> long类型
long longVar = 17; //整数类型默认为int类型
// long类型 -> float类型
float floatVar = longVar;
// float类型 -> double类型
double doubleVar = floatVar;
//自动类型提升
int a = 1;
int b = 2;
int c = a + b;
byte d = 2;
int e = 3;
//byte short char 类型参与运算时会自动提升为int类型
System.out.println(d + e);
}
}
自动类型提升
当一个算术表达式中，包含多个基本数据类型的常量或变量（boolean除外）时，整个算术表达式的结果类型将在出现自动提升，其规则是：
(1)所有的byte、short、char类型被自动提升到int类型，再参与运算；
(2)整个表达式的最终结果类型，被提升到表达式中类型最高的类型。
public class Demo05 {
public static void main(String[] args) {
System.out.println('a' + 1);
byte a = 1;
a = a + 2; //编译失败
double b = 1 + 2F + 3.14 + 4L; //类型自动转化为最高类型double
System.out.println(b);
}
}
因此，算数表达式结果的类型就是其中范围最大的数据类型。
强制类型转换
强制类型转换，也称为显式类型转换，就是把范围大的数据类型强制转换成范围小的数据类型。
语法格式：
范围小的数据类型 变量 = （范围小的数据类型）范围大的数据类型值;
但是一般情况下不建议使用强转，因为强转有可能损失精度。
public class Demo06 {
public static void main(String[] args) {
int a = 1;
byte b = 2;
//自动类型转换
int c = a + b;
//强制类型转换
byte d = (byte)(a + b);
int e = (int)1.23;
System.out.println(e); //输出1
}}
运算符
对常量和变量进行操作的符号称为运算符。
常用运算符：
算术运算符
赋值运算符
比较运算符
逻辑运算符
三元运算符
算术运算符
加减乘除余
对于字符串而言，+符号表示连接操作，任何类型的数据和字符串相连接，结果都是字符串。
public class Demo07 {
public static void main(String[] args) {
int a = 20;
int b = 10;
//加减乘除
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / b);
//取模求余
System.out.println(a % b);
//字符串
System.out.println(1+2+"BanQ");
System.out.println("BanQ"+1+2);
}}
控制台输出：
30
10
200
2
0
3BanQ
BanQ12
自增和自减
自增：++，递增操作符，使变量值增加1，有前置和后置之分，只能操作变量。
自减：-- ，递减操作符，使变量值减去1，有前置和后置之分，只能操作变量。
自增和自减具体操作是一样的，仅仅是一个是加1，一个是减1而已。
public class Demo08 {
public static void main(String[] args) {
int a = 1;
int b = ++a;
System.out.println("a=" + a);
System.out.println("b=" + b);
int c = 1;
int d = c++;
System.out.println("c=" + c);
System.out.println("d=" + d);
}}
控制台输出：
a=2
b=2
c=2
d=1
代码 a++和 ++a，结果都是a变量的值加1。唯一的区别是：
前置（++a）: 表示对result加1之后的结果进行运算
后置（a++）: 表示对result变量加1之前的值（原始值）进行运算。
如果仅仅执行简单的递增操作（只写a++或++a），那么选用任意一个都可以。
正确的解释：
++a表示取a的地址，增加它的内容，然后把值放在寄存器中；
a++表示取a的地址，把它的值装入寄存器，然后增加内存中的a的值；
如果不理解什么是寄存器，简单记住，都可以表示当前变量自身加1，区别是：
前置++：先增加后使用
后置++：先使用后增加
赋值运算符
public class Demo09 {
public static void main(String[] args) {
int a = 1;
System.out.println("a=" + a);
a += 1;
System.out.println("a=" + a);
short b = 2;
b += 1; //等价于 b = (short)（b + 1）
System.out.println("b=" + b);
}}
控制台输出：
a=1
a=2
b=3
比较运算符
用于比较两个变量或常量之间的大小关系，其结果是boolean类型（要么为true，要么为false）。
其格式为:
boolean 变量名 = 表达式A 比较运算符 表达式B;
注意：>=符号，表示大于或者等于。
public class Demo10 {
public static void main(String[] args) {
System.out.println(10 > 5);
System.out.println(10 >= 5);
System.out. println(10 >= 10);
System.out. println(10 < 5);
System.out. println(10<= 5);
System.out. println(10 <=10);
System.out.println(10 == 10);
System.out.println(10 != 10);
int a = 10;
int b = 5 ;
boolean result = a > b;
System.out.println(result);
}}
控制台输出：
true
true
true
false
false
true
true
false
true
三元运算符
三元运算符，表示有三个元素参与的表达式，所以又称为三目运算符，其语义表示if-else（如果什么情况就做什么，否则做什么）。
语法格式：
数据类型 变量名 = boolean表达式 ? 结果A ：结果B；
如果boolean表达式结果：
为true，则三元运算符的结果是结果A；
为false，则三元运算符的结果是结果B；
注：三元运算符必须定义变量接受运算的结果，否则报错。
三元运算符结果的类型由结果A和结果B来决定的，结果A和结果B的类型是相同的。
(1)判断一个数是不是偶数
public class Demo11 {
public static void main(String[] args) {
int a = 77;
String result = a % 2 == 0 ? "偶" : "奇";
System.out.println(result); //奇
}}
(2)求99和20两个数中的最大值
public class Demo12 {
public static void main(String[] args) {
int a = 99;
int b = 20;
int result = a > b ? a : b;
System.out.println("最大值：" + result); //99
}}
(3)—共55条数据，每叶10个条数据，一共分多少页
public class Demo13 {
public static void main(String[] args) {
int totalCount = 55;
int pageSize = 5;
int totalPage = totalCount % pageSize == 0
? totalCount / pageSize
: totalCount / pageSize + 1;
System.out.println(totalPage); //11
}}
逻辑运算符
逻辑运算符用于连接两个boolean表达式，结果也是boolean类型的。
语法格式为：
boolean 变量名 = boolean表达式A 逻辑运算符 boolean表达式B;
运算规则如下：
规律：
非：取反，！true则false,！false则true
与：有false则false
或：有true则true
异或：^ 相同则false,不同则true
public class Demo14 {
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
System.out.println(!!(a > b)); //!!false
}}
控制台输出：
false
false
false
true
false
true
true
true
false
true
false
&和&&的区别
& ：&左边表达式无论真假，&右边表达式都进行运算；
&& ：如果&&左边表达式为真，&&右边表达式参与运算，否则&&右边表达式不参与运算，故称短路与。
| 和 || 的区别同理，||，左边为真，右边不参与运算。
public class Demo15 {
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); //不报错，说明右边表达式不执行
}}
运算优先级
表达式的运算都是有优先级的，基本上和数学中的优先级类似，这里需要注意的是，赋值符号。
注意：赋值符号最后运算的，并且是从右向左运算的。
以上就是Java入门第二天的全部内容了。
资料文档地址：Java开发零基础篇：Day02变量和运算符.pdf
