day02-变量和运算符

day02-变量和运算符

今日学习内容：

• 数据类型
• 常量
• 变量的定义和使用
• 基本数据类型的转换
• 算术运算符
• 赋值运算符
• 比较运算符
• 三元运算符
• 逻辑运算符

今日学习目标：

必须掌握变量的定义和赋值

掌握什么是表达式

掌握基本数据类型的自动转换

掌握基本数据类型的自动提升

掌握基本数据类型的强制转换

掌握算术运算符的使用

了解什么是前置++和后置++的区别

掌握赋值运算符的使用，以及它的底层含义

掌握比较运算符的使用

必须掌握三元运算符的语法和使用

掌握逻辑运算符的使用（常用 && 、|| 、！）

了解位与（&）和短路与（&&）的区别，记住结论使用&&即可

了解运算符的优先级

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种基本数据数据类型的范围和占内存大小（了解）：1个字节8位 01010101 01111111

• 整数类型默认是int类型，小数类型默认是double类型
• 表示long类型常量，要加L或者l，建议加L
• 表示float类型常量，要加F或者f，建议加F
• 字符表示Unicode（万国码）编码表中的每一个符号，每个符号使用单引号引起来，其中前128个符号和ASCII表相同，如下图。
• boolean类型适用于逻辑运算，一般用于流程控制。
• 引用类型先不管，先记住String这个类，表示字符串类型就可以了，所谓字符串就是多个字符合在一起，每个字符串使用双引号引起来。

这张表要记住的几个符号，A在码表的顺序是65，a在码表的顺序是97。

不同数据类型的常量：

• 整数常量，所有整数，如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后缀
		System.out.println(3.14F);

		//double类型常量
		System.out.println(3.14);

		//char类型常量
		System.out.println(65);
		System.out.println('A');

		//boolean类型常量
		System.out.println(true);
		System.out.println(false);

		//String类型常量
		System.out.println("你好");
	}
}

2.1.3.变量（重点）

通过一张不完整的房屋租赁合同，引出变量。

案例：张三需要租赁李四的房屋，租赁合同如下：

上述合同，相当不正规，因为正规的合同上，租客和房东都是有变动的，不能写死，在整个合同中应该是使用甲方来表示房东，乙方来表示租客，只会在最后的时候签名甲方是谁，乙方是谁。

2.1.3.1 变量概述（了解）

表示存储空间，可用来存放某一类型的常量，没有固定值，并可以重复使用。变量是内存中一块区域，可以往该区域存储数据，修改里面的数据，也可以获取里面的数据。

变量的特点：

• 占据着内存中的某一块存储区域
• 该区域有自己的名称（变量名）和类型（数据类型）
• 可以被重复使用
• 该区域的数据可以在同一类型范围内不断变化

2.1.3.2 变量定义和赋值（重点）

需求，定义一个int类型变量，并赋值。

public class VarDemo{
	public static void main(String[] args) {
        // 方式一，先定义变量，再赋值
		// 数据类型  变量名;如：int	age；
		// 变量名 = 常量值;
		// 定义一个int类型变量,初始值为17
		int age;
		//修改age变量的值为17
		age = 22;
		System.out.println(age);
        // 方式二，在声明时同时赋值（推荐）
		// 数据类型 变量名 = 初始化值;	
        // 定义一个String类型的变量，初始值为wolf
        String name = "wolf";
	}
}

使用变量注意：

• 变量必须先声明，并且初始化后才能使用
• 定义变量必须有数据类型
• 变量从开始定义到所在的花括号结束之内可以使用，离开花括号就不能使用了
• 同一作用域内，变量名不能重复定义

记： 语法格式

• String，表示类型，这里可以写任何的类型
• name：变量名，和我们的姓名一样理解， 没有为什么
• =：赋值运算符，后面会讲，意思是将右边的值赋值给左边的变量
• “wolf”：一个字符串类型的值，如果是其他类型，不要加引号

需求：定义每一种数据类型的变量

public class VarDemo{

	public static void main(String[] args) {

		//byte类型变量
		byte b = 20;
		System.out.println(b);

		//short类型变量
		short s = 20;
		System.out.println(s);

		//int类型变量
		int i = 20;
		System.out.println(i);

		//long类型变量,使用L后缀
		long l = 20L;
		System.out.println(l);

		//float类型变量,使用F后缀
		float f = 3.14F;
		System.out.println(f);

		//double类型变量
		double d = 3.14;
		System.out.println(d);

		//char类型变量
		char c = 'A';
		System.out.println(c);

		//boolean类型变量
		boolean bb = true;
		System.out.println(bb);

		//String类型变量
		String str = "你好";
		System.out.println(str);
	}
}

需求：交互两个相同类型变量的值

1、把num1的值存储到临时变量temp中去

2、把num2的值赋给num1变量

3、把temp存储的值赋给num2变量

public class ChangVarDemo{

	public static void main(String[] args) {
		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

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个字节，但浮点数最大值要比长整型的范围要大。

2.3.1 自动类型转换（掌握）

自动类型转换，也称为“隐式类型转换，就是把范围小的数据类型直接转换成范围大的数据类型。

转换规则：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 b1 = 3;
		int c1 = a1 + b1;

		//定义一个byte类型,一个int类型
		byte b2 = 2;
		int c2 = 3;
		System.out.println(b2 + c2);

		//byte、short、char类型参与运算时把自己提升为int类型
		//byte d1 = b2 + c2;//编译报错
		int d3 = b2 + c2;//编译通过
	}
}

2.3.2 自动类型提升（掌握）

当一个算术表达式中，包含多个基本数据类型的常量或变量（boolean除外）时，整个算术表达式的结果类型将在出现自动提升，其规则是：

• 所有的byte、short、char类型被自动提升到int类型，再参与运算
• 整个表达式的最终结果类型，被提升到表达式中类型最高的类型

System.out.println('a' + 1);//98
byte b = 22;
b = b + 11;//编译出错，此时结果类型应该是int
double d1 = 123 + 1.1F + 3.14 + 99L ;

结论：算数表达式结果的类型就是其中范围最大的数据类型。

2.3.3 强制类型转换（掌握）

强制类型转换，也称为“显式类型转换”，就是把范围大的数据类型强制转换成范围小的数据类型。

语法格式：

范围小的数据类型  变量 = （范围小的数据类型）范围大的数据类型值;

注意：一般情况下不建议使用强转，因为强转有可能损失精度

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);//3
	}
}

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 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) {
		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个条数据，一共分多少页

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;

运算规则如下：

规律：

• 非：取反，！true则false,！false则true
• 与：有false则false
• 或：有true则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
		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 运算优先级

表达式的运算都是有优先级的，基本上和数学中的优先级类似，这里需要注意的是，赋值符号。

注意：赋值符号最后执行的，并且是从右向左运算的。

学习优势：

1.包含java前后端从 0 ->1 全过程教学, 内容全面, 知识点不遗漏, 学完即可参加实际工作.
2.课程为目前项目开发常用的技术知识，向用人单位对标，学以致用。那些脱离实际，废弃不用的，太前沿的框架技术前期不建议学。
3.一起学习,打卡,一起交流,希望能营造一个和线下一样的学习环境。

需要进微信学习交流群, 或者想领取代码,文档,全套视频的同学请+v：lmm99964