一、基本数据类型的转换之特殊点
public class Test01{
/**
知识点：基本数据类型的转换 之 特殊点
特殊点一：
byte b1 = 1;//1为int类型的数字字面量，1在byte类型的取值范围内，就直接赋值
byte b2 = (byte)128;//128为int类型的数字字面量，128不在byte类型的取值范围内，就必须强转
//128 - int：0000,0000,0000,0000,0000,0000,1000,0000
//(byte)128：1000,0000
//注意：强制转型会把最左侧的位数给舍弃掉
System.out.println(b1);//1
System.out.println(b2);//-128
特殊点二：
//报错原因：12345678901为int类型的数字字面量，但是该数字已经超出了int类型的取值范围，就报错了
int i = 12345678901;
特殊点三：
//报错原因：12345678901为int类型的数字字面量，但是该数字已经超出了int类型的取值范围，就报错了
long l1 = 12345678901;
//不会报错的原因：12345678901L为long类型的数字字面量，该数字没有超过long类型的取值范围，所以就不会报错
long l2 = 12345678901L;
特殊点四：
float f1 = 1;//int->float 自动转型
//float f2 = 1.0;//double->float 强制转型
//解决方案一：内存从64位到32位
//float f2 = (float)1.0;
//解决方案二：内存直接开辟32位空间，效率更高
float f2 = 1.0F;
System.out.println(f1);
System.out.println(f2);
特殊点五：
char c = 'a';//UniCode -- 97
int i = c;
System.out.println(i);
特殊点六：
//注意：boolean不能与其他类型兼容
boolean bool = true;
int i = (int)bool;
*/
public static void main(String[] args){
}
}
二、算数运算符的使用
public class Test02{
/**
知识点：算数运算符的使用
符号：+、-、*、/、%、++、--
int num1 = 10;
int num2 = 5;
int result = num1 + num2;
System.out.println(result);//15
System.out.println(num1 - num2);//5
System.out.println(10 * 5);//50
System.out.println(10 / 5);//2
System.out.println(10 % 3);//1
//++：自增1
//++a：先自增1，再使用
int a = 10;
System.out.println(++a);//11
System.out.println(a);//11
//b++：先使用，再自增1
int b = 10;
System.out.println(b++);//10
System.out.println(b);//11
//--：自减1
//--c：先自减1，再使用
int c = 10;
System.out.println(--c);//9
System.out.println(c);//9
//d--：先使用，再自减1
int d = 10;
System.out.println(d--);//10
System.out.println(d);//9
*/
public static void main(String[] args){
}
}
三、算数运算符的深入
public class Test03{
/**
知识点：算数运算符的深入
符号：+、-、*、/、%、++、--
//特殊点一：byte类型做运算会向上转型成int类型，再做运算
//注意：向上转型是按照最高位补位
byte b1 = 10;
byte b2 = 20;
//b1 - byte：0000,1010
// int：0000,0000,0000,0000,0000,0000,0000,1010
//b2 - byte：0001,0100
// int：0000,0000,0000,0000,0000,0000,0001,0100
// 结果：0000,0000,0000,0000,0000,0000,0001,1110
// (byte)：0001,1110
byte result = (byte)(b1+b2);
System.out.println(result);
//特殊点二：short类型做运算会向上转型成int类型，再做运算
short s1 = 10;
short s2 = 20;
//s1 - short：0000,0000,0000,1010
// int：0000,0000,0000,0000,0000,0000,0000,1010
//s2 - short：0000,0000,0001,0100
// int：0000,0000,0000,0000,0000,0000,0001,0100
// 结果：0000,0000,0000,0000,0000,0000,0001,1110
// (short)：0000,0000,0001,1110
short result = (short)(s1+s2);
System.out.println(result);
//特殊点三：除了byte和short做运算会向上转型成int，其余的数值型按照取值范围大的类型转型
byte b = 10;
short s = 10;
int i = 10;
long l = 10;
float f = 10;
double d = 10;
System.out.println(b + s);//int
System.out.println(b + i);//int
System.out.println(s + i);//int
System.out.println(i + l);//long
System.out.println(i + f);//float
System.out.println(l + f);//float
System.out.println(f + d);//double
//特殊点四：浮点类型做运算有可能会损失精度，所以浮点类型不能直接做运算
float f1 = 0.5F;
float f2 = 0.4F;
System.out.println(f1 - f2);//0.0999994
double d1 = 0.5;
double d2 = 0.4;
System.out.println(d1 - d2);//0.0999999998
//特殊点五：char类型做运算是获取的字符里的码值
char c = 'a';//UniCode -- 97
int i = c+1;
System.out.println(i);//98
//特殊点六：a++; 和 ++a;没有区别，因为分号是执行语句的结束，不管先加还是后加，都给我加
int a = 10;
//a++;
++a;
System.out.println(a++);
//特殊点七：
int a = 10;
++a;//a = (int)(a+1);
System.out.println(a);
经典面试题一：输出结果为？
int a = 8;
int b = (a++)+(++a)+(a*10);
//a = 10
//b = 8 + 10 + 10 * 10
System.out.println(b);//118
经典面试题二：输出结果为？
int i = 0;
i = ++i;
//底层逻辑：
//i = (int)(i+1);
//i = i;
System.out.println(i);//1
经典面试题三：输出结果为？
int i = 0;
i = i++;
//底层逻辑：
//int temp = i;//temp记录了i的初始值 -- 0
//i = (int)(i+1);
//i = temp;
System.out.println(i);//0
*/
public static void main(String[] args){
}
}
四、赋值运算符
public class Test04{
/**
知识点：赋值运算符
符号：=、+=、-=、*=、/=、%=
int a = 10;
a += 5;//a = (int)(a+5);
a -= 5;//a = (int)(a-5);
a *= 5;//a = (int)(a*5);
a /= 5;//a = (int)(a/5);
a %= 3;//a = (int)(a%3)
System.out.println(a);//1
//经典面试题一：输出结果为？
int a,b;//一次性声明多个变量
a = b = 100;//将100赋值给变量b，再将b赋值给a
System.out.println(a);//100
System.out.println(b);//100
经典面试题二：下面的两种写法结果分别是？
short s=1;
s = s+1; //报错：short和int做运算会向上转型成int类型
short s=1;
s += 1;//底层：s = (short)(s+1);
赋值规则：
s += 1 s = (T)((s) + (1))
复合赋值 E1 op= E2等价于简单赋值 E1 = (T)((E1) op (E2))，其中T是E1的类型。
*/
public static void main(String[] args){
}
}
五、关系运算符
public class Test05{
/**
知识点：关系运算符
符号：==、!=、>、>=、<、<=
boolean bool = 10 == 5;
System.out.println(bool);//false
System.out.println(10 != 5);//true
System.out.println(10 > 5);//true
System.out.println(10 >= 5);//ts
System.out.println(10 < 5);//false
System.out.println(10 <= 5);//false
经典面试题一：输出结果为？
int x = 10;
int y = 10;
boolean flag = (x == y);
System.out.println(flag);//true
flag = (x = y);//会报错 -- boolean不能与其他类型兼容
System.out.println(flag);
经典面试题二：输出结果为？
boolean b1 = true;
boolean b2 = false;
boolean b3 = (b1 == b2);
System.out.println(b3);//false
boolean b4 = (b1 = b2);
System.out.println(b4);//false
注意：
1.=是赋值号，将右边的值赋值给左边的变量
2.==是判断两个值是否相同
3.关系运算符运算的结果都是boolean类型
*/
public static void main(String[] args){
}
}
六、Scanner类
//导包
import java.util.Scanner;
public class Test06{
/**
知识点：Scanner类
含义：Java提供的专门在控制台输入数据的类
*/
public static void main(String[] args){
//创建Scanner类的对象
Scanner scan = new Scanner(System.in);
//利用Scanner类的对象从控制台输入数据
System.out.println("请输入int类型的数据：");
int i = scan.nextInt();
System.out.println("请输入double类型的数据：");
double d = scan.nextDouble();
System.out.println("请输入字符串类型的数据：");
String str = scan.next();
System.out.println("输入的数据为：");
System.out.println(i);
System.out.println(d);
System.out.println(str);
}
}
七、逻辑运算符
import java.util.Scanner;
public class Test08{
/**
知识点：逻辑运算符
符号：
&与 &&短路与
|或 ||短路或
^异或
!非
//&与：两侧必须是boolean，两者必须同时成立(true)，结果才成立(true)
System.out.println(true & true);//true
System.out.println(false & true);//false
System.out.println(true & false);//false
System.out.println(false & false);//false
//&&短路与：两侧必须是boolean，两者必须同时成立(true)，结果才成立(true)
System.out.println(true && true);//true
System.out.println(false && true);//false
System.out.println(true && false);//false
System.out.println(false && false);//false
//&与：判断前者为false后，还会判断后者
//&&短路与：判断前者为false后，不会判断后者，所以效率更高
//ArithmeticException--算数异常
System.out.println(false && 10/0>5);
//|或：两侧必须是boolean，两者有一个成立(true)，结果就成立(true)
System.out.println(true | true);//true
System.out.println(false | true);//true
System.out.println(true | false);//true
System.out.println(false | false);//false
//|短路或：两侧必须是boolean，两者有一个成立(true)，结果就成立(true)
System.out.println(true || true);//true
System.out.println(false || true);//true
System.out.println(true || false);//true
System.out.println(false || false);//false
//|或：判断前者为true后，还会判断后者
//||短路或：判断前者为true后，不会判断后者，所以效率更高
System.out.println(true || 10/0>5);
//^异或：两侧必须是boolean，两者不同，结果就成立(true)
System.out.println(true ^ true);//false
System.out.println(false ^ true);//true
System.out.println(true ^ false);//true
System.out.println(false ^ false);//false
//!非：置反
boolean bool1 = true;
System.out.println(!bool1);//false
boolean bool2 = false;
System.out.println(!bool2);//true
注意：
1.逻辑运算符运行结果都是boolean类型
2.&、&&、|、||、^ 两侧都是boolean类型数据
练习题：在dos窗口输入一个数字，判断是否在50~100的区间内
分析：
1.创建Scanner类的对象
2.输入数字
3.判断区间
*/
public static void main(String[] args){
//1.创建Scanner类的对象
Scanner scan = new Scanner(System.in);
//2.输入数字
System.out.println("请输入int类型的数字：");
int num = scan.nextInt();
//3.判断区间
boolean bool = (num>50) && (num <100);
System.out.println("输入的数字是否在50~100的区间内：" + bool);
}
}
八、三目运算符/三元运算符
import java.util.Scanner;
public class Test09{
/**
知识点：表达式
5 + 6 --> 算数表达式
5 > 6 --> 关系表达式
5 | 6 -->位运算表达式
知识点：三目运算符/三元运算符
语法结构：
变量 = (表达式)?值1:值2;
理解：
表达式的结果必须是boolean
true - 将值1赋值给变量
false- 将值2赋值给变量
做实验：
int num = (false)?10:20;
System.out.println(num);
需求1：在控制台输入两个int数字，输出最大值
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个数字：");
int a = scan.nextInt();
System.out.println("请输入第二个数字：");
int b = scan.nextInt();
int max = (a>b)?a:b;
System.out.println("最大值为：" + max);
需求2：在控制台输入三个int数字，输出最大值
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个数字：");
int a = scan.nextInt();
System.out.println("请输入第二个数字：");
int b = scan.nextInt();
System.out.println("请输入第三个数字：");
int c = scan.nextInt();
int max = (a>b)?a:b;
max = (max>c)?max:c;
System.out.println("最大值为：" + max);
扩展面试题1：
int a = 5;
System.out.println((a<5)?10.9:9);//9.0
扩展面试题2：
char x = 'x';//Unicode -- 120
int i=10;
System.out.println(false?i:x);//120
扩展面试题3：
char x='x';//Unicode -- 120
System.out.println(false?100:x);//x
System.out.println(false?100000:x);//120
三目运算符返回值规则：
1.值1和值2都是常量，按照取值范围大的类型返回数据
2.值1和值2都是变量，按照取值范围大的类型返回数据
3.值1和值2一个是变量一个是常量的情况，判断常量是否在变量所属类型的取值范围内
在 -- 按照变量类型返回数据
不在- 按照常量类型返回数据
*/
public static void main(String[] args){
}
}
九、位运算符
public class Test10{
/**
知识点：位运算符
含义：将十进制数据转换为二进制做运算
符号：
&与 |或 ^异或
<< 左移
>> 右移
>>>无符号位右移
//&与：同位比较，两者都为1，结果才为1
int num1 = 22;//0000,0000,0000,0000,0000,0000,0001,0110
int num2 = 26;//0000,0000,0000,0000,0000,0000,0001,1010
//0000,0000,0000,0000,0000,0000,0001,0010
int result = num1 & num2;
System.out.println(result);//18
//|或：同位比较，两者有1，结果就为1
int num1 = 22;//0000,0000,0000,0000,0000,0000,0001,0110
int num2 = 26;//0000,0000,0000,0000,0000,0000,0001,1010
//0000,0000,0000,0000,0000,0000,0001,1110
int result = num1 | num2;
System.out.println(result);//30
//^异或：同位比较，相同为0，不同为1
int num1 = 22;//0000,0000,0000,0000,0000,0000,0001,0110
int num2 = 26;//0000,0000,0000,0000,0000,0000,0001,1010
//0000,0000,0000,0000,0000,0000,0000,1100
int result = num1 ^ num2;
System.out.println(result);//12
&、|、^：前后两侧都是boolean，此符号为逻辑运算符
&、|、^：前后两侧都是数值，此符号为位运算符
//<<左移：整体向左移动n为，就用n个0补到最低位
int a = 1024;//0000,0000,0000,0000,0000,0100,0000,0000
System.out.println(a << 2);//4096 -- 0000,0000,0000,0000,0001,0000,0000,0000
//>>右移：整体向右移动n为，就用n个符号位补到最高位
//>>>无符号位右移：整体向右移动n为，就用n个0补到最高位
//注意：右移和无符号位右移在处理正数时是一样的
int b = 1024;//0000,0000,0000,0000,0000,0100,0000,0000
System.out.println(b >> 2);//256 -- 0000,0000,0000,0000,0000,0001,0000,0000
System.out.println(b >>> 2);//256 -- 0000,0000,0000,0000,0000,0001,0000,0000
int c = -23;//1111,1111,1111,1111,1111,1111,1110,1001
System.out.println(c >> 2);//-6 -- 1111,1111,1111,1111,1111,1111,1111,1010
System.out.println(c >>> 2);//10737418181 -- 0011,1111,1111,1111,1111,1111,1111,1010
经典面试题：解释下列代码的转换过程
考点：
1.强制转型是舍弃前面的位数
2.自动转型按照最高位补位
3.char类型转型用0补位
//-1 -- int：1111,1111,1111,1111,1111,1111,1111,1111
// (byte)：1111,1111
// (char)：1111,1111,1111,1111
// (int)：0000,0000,0000,0000,1111,1111,1111,1111
System.out.println((int)(char)(byte)-1);//65535
知识点：运算符的优先级别
经验：不用记，灵活运用小括号
*/
public static void main(String[] args){
}
}
十、转义字符
含义：用来表示有特殊意义的字符本身
| 符号 | 作用 |
|---|---|
| \n | 换行 |
| \t | 水平制表 |
| \” | 双引号 |
| \’ | 单引号 |
| \ | 一个斜杠 |
System.out.print(""); ---- 表示输出
System.out.println(""); -- 表示输出并换行
十一、常量
含义：程序执行过程中不可发生改变的量
分类：
- 数字字面量：程序中出现的数字,整数数字默认int类型,小数数字默认double类型
- 字面值常量：使用双引号括起来的内容
- final修饰的变量：最终变量-常量
final int i = 100; System.out.println(i);//100字面值常量和final修饰的变量：
存放在常量池中，并且常量池中的数据不能重复，直到项目结束时常量池中的数据才会被情况
1380
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
