变量，作用域，运算符
文章目录
-
- 变量，作用域，运算符
-
-
- 1. 变量
-
- 1.1 变量定义格式【重点】
- 1.2 变量定义代码演示
- 1.3 变量定义过程中的问题
-
- 1.3.1 浮点常量默认数据类型
- 1.3.2 long整数数据赋值建议
- 1.3.3 字符类型常量有且只能使用字符本身
- 1.3.4 Java中变量未初始化不能使用
- 1.3.5 找不到符号问题
- 1.3.6 浮点数拓展
- 1.3.7 字符拓展
- 1.3.8 new对象跟直接创建对象区别
- 1.3.9 类型转换
- 1.4 变量作用域
- 2. 运算符
-
- 2.1 算术运算符
- 2.2 自增自减运算符
- 2.3 关系运算符
- 补充：
- 2.4 逻辑运算符
- 2.5 计算时内存溢出
- 2.6 小练习
- 2.6 短路原则
-
变量，作用域，运算符
1. 变量
1.1 变量定义格式【重点】
格式:
数据类型 变量名 = 初始化数据;
数据类型:
明确当前变量可以保存的数据类型是什么
例如：
数据类型为char类型，当前变量，有且只能保存字符类型
数据类型为int类型，当前变量，有且只能保存一定范围以内的整数类型
【数据类型一致化要求】
变量名:
要求符合AJCG命名规范。见名知意，动宾结构
变量名是操作当前变量使用的一个名称，具有一定范围以内的唯一性。
变量名保存程序运行过中，赋值给变量的数据
=:
赋值号 将赋值号右侧的数据，赋值给左侧的【变量】。
初始化数据:
需要对应当前数据类型，赋值当前程序要求初始化数据。
1.2 变量定义代码演示
class Demo1 {
public static void main(String[] args) {
/* 整型变量 */
byte byteNumber = 10;
short shortNumber = 20;
int intNumber = 30;
long longNumber = 40L;
System.out.println(byteNumber);
System.out.println(shortNumber);
System.out.println(intNumber);
System.out.println(longNumber);
/* 浮点型变量 */
float floatNumber = 5.5F;
double doubleNumber = 3.14;
System.out.println(floatNumber);
System.out.println(doubleNumber);
/* 字符类型变量 */
char ch1 = 'A';
char ch2 = '我';
System.out.println(ch1);
System.out.println(ch2);
/* 布尔类型 ret ==> result 结果 */
boolean ret1 = true;
boolean ret2 = false;
System.out.println(ret1);
System.out.println(ret2);
}
}
1.3 变量定义过程中的问题
1.3.1 浮点常量默认数据类型
Demo1.java:15: 错误: 不兼容的类型: 从double转换到float可能会有损失
float floatNumber = 5.5;
^
1 个错误
在计算机中，计算机为了保证数据的精度问题，所有的常量浮点类型数据，都看作是double类型。double数据类型占用内存空间是8个字节，float占用4个。这里因为数据类型不一致，导致报错。我们需要告知编译器，当前浮点类型常量数据类型为float类型。
在常量之后加上大写 F
float floatNumber = 5.5F;
1.3.2 long整数数据赋值建议
在开发中，整数默认的采用的形式都是int类型。赋值给long类型变量，是可以执行，没有报错。但是为了数据类型一致化要求，我们可以告知编译器，当前常量为long类型
在常量之后加入一个大写 L
long longNumber = 40L;
1.3.3 字符类型常量有且只能使用字符本身
1.3.4 Java中变量未初始化不能使用
int num;
System.out.println(num);
Demo1.java:38: 错误: 可能尚未初始化变量num
System.out.println(num);
^
1 个错误
num定义之后并没有进行赋值操作。当前num中保存的数据，对于Java程序而言是无效的，无法明确当前num保存的数据内容是什么。Java通过编译器提示，避免了【野值】问题。
Java中的一个变量未赋值的情况下，不得参与其他代码执行操作。
1.3.5 找不到符号问题
1. 当前使用的变量未定义！！！
Java中变量未定义不能使用。
2. 变量名/方法名 拼写错误
1.3.6 浮点数拓展
银行业务使用float还是double？ 应该使用BigDecimal类表示
float f1 = 0.1F;
double d1 = 1.0/10;
System.out.println(f1); // 输出结果 0.1
System.out.println(d1); // 输出结果 0.1
System.out.println(d1 == f1); // 输出结果 false
float f2 = 34561321651231F;
float f3 = f2 + 1;
System.out.println(f2 == f3); // 输出结果 true
1.3.7 字符拓展
char c1 = 'a';
char c2 = '中';
System.out.println(c1); // 输出结果 a
System.out.println((int)c1); // 输出结果 97
System.out.println(c2); // 输出结果 中
System.out.println((int)c2); // 输出结果 20013
// 所有字符本质还是数字 编码 Unicode
char c3 = '\u0061';
System.out.println(c3); // 输出结果 a
1.3.8 new对象跟直接创建对象区别
String s1 = "95827";
String s2 = "95827";
System.out.println(s1 == s2); // 输出结果 true
String s3 = new String("95827");
String s4 = new String("95827");
System.out.println(s3 == s4); // 输出结果 false
// jvm在堆区为对象分配完内存后，产生一个引用指向这个对象在内存中的地址
// s3、s4实际是引用对象的地址 (有new就有堆，每次new都创建一个新的对象，不论对象的值是否相等)
1.3.9 类型转换
int a = 128;
byte b = (byte)a;
System.out.println(a); // 输出结果 128
System.out.println(b); // 输出结果 -128
// 二进制128 ：10000000
// Java中：1表示符号位（为1时正数，0代表负数）后七位表示数值
System.out.println((int)23.8); // 输出结果 23
System.out.println((int)-23.72); // 输出结果 -23
// 强制类型转换可能会丢失精度
类型转换：强制装换（高到低） 自动转换（低到高）
1.4 变量作用域
/*
类变量
实例变量
局部变量
*/
public class Test {
static int anInt = 18; // 类变量（全局变量）
int a; // 实例变量:从属于对象，不初始化值为默认值
public static void main(String[] args) {
// test--> Test类的对象
Test test = new Test();
System.out.println(test.a);// 输出结果为0
// 类变量
System.out.println(test.anInt);// 输出结果为18
}
public void method() {
int a = 18; // 局部变量:必须声明和初始化值
}
}
// 默认值：boolean: 默认false
// int short long float double 默认为0
// 除了基本类型，其他类型都为null
2. 运算符
补充：转义字符
对于字符使用，有且只允许使用【字符本身】，不允许使用对应编码值
转义字符：
\" // 表示斜杠后的"
\' // 表示斜杠后的'
\\ // 表示斜杠后的\
\\\\ // 表示斜杠后的\，相当于两个\\
\n // 换行
\t // 一个制表符
2.1 算术运算符
数学中
+ - × ÷ ()
注意事项:
1. 先乘除，后加减
2. 有括号先处理括号里面的内容
3. 从左至右计算内容
4. 除数不能为0
开发中
+ - * / % () =
% 取余[只能操作整数]
5 ÷ 2 = 2 ... 1 商为 2 余数为 1 取余操作需要的结果为1
10 % 12 ==> 10
5 % 4 ==> 1
6 % 2 ==> 0
4 % 5 ==> 4
优先级问题:
在运算过程中，如果出现了优先级问题，简单粗暴加括号
/* 算术运算符演示 */
class Demo2 {
public static void main(String[] args) {
int num1 = 20;
int num2 = 30;
num1 = num1 + num2; // num1 = 50 num2 = 30
num1 = num1 * num2; // num1 = 1500 num2 = 30
num1 = num1 - num2; // num1 = 1470 num2 = 30
num1 = num1 / num2; // num1 = 49 num2 = 30
num1 = num1 % num2; // num1 = 19 num2 = 30
System.out.println("num1 : " + num1);
System.out.println("num1 : " + num2);
}
}
public class test {
public static void main(String[] args) {
long a = 7894564321L;
int b = 123456;
short c = 123;
byte d = 10;
// 数值提升，运算时有高类型结果向上提升
System.out.println(a + b + c + d); // 输出结果为 7894687910 long类型
System.out.println(b + c + d); // 输出结果为 123589 int类型
System.out.println(c + d); // 输出结果为 133 int类型
}
}
2.2 自增自减运算符
格式:
++ --
1. 自增自减运算符，有且只能操作变量
2. ++ 自增操作，当前变量数据 + 1 -- 自减操作，当前变量数据 - 1
基本的语法
在变量之后，首先取出当前变量数据，参与当前行代码执行，然后在执行自增/自减操作
在变量之前，首先执行自增/自减操作，然后当前变量再来参与当前代码行执行
【来自16岁程序员的建议】
使用 += 1 替代++
使用 -= 1 替代--
来自 Swift iOS开发语言
自增自减运算符单独成行
【补充知识点】
+= -= *= /= %=
num1 = num1 + 10; ==> num1 += 10;
1.
int num = 5;
int ret = num++ * ++num;
num = 7
ret = 35
num++ * ++num
num++ : 5 num ==> 6
++num : num ==> 7 7
5 * 7
2.
int num = 5;
++(num++)++;
num = ?
编译错误
自增自减运算符，有且只能操作变量
(num++) 对于整个代码运行过程中,(num++)对外是一个整体，可以看做是一个常量，已经不再是操作num内容
int num = 10;
++num;
num++;
2.3 关系运算符
数学中:
> < ≥ ≤ ≠ =
开发中的关系运算符:
> < >= <= != ==
关系运算符判断表达式两边的数据是否满足关系运算符要求，如果满足返回true，不满足返回false
/* 关系运算符演示 */
class Demo4 {
public static void main(String[] args) {
boolean ret = 5 > 3;
System.out.println("ret : " + ret);
ret = 5 < 3;
System.out.println("ret : " + ret);
ret = 5 >= 5;
System.out.println("ret : " + ret);
ret = 5 <= 10;
System.out.println("ret : " + ret);
ret = 5 != 5;
System.out.println("ret : " + ret);
ret = 5 == 5;
System.out.println("ret : " + ret);
}
}
补充：
Java的Math类封装了很多与数学有关的属性和方法。 例如: 幂运算等
2.4 逻辑运算符
与
&&
同真为真，有假【即】假
银行保险柜 需要保险柜持有者和管理员同时在场 才可以打开
或
||
有真【即】真，同假为假
自己家门，只要有人带有钥匙，就可以回家
非
!
取反
/* 逻辑运算符 */
class Demo5 {
public static void main(String[] args) {
boolean ret = 5 > 3 && 5 > 2;
System.out.println("ret : " + ret);
ret = 5 > 10 && 5 > 2;
System.out.println("ret : " + ret);
ret = 5 > 20 || 5 > 2;
System.out.println("ret : " + ret);
ret = 5 > 20 || 5 > 30;
System.out.println("ret : " + ret);
ret = !(5 > 3);
System.out.println("ret : " + ret);
ret = !(5 < 3);
System.out.println("ret : " + ret);
}
}
**位运算：>> --> /2， 相当于除二 << --> *2 ,相当于乘二 **
2.5 计算时内存溢出
int a = 10_0000_0000; // jdk7新特性数字可以加下划线表示
int b = 30;
int total = a * b; // 内存溢出
long total1 = a * b;
System.out.println(total); // 结果 -64771072
System.out.println(total1); // 结果 -64771072 a,b 类型都为int，计算后还为int类型，转换之前已经存在问题
long total2 = a *(long)b;
long total3 = (long)a * b;
System.out.println(total2); // 结果为 30000000000
System.out.println(total3); // 结果为 30000000000
2.6 小练习
条件完成
1. 字符类型变量是否英文字符
char ch;
'A' <= ch <= 'Z' 开发中无法使用
ch >= 'A' && ch <= 'Z' 大写字母条件
ch >= 'a' && ch <= 'z' 小写字母条件
(ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')
2. 字符类型变量是否是数字字符
char ch
ch >= '0' && ch <= 9
3. 闰年条件
能被4整数，但是不能被100整除，或者能被400整除
int year
year % 4 == 0;
year % 100 != 0
year % 400 == 0
(year % 4 == 0 && year % 100 != 0) || year % 400 == 0
4.
int num = 5;
boolean ret = 10 < 5 && ++num > 2;
ret = ?
num = ?
5.
int num = 5;
boolean ret = 10 > 5 || ++num > 2;
ret = ?
num = ?
2.6 短路原则
int num = 5;
boolean ret = 10 < 5 && ++num > 2;
ret = false
num = 5
同真为真，有假【即】假
逻辑与短路原则:
10 < 5 && ++num > 2;
10 < 5 不成立，为false，当前整个逻辑与表达式结果已经明确为false。计算机为了节约系统资源，提供运行效率，从false条件开始，之后的表达式都不在运行。++num > 2是没有执行的，无效代码。
int num = 5;
boolean ret = 10 > 5 || ++num > 2;
ret = true
num = 5
有真【即】真，同假为假
逻辑或短路原则:
10 > 5 || ++num > 2;
10 > 5 成立，为true，当前整个逻辑或表达式结果明确为true，从true条件开始，之后的内容不再执行。++num > 2没有执行，无效代码。