目录
- 表达式
- 数据类型转换
- 自动转换
- 强制转换
- 运算符
- 数学运算符
- 自增自减运算符
- i++与 ++i的区别
- 赋值运算符
- 比较运算符
- 位运算符(了解)
- 逻辑运算符
- 三目运算符
表达式
/**
* 表达式定义：由常量 变量 运算符 括号组成的算式，为了按照一定的运算规则计算出结果值
* 括号能提高运算的优先级
* 1.表达式结果可使用变量接收后用变量打印，也可使用表达式直接打印
* 2.只要表达式中有一个是字符串结果就都是用字符串类型接收
*/
public class BDSDemo {
public static void main(String[] args) {
int a = 25;
boolean b = true;
// 表达式结果可直接打印
System.out.println(a + 69 + "你们好" + b + (36 + 45));
// 只要表达式中有一个是字符串结果就都是用字符串类型接收
String s1 = a + 69 + "你们好" + b + (36 + 45);
String s2 = a + 69 + "25" + b + (36 + 45);
}
}
数据类型转换
类型转换定义：从一种数据类型转换为另外一种类型
作用：1.节约内存空间；2.转换成项目所需要的类型
基本数据类型排序
(boolean)、byte、char、short、int、long、float、double
char 只有正数范围 [0，2^16-1]
自动转换
/**
* 自动转换：从小的类型转换大的类型
* 1.布尔类型不参与转换
* 2.byte与char之间不能自动转换，因为char只有正数范围
* char与short之间不能自动转换，因为char正数范围比short大
*/
public class TypeTransform {
public static void main(String[] args) {
//1.如果运算式中元素类型分别属于（byte，short，char，int），那么运算前所有元素类型都将会自动转换为int类型再运算，结果也为int（自动向上转型）
byte b = 25;
short s = 26;
char c = 'A';
int i = b+s+c+69;
System.out.println("i: "+i);
byte b1 = 23;
int r = b+b1;
//2.long float double只要两个操作数中有一个为以上类型，另一个就会被转换成表达式中最大类型，并且结果也为该类型
long x = 36L;
float y = 20.0F;
float d = x+y;
double t = x+y+3.14;
float t1 = x+y+3.14F;
double t2 = 69+x+y+b+c+s+2.0;
//3.char类型向更高长度类型（例如整型）转换时，会转换为对应的ASCII码值，再做其他类型的自动转换
char c1 = 'A';
int t3 = c1+35;//根据ASCII码值为65 提升为int类型
System.out.println("t3: "+t3);
//特例 从大到小（要在小的类型范围中）
byte b2 = 36;
short s1 = 5798;
}
}
强制转换
/**
* 强制转换：从大的类型转换成小的类型 （是为了转换成自己或者项目所需要的的类型）
* 语法：强转类型 变量名 = (强转类型)(值或者表达式)
* 注意：都是已知转换不会出问题，如果是未知的强制转换就有可能出现精度损失
*/
public class TypeTransform2 {
public static void main(String[] args) {
byte b1 = 120;
byte b2 = 3;
//正常强制转换
byte x1 = (byte)(b1+b2);
System.out.println("x1: "+x1);
byte b3 = 120;
byte b4 = 30;
//出现精度损失的强制转换
byte x2 = (byte)(b3+b4);
System.out.println("x2: "+x2);
//byte与char不能自动转换 但是可以强转
char c = 65;
byte b5 = (byte)c;
int i1 = 123;
int i2 = 456;
//注意强转的时候强转的部分是否为一个整体
float d = (float)((i1 + i2) * 1.2);
}
}
运算符
数学运算符
/**
* 数学运算符：+(加) -(减) *(乘法) /(除法) %(取模 求余数)
* 作用于常量或者变量
*/
public class _04MathSignDemo {
public static void main(String[] args) {
//加法
System.out.println(2+50.0);
//减法
System.out.println(2-1);
//乘法
System.out.println(2*2);
//除法
System.out.println(2/2);
//System.out.println(1/0); //编译只看类型 不会进行运算 所以编译不会报错 运行会报错 因为0不能作为分母
System.out.println(1.0/0); //Infinity 0先提升为double类型 double类无限趋近于这个数字
System.out.println(0.0/0); //NaN 等同于无线趋近于0乘以无限大 not a number 不是一个数
System.out.println(10/3); //3 因为两个都是整数类型 结果也为整数类型 不会保留小数位
//取模
System.out.println(5%2); //1
}
}
自增自减运算符
/**
* 自增运算符：++，只能作用于变量，使变量的值自动增加1
* 自减运算符：--，只能作用于变量，使变量的值自动减少1
*/
public class _05AutoIncreDemo {
public static void main(String[] args) {
int i = 2;
i++;
System.out.println(i); //3
int j = 2;
++j;
System.out.println(j); //3
int x = 5;
x--;
System.out.println(x); //4
System.out.println(--x);//3
}
}
i++与 ++i的区别
/**
* 自增运算符：++，只能作用于变量，使变量的值自动增加1
* i++与 ++i的区别：
* i++和++i本身是一个表达式，也具有值
* 结论：
* i++表达式的值等于i自增之前的值，i本身的值也会+1
* ++i表达式的值等于i自增之后的值，i本身的值也会+1
* 使用的时候 需要注意 到底是使用的是变量的值 还是自增表达式的值
*/
public class _06AutoIncreDemo2 {
public static void main(String[] args) {
int i = 2;
System.out.println(i++); // 2
System.out.println("i=" + i);
int j = 2;
System.out.println(++j); // 3
System.out.println("j=" + j);
}
}
public class Practice {
public static void main(String[] args) {
int i = 3;
int a = i++ + i++ + i++;
// 3 4 5 i=6
int b = ++i + ++i + ++i;
// 7 8 9 i=9
System.out.println(i); //9
System.out.println( a); //12
System.out.println( b); //24
}
}
+号的特殊使用:
1.基本数据类型之间使用+号
全部进行加法运算
2.基本数据类型和引用数据类型之间使用+号
2.1如果基本数据类型先使用+号，那么进行加法运算，然后使用+号和字符串进行拼接
2.2如果字符串和字符之间使用+号，那么字符不会转换成对应的数值，直接进行拼接
3.引用数据类型和引用数据类型之间使用+号
全部进行拼接
如果字符串在最前面,那么后面的全部进行拼接
自增自减运算符符号： ++ --
注意: 自增自减只能够用于变量，不能用于常量
自增自减运算的优先级比算术运算符高
要点: 把整个表达式看成是一个整体。
如果符号在变量名后面，那么整个表达式的值就是原来值不变。
如果符号在变量名前面，那么整个表达式的值就是原来的值加1。
赋值运算符
/**
* 赋值运算：从右往左
* = += -= *= /= %=
* += -= *= /= %= 会存在隐式的自动类型转换
*/
public class _08FZSignDemo {
public static void main(String[] args) {
int x = 6;
x += 5; //可以理解为x=x+5;
System.out.println("x: "+x); //11
x -= 6; //可以理解成x=x-6;
System.out.println("x: "+x); //5
byte b1 = 2, b2 = 3;
b1 = (byte) (b1 + b2);
System.out.println(b1);
b1 += b2; //可以理解成为： b1=b1+b2，有一个隐式的自动类型转换
}
}
比较运算符
/**
* 比较运算符
* ==(相等) !=(不等) > < >= <=
* 用来两个常量或者变量或者两个表达式之间的比较
* 比较运算的结果为布尔类型
*/
public class _09CompareDemo {
public static void main(String[] args) {
System.out.println(5>3);//true
int a = 5 ,b = 6;
System.out.println(a!=b);//true
System.out.println(a++>b++);//false
System.out.println(a==b);//false
}
}
位运算符(了解)
/**
* 位运算符(了解)
* 主要用来进行二进制的运算，进行位运算之前，首先需要将数据转换为二进制以后再进行运算
1. & : 与 位运算，两边为1，结果为1，不同时为1，则结果为0
2. | : 或 位运算，有一个为1，结果为1
3. ^ : 异或，两边不一样，就为1，否则为0
4. ~ : 取反，1变成0，0 变成1 ~（-5）结果4
5. <<：向左位移动，例如1<<3， 结果8
6. >>：向右位移动，例如8>>2
7. >>>：无符号向右移动
*/
public class _10BinSignDemo {
public static void main(String[] args) {
//&：先转为二进制去算，同时为1则为1，其他都为0
System.out.println(2&3); //结果为二进制的10， 10进制就为2
/* 10
* 11
* ----
* 10
* */
//|：有一个为1 则为1
System.out.println(2|3); //11=1*2^1+1*2^0=1+2=3
//^：两边不一样才为1
System.out.println(2^3); //01 -->1
//<<：往左移动3位，补0
System.out.println(1<<3); //1000=1*2^3=8
//>>：往右移动3位
System.out.println(8>>3); //1
}
}
逻辑运算符
/**
* 逻辑运算符:
* 用来连接两个布尔类型的值或者表达式，运算的最终结果也为布尔类型
* &：与 两个表达式同时为true，则结果为true，否则结果为false
* |：或 只要有一个为true，则逻辑运算结果为true
* !: 取反
* ^：亦或 必须两个不同的时候 逻辑运算才true
* &&：短路与 两个表达式同时为true，则结果为true，第一个为false后面的就不用运行
* ||：短路或 只要有一个为true，逻辑运算结果为true，第一个为true后面的就不用运行
*/
public class _11LogicDemo {
public static void main(String[] args) {
System.out.println(true&true); //true
System.out.println(true&false); //false
System.out.println(true|false); //true
System.out.println(false|false);//false
System.out.println(!true); //false
System.out.println(true^false); //true
System.out.println(false^false);//false
System.out.println(true^true); //false
System.out.println(true&&true); //true
System.out.println(true&&false);//false
System.out.println(true||true); //true
System.out.println(true||false);//true
}
}
/**
* && 和 & 区别?
* &不具有短路功能，当第一部分为false的时候， 依然会执行第二部分的代码
* &&具有短路功能，当第一部分为false的时候，不会执行第二部分
* | 和 || 区别?
* |不具有短路功能,当第一部分为true时，依然会执行第二部分
* ||具有短路功能，当第一部分为true时，不会执行第二部分
*/
public class _12LogicDemo2 {
public static void main(String[] args) {
int x = 5;
System.out.println(3>5 & x++>6); //false
System.out.println(x); //6
int y = 5;
System.out.println(3>5 && y++>6); //false
System.out.println(y); //5
int i = 4;
System.out.println(5>3|i++>2); //true
System.out.println(i); //5
int j = 4;
System.out.println(5>3||j++>2); //true
System.out.println(j); //4
}
}
三目运算符
/**
* 三目运算符：由?和:分隔的三个表达式
* 语法：x?y:z， x:布尔类型的值或者表达式， y和z，一般来说为同种类型的变量 常量或者表达式
* 运算流程：当x为true的时候，三目运算的结果为y，否则为z
*/
public class _13ThreeEyesDemo {
public static void main(String[] args) {
// 三目运算
String s = false ? "真的" : "假的";
System.out.println(s);
// 不能使用变量接收 因为编译只看类型 不会运算
System.out.println(false ? "真的" : 4);
// 求出a和b两个整数中最大的整数
int a = 69, b = 138;
System.out.println(a > b ? a : b);
// 求出 a,b,c 三个数中最小的数字
// 两两比较 先找出两者中最小的 再将结果和第三个进行比较
int x = 9, y = -6, z = -1;
int t = x < y ? x : y;
int min = t < z ? t : z;
System.out.println(min);
// 例如小明学习java 考试成绩 >=60 显示 非常优秀 否则输出 还有很大的提升空间。
// 定义一个变量 用来存放小明成绩
int score = 99;
String s2 = score >= 60 ? "非常优秀" : "还有很大提升空间";
System.out.println(s2);
// 等级分 A B C D ,也是通过三目运算写出结果
/*
* 90~100 A score>=90&&score<=100
* 80~90 B score>=80&&score<90
* 70~80 C score>=70&&score<80
* 60~70 D score>=60&&score<70
*/
// 三木运算嵌套
String s3 = score >= 90 && score <= 100 ? "A" : (score >= 80 && score < 90 ? "B" : (score >= 70 && score < 80 ? "C" : "D"));
System.out.println(s3);
}
}
![[面向对象] 单例模式与工厂模式](https://img-blog.csdnimg.cn/direct/352b6cb15acc44ae9666f88bd114a515.png)
![[尚硅谷 flink] 状态管理 笔记](https://img-blog.csdnimg.cn/img_convert/d883d470817071d4000cfaf1f1c6ed0f.png)
