02--Java数据类型和运算符
1、数据类型
作用:用于定义变量的,然后约束变量只能存储什么类型的数据。
1.1 基本数据类型
注意:
a.随便写整数,默认是int类型,要当成long 加L l。
b.随便写小数,默认是double类型,要当成float 加F f。
1.1.1 整型
// 1、byte字节型 占1个字节 -128 - 127
byte number = 98;
System.out.println(number);
// byte number2 = 128; // 报错!
// 2、short短整型 占2个字节
short money = 30000;
System.out.println(money);
// 3、int 整型 默认的类型 占4个字节(默认使用的类型)
int it = 232442442;
System.out.println(it);
// 4、long长整型 占8个字节
long lg = 133244244;
// 注意:随便写一个整数字面量默认是int类型的,
// 133244244虽然没有超过long的范围,但是它超过了本身int类型的表示范围。
// 如果希望随便写一个整数字面量当成long类型,需要在其后加L/l
long lg2 = 132223243244244L;
System.out.println(it);
1.1.2 浮点型
// 1、浮点型(小数)
// float单精度 占4个字节
// 注意:随便写一个小数字面量默认是double类型,
// 如果希望随便写一个小数字面量是float类型的需要在其后加上 F / f
float score = 98.5F;
System.out.println(score);
// 2、double双精度 占8个字节
double score2 = 999.99;
System.out.println(score2);
1.1.3 字符类型
// 字符类型:char
char ch = 'a';
// char ch = '中国'; //报错
// 1.''内有且仅有一个字符
char ch1 = '中';
// 2.unicode值 为16进制数字
char ch2 = '\u0036';
// 3.转义字符 \t \n
char ch3 = '\n'
// 4.数字 转成ASCII值 A 65 a 97 差值32
char ch4 = 97;
1.1.4 布尔类型
// 布尔类型 boolean
boolean rs = true;
boolean rs2 = false;
1.2 引用数据类型
引用数据类型:不是基本数据类型的就是引用数据类型,例如类Class(String)、数组Array、接口Interface、枚举Enum、注解Annotation、记录Record
1.3 类型转换
1.3.1 自动类型转换
为什么自动类型转换? 存在小范围类型的变量赋值给大范围类型的变量。
基本语法规则 小范围类型的变量可以直接赋值给大范围类型的变量。
范围规则:
public class TypeDemo1 {
public static void main(String[] args) {
byte a = 20;
int b = a; // 发生了自动类型转换
System.out.println(a);
System.out.println(b);
int age = 23;
double db = age; // 自动类型转换
System.out.println(db);
char ch = 'a'; // 00000000 01100001
int code = ch; // 00000000 00000000 00000000 01100001
System.out.println(code);
}
}
1.3.2 表达式的自动类型转换
规则:
- 表达式的最终结果类型是由表达式中的最高类型决定的。
- byte、short、char直接提升成int运算的。
public class TypeDemo2 {
public static void main(String[] args) {
byte a = 10;
int b = 20;
double c = 1.0;
double rs = a + b + c;
System.out.println(rs);
double rs2 = a + b - 2.3;
System.out.println(rs2);
byte i = 100;
byte j = 120;
int k = i + j;
System.out.println(k);
}
}
1.3.3 强制类型转换
形式:大范围类型的变量赋值给小范围类型的变量会出现错误,需要强制类型转换。
格式:数据类型 变量2 = (数据类型)变量1
注意事项:
a.强制类型转换可能出现数据丢失。
int i = 2223;
byte j = (byte)i;
b.小数强制转换成整数,会截断小数部分,直接返回整数.
public class TypeDemo3 {
public static void main(String[] args) {
double num = 23.45;
int i = (int)num;
int a = 20;
byte b = (byte)a;
System.out.println(a);
System.out.println(b);
int i = 1500;
byte j = (byte) i;
System.out.println(j);
double score = 99.5;
int it = (int) score;
System.out.println(it); // 99
}
}
2、常量
2.1 字面量
字面量:可以直接看到的数据,整数、小数、字符(必须用单引号围起来,有且仅能包含一个字符,特殊字符’\t’、‘\n’)、字符串(必须用双引号围起来,内容可以随意)、布尔型(false、true)、空(null)
字符、字符串的字面量的格式要求?
字符必须单引号围起来,有且仅能一个字符。
字符串必须用双引号围起来。
布尔类型只有2个值:false 、true
public class LiteralDemo {
public static void main(String[] args) {
// 1、整数
System.out.println(66);
System.out.println(-23);
// 2、小数
System.out.println(99.5);
// 3、字符:必须单引号围起来,有且仅能有一个字符
System.out.println('中');
System.out.println('0');
System.out.println('\n'); // \n换行
System.out.println('\t'); // \t空格
System.out.println('a');
// 4、字符串:必须双引号围起来,内容可以随意
System.out.println("");
System.out.println("我爱你中国!abc");
System.out.println(" 学习Java使我快乐!~~~");
// 5、布尔类型:true false
System.out.println(true);
System.out.println(false);
// 6、空类型 null (以后再详细说明!)
}
}
2.2 final修饰
被final修饰的常量不能被修改,不能被重新赋值。一旦赋值,不能被修改。
// 定义一个final修饰的常量
final double PI = 3.14;
final int STUDENT_NUMBER = 40;
3、运算符
3.1 算术运算符
常用算术运算符:+ - * / %
注:做除法,如果都是整数,结果一定是整数
取模后,结果与被取模的符号相同。
public class OperatorDemo1 {
public static void main(String[] args) {
// 算术算术运算符的使用:+ - * / %
int a = 10;
int b = 3;
System.out.println(a + b); // 13
System.out.println(a - b); // 7
System.out.println(a * b); // 30
System.out.println(a / b); // 3.3333 ==> 3
System.out.println(a * 1.0 / b); // 3.3333
System.out.println(3 / 2); // 1
System.out.println(3 * 1.0 / 2); // 1.5
System.out.println(3 / 2 * 1.0); // 1.0
System.out.println(a % b); // 1
System.out.println(-15 % 2); // -1
System.out.println(15 % 2); // 1
}
}
3.2 赋值运算符
常用赋值运算符:= += -= *= /= %=
从右往左执行。
a += b 等价于 a = (a的类型)(a + b),扩展运算符自带了强制类型转换。
public class OperatorDemo2 {
public static void main(String[] args) {
// 赋值运算符:= += -= *= /= %=
int a = 10;
int b = 200;
// a = a + b;
a += b; // a = (int)(a + b)
System.out.println(a);
byte i = 10;
byte j = 20;
// i = (byte) (i + j);
i += j; // i = (byte) (i + j);
System.out.println(i);
int m = 10;
int n = 5;
// m += n;
// m -= n; // 等价于: m = (int)(m - n)
// m *= n; // 等价于: m = (int)(m * n)
// m /= n; // 等价于: m = (int)(m / n)
m %= n; // 等价于: m = (int)(m % n)
System.out.println(m);
}
}
3.3 自增自减运算符
++ --
注:在变量前后单独使用的情况,无区别,a++、++a
++,–如果在变量前后使用,并且包含其他操作,赋值或者在表达式中,放在前后有明显区别。
在变量前面:先加减再使用,在变量后面:先使用再加减。
public class OperatorDemo3 {
public static void main(String[] args) {
// 自增自减运算符: ++ --
int a = 10;
// a++; // a = a + 1
++a; // a = a + 1
System.out.println(a); // 11
int b = 10;
//b--; // b = b -1
--b;
System.out.println(b);
System.out.println("------------------------------");
// 在表达式中或者不是单独操作的情况,++ -- 在变量前后存在区别
// ++ -- 在变量前面。先+1 -1 再使用。
int i = 10;
int j = ++i;
System.out.println(i); // 11
System.out.println(j); // 11
// ++ -- 在变量的后面 先使用再+1 -1
int m = 10;
int n = m++;
System.out.println(m); // 11
System.out.println(n); // 10
System.out.println("-----------拓展案例(可以了解和参考)--------------");
int k = 3;
int p = 5;
// k 3 4 5 4
// p 5 4 3 4
// rs 3 + 5 - 4 + 4 - 5 + 4 + 2
int rs = k++ + ++k - --p + p-- - k-- + ++p + 2;
System.out.println(k); // 4
System.out.println(p); // 4
System.out.println(rs); // 9
}
}
3.4 比较运算符
== != < <= > >=
返回的结果是布尔类型
public class OperatorDemo4 {
public static void main(String[] args) {
// 关系运算符。
int i = 10;
int j = 5;
System.out.println(i == j); // false
System.out.println(i != j); // true
System.out.println(i > j); // true
System.out.println(i >= j); // true
System.out.println(i < j); // false
System.out.println(i <= j); // false
}
}
3.5 逻辑运算符
& && | || ! ^
public class OperatorDemo5 {
public static void main(String[] args) {
// 逻辑运算符
double size = 9.8;
double storage = 6;
// 需求:尺寸大于等于6.95 内存要大于等于8GB
// 注意:必须前后都是true结果才是true
System.out.println(size >= 6.95 & storage >=8);
// 需求:要么内存大于等于8 要么尺寸大于等于6.95
// 注意:只要有一个是true 结果就一定是true
System.out.println(size >= 6.95 | storage >=8);
System.out.println(!true);
System.out.println(!false);
// 逻辑异或:必须两个不同结果才是true
System.out.println(false ^ true); // true
System.out.println(true ^ false); // true
System.out.println(true ^ true); // false
System.out.println(false ^ false); // false
System.out.println("-----------&& & || |的区别-------------------");
int a = 10;
int b = 20;
// System.out.println(a > 100 && ++b > 10);
System.out.println(a > 100 & ++b > 10);
System.out.println(b);
int i = 10;
int j = 20;
//System.out.println(i > 2 || ++j > 10);
System.out.println(i > 2 | ++j > 10);
System.out.println(j);
}
}
3.6 三元运算符
作用:根据条件作出分支选择,返回对应的值。
格式:条件表达式?值1 :值2
public class OperatorDemo6 {
public static void main(String[] args) {
// 三元运算符
double score = 18;
String rs = score >= 60 ? "考试通过" : "挂科";
System.out.println(rs);
// 需求:需要从2个整数中找出较大值
int a = 10000;
int b = 2000;
int max = a > b ? a : b;
System.out.println(max);
System.out.println("-------------------------");
int i = 10;
int j = 30;
int k = 50;
// 1、找出2个整数的较大值
int temp = i > j ? i : j;
// 2、拿临时变量与第三个变量的值继续比较
int rsMax = temp > k ? temp : k;
System.out.println(rsMax);
System.out.println("-------------拓展知识-------------");
int rsMax1 = i > j ? (i > k ? i : k) : (j > k ? j : k);
System.out.println(rsMax1);
}
}
3.7 String字符串操作
+号与字符串一起会做连接符,连接后的结果还是字符串。
注:能算则算,不能算就在一起
String可以使用的操作有+、+=、==、!=
public class OperatorDemo7 {
public static void main(String[] args) {
// +符号做连接符的识别
int a = 5 ;
System.out.println("abc" + 'a'); // abca
System.out.println("abc" + a); // abc5
System.out.println(5 + a); // 10
System.out.println("abc" + 5 + 'a'); // abc5a
System.out.println(15 + "abc" + 15); // 15abc15
System.out.println(a + 'a'); // 102 a转成数字为97
System.out.println(a + "" +'a'); // 5a
System.out.println(a + 'a'+" itheima "); // 102 itheima
System.out.println("itheima"+ a + 'a'); // itheima5a
System.out.println("itheima"+ ( a + 'a' ));// itheima102
}
}
3.8 运算符优先级
最高优先级是()
public class OperatorDemo8 {
public static void main(String[] args) {
// 目标:优先级问题
System.out.println(10 > 3 || 10 > 3 && 10 < 3); //true
System.out.println( (10 > 3 || 10 > 3 ) && 10 < 3); // false
}
}
4、进制转换
class BinaryTest {
public static void main(String[] args) {
int num1 = 123; //十进制
int num2 = 0b101; //二进制
int num3 = 0127; //八进制
int num4 = 0x12aF; //十六进制
System.out.println(num1); // 123
System.out.println(num2); // 5
System.out.println(num3); // 87
System.out.println(num4); // 4783
}
}