【Java学习】004_变量&数据类型&数据类型转换&ASCII编码&运算符
一、变量
什么是变量？
在一定范围内，可以发生变化的量变量的定义格式：
格式一：（直接定义）
数据类型 变量名 = 数据;
int a = 12;
格式二：（间接定义）
数据类型 变量名;
变量名 = 数据;
int i;
i = 12;二、数据类型
Java中数据类型的分类：
2大类4小类8小种基本数据类型：4类8种
整型：
byte（1个字节）
short（2个字节）
int（4个字节）
long（8个字节）
一个整数，默认的数据类型是int
浮点型：
float（4个字节）
double（8个字节）
字符型：
char（2个字节）
布尔型：
boolean（1个字节）
输入：
package com;
public class demo01 {
public static void main(String[] args) {
// 定义一个byte类型的变量
byte a = 12;
System.out.println(a);
// 定义一个short类型的变量
short b;
b = 13;
System.out.println(b);
// 定义一个int类型的变量
int c = 1;
System.out.println(c);
// 定义一个long类型的变量
long d = 2;
System.out.println(d);
// 定义一个float类型的变量
float e = 3.14f; // 需要加个大写或小写的F
System.out.println(e);
// 定义一个double类型的变量
double f = 3.14;
System.out.println(f);
// 定义一个char类型的变量
char g = 'a';
System.out.println(g);
//定义一个boolean类型的变量
boolean h = true;
System.out.println(h);
boolean i = false;
System.out.println(i);
// 定义两个int类型的变量
int j = 1;
int k = 2;
int l = 1, m = 2;
int n,o;
n = 1;
o = 2;
}
}
输出：
12
13
1
2
3.14
3.14
a
true
false注：在使用变量的时候需要注意的问题
1. 当我们给float类型变量赋值的时候，要在数据的后面加上F或f
2. 当我们给long类型变量赋值的时候，建议在后面加上L或l
3. 当我们想要使用某个变量的时候，一定要先赋值，再使用，否则会报错
4. 当我们想要给某个变量赋值的时候，要考虑该变量的范围，否则会报错
5. 在同一对花括号内，不能定义同名变量引用数据类型：（后面介绍）
三、数据类型的转换
隐式类型转换
什么是隐式类型转换？
就是指小的数据类型会自动提升为大的数据类型
byte b = 1;
short s = 2;
int i = 3;
long l = 4;
float f = 3.14f;
double d = 3.15;
double dd = b + s + i + l + d;
当多个数据类型参与运算的时候，小的数据类型会自动提升为大的数据类型注：boolean类型不能和其他数据类型相互转换
byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;
System.out.println(b3); // 编译报错
byte b1 = 1;
byte b2 = b1 + 2;
System.out.println(b2); // 编译报错
// 结论：针对byte和short类型的时候，只有右边有一个是变量，就会编译报错
byte b4 = 126 + 1;
System.out.println(b4); // 正确
byte b5 = 127 + 1;
System.out.println(b5); // 报错强制类型转换
什么是强制类型转换？
是指大的数据类型被强制转换成小的数据类型
强制类型转换的格式：
小的数据类型 小的数据类型的变量名 = (小的数据类型)大的数据类型的变量名;
eg:
int i = 110;
byte b = (byte)i注：能不使用强制转换，尽量不要使用，因为转不好会出现问题
int i = 130;
byte b = (byte)i;
System.out.println(b); // -126
四、ASCII编码表
'a' --> 97，b、c、d、……累加
'A' --> 65，B、C、D、……累加
'0' --> 32，1、2、3、……累加
char c = 'a';
int i = 1;
int a = i + c;
System.out.println(a); // 98 ----> 'a' >>>97
System.out.println(' ' + 0); // 32 ----> ' ' >>>32
System.out.println('0' + 0); // 48 ---> '0' >>>48
五、运算符
算数运算符
+
在Java中的含义：
1. 加减乘除的加
2. 正负的正
3. 连接符
任意数据类型的数据与字符串相连接的时候，那个+号就是连接符
System.out.println(1 + "abc"); // "1abc"
System.out.println("abc" + 1); // "abc1"
System.out.println(true + "abc"); // "trueabc"
System.out.println('a' + "abc"); // "aabc"
int i = 1;
int j = 2;
System.out.println(i + "abc" + j); // "1abc" + j ---> "1abc2"
// 已知有两个变量a和b，值分别为1和2，输出 a + b = 3，1 + 2 = 3
int a = 1;
int b = 2;
System.out.println("a + b = " + (a + b)); // a + b = 3
System.out.println(a + " + " + b + " = " + (a + b)); // 1 + 2 = 3
-
*
/
整数除以整数，结果仍是整数
int i1 = 5;
int j1 = 2;
int a1 = i1 / j1;
System.out.println(a1); // 2
int i2 = 5;
int j2 = 2;
double a2 = i2 / j2;
System.out.println(a2); // 2.0
int i3 = 5;
double j3 = 2;
double a3 = i3 / j3;
System.out.println(a3); // 2.5
%
取余
int i = 3;
int j = 2;
int k = 1;
System.out.println(i % j); // 1
System.out.println(j % i); // 2
System.out.println(i % k); // 0
++
单独使用：
int i1 = 1;
int i2= 1;
int j1 = 2;
int j2 = 2;
i1++;
++i2;
j1++;
++j2;
System.out.println(i1); // 2
System.out.println(i2); // 2
System.out.println(j1); // 3
System.out.println(j2); // 3
不管++是在前还是在后，结果都是加1
参与运算：
++在前：先自身加1，然后再参与运算
int i = 1;
int j = ++i;
System.out.println(i); // 2
System.out.println(j); // 2
++在后，先参与运算，然后再自身加1
int i = 1;
int j = i++;
System.out.println(j); // 1
System.out.println(i); // 2
注：
byte b = 1;
b = b + 1;
System.out.println(b); // 报错
byte b = 1;
b++; // b = (byte)(b + 1); ++自身带有强制转换
System.out.println(b); // 2
--
单独使用：
int i1 = 1;
int i2= 1;
int j1 = 2;
int j2 = 2;
i1--;
--i2;
j1--;
--j2;
System.out.println(i1); // 0
System.out.println(i2); // 0
System.out.println(j1); // 1
System.out.println(j2); // 1
不管--是在前还是在后，结果都是减1
参与运算：
--在前：先自身减1，然后再参与运算
int i = 1;
int j = --i;
System.out.println(i); // 0
System.out.println(j); // 0
--在后，先参与运算，然后再自身减1
int i = 1;
int j = i--;
System.out.println(j); // 1
System.out.println(i); // 0
int i = 10;
int j = i++ + ++i + i-- + --i;
// int a = i++; // a=10, i=11
// int b = ++i; // i=12, b=12
// int c = i--; // c=12, i=11
// int d = --i; // i=10, d=10
// int j = a + b + c + d; // j = 10 + 12 + 12 + 10 = 44
System.out.println(j); // 44赋值运算符
=
+=
int i = 1;
i += 2;
System.out.println(i); // 3
-=
int i = 1;
i -= 2;
System.out.println(i); // -1
*=
int i = 2;
i *= 3;
System.out.println(i); // 6
/=
int i = 8;
i /= 2;
System.out.println(i); // 4
%=
int i = 8;
i %= 3;
System.out.println(i); // 2注：++，–，+=，-=，*=，/=，%= 都自带了强制类型转换
关系运算符
关系运算符输出的结果一定是boolean类型，也就是说要么是true，要么是false
>
<
>=
<=
!=
==逻辑运算
左右两边的数据的数据类型都是boolean类型，结果也是boolean类型
&（单与）：两边只要有一个是false，结果就为false
System.out.println(true & true); // true
System.out.println(true & false); // false
System.out.println(false & false); // false
System.out.println(false & true); // false
|（单或）：两边只要有一个是true，结果就为true
System.out.println(true | true); // true
System.out.println(true | false); // true
System.out.println(false | false); // false
System.out.println(false | true); // true
^（异或）：两边相同为false，两边不同为true
System.out.println(true ^ true); // false
System.out.println(true ^ false); // true
System.out.println(false ^ false); // false
System.out.println(false ^ true); // true
!（非）：
System.out.println(!true); // false
System.out.println(!false); // true
System.out.println(!!true); // true
System.out.println(!!!true); // false
&&（双与）：同&（单与）：两边只要有一个是false，结果就为false
System.out.println(true && true); // true
System.out.println(true && false); // false
System.out.println(false && false); // false
System.out.println(false && true); // false
||（双或）：同|（单或）：两边只要有一个是true，结果就为true
System.out.println(true || true); // true
System.out.println(true || false); // true
System.out.println(false || false); // false
System.out.println(false || true); // true&和&&的区别，|和||的区别
&&：如果左边为false，右边就不再执行了，结果就为false
&：如果左边为false，右边依然会执行，结果就为false
||：如果左边为true，右边就不再执行了，结果就为true
|：如果左边为true，右边依然会执行，结果就为false
推荐使用&&和||，提高执行效率位运算符
左右两边的数据都是数字，结果也为数字
&（与位运算）：
System.out.println(3 & 2); // 2
|（或位运算）：
System.out.println(3 | 2); // 3
^（异或位运算）：
System.out.println(3 ^ 2); // 1
// 实现i和j的调换
int i = 1;
int j = 2;
System.out.println(i + "..." + j); // 1...2
// 方法一：
int temp = i;
i = j;
j = temp;
System.out.println(i + "..." + j); // 2...1
// 方法二：
i = i ^ j;
j = i ^ j;
i = i ^ j;
System.out.println(i + "..." + j); // 2...1
~（按位取反）：
>>（右移位运算）：
System.out.println(3 >> 2); // 0
<<（左移位运算）：
System.out.println(3 << 2); // 12
>>>（无符号右移）：
System.out.println(3 >>> 2); // 0
三元运算符
三元运算符，也称条件运算符、三目运算符
格式：条件表达式 ？表达式1 : 表达式2;
执行流程：
如果条件表达式为true，就会执行表达式1，不会执行表达式2
如果条件表达式为false，就会执行表达式2，不会执行表达式1
public class demo09 {
public static void main(String[] args) {
// 获取两个数的最大值
int i = 2;
int j = 3;
int max = i > j ? i : j;
System.out.println(max); // 3
System.out.println(i > j ? i : j); // 3
}
}注意事项：
- 三元运算符是一个运算符，既然是一个运算符，就一定会有一个结果，所以表达式1和表达式2都会得到一个结果，所以表达式1和表达式2中不能是输出语句：
3 > 2 ? System.out.println(“hehe”) : System.out.println(“haha”); // 格式错误- 表达式1和表达式2既然会得到一个结果，如果传递给一个变量去接收，该变量的数据类型应该和表达式1和表达式2的结果的数据类型匹配：
double d = 3 > 2 ? 1 : 2;
System.out.println(d); // 1.0
——————————————
int c = 3 > 2 ? ‘a’ : ‘b’;
System.out.println(c); // 97
——————————————
char c1 = 3 > 2 ? 97 : 98;
System.out.println(c1); // a