数值类型转换
boolean类型不参与数值类型转换
自动类型提升
大范围数据类型 变量 = 小范围数据类型的数据;
强制类型转换
小范围数据类型 变量 = (小范围数据类型)大范围数据类型的数据;
注意：
对应类型的数据复制给对应类型的变量，强制转换类型发生在赋值之前
如果多种数据类型的数据参与运算，最终的结果为参与运算中的最大数据类型，如果参与运算后的最大数值类型小于int类型，则会自动提升到int类型。
类型大小比较：
byte<short<int<long<float<double
如果为byte,short,char类型赋值的时候，只要在其范围内的常量就能成功赋值
public class Demo{
public static void main(String[] agrs){
byte b = 100;
short t = 0;
int i = 1000;
long lo = 10000000000L;
float f = 1.123f;
double d = 1.123123123;
char c = 'a';
System.out.println(b);
System.out.println(t);
System.out.println(i);
System.out.println(lo);
System.out.println(f);
System.out.println(d);
System.out.println(c);
t = b; //会自动将byte提升为short类型
System.out.println(t);
t = (short)i; //大范围数据类型int的变量将值赋值给short类型的变量需要在int类型变量前加(short)
System.out.println(t);
i = (int)lo; //超出目标类型数值范围的大范围数据在强制转换过程中数据会被截断
System.out.println(i);
f = 100; //int类型的数据自动提升为float
System.out.println(f);
f = (float)d; //double强制转换为float类型时会损失精度
System.out.println(f);
i = c; //char类型的数据可以直接赋值给大于等于char类型数值范围的数据类型
System.out.println(i);
c = 3000; //如果为byte,short,char类型赋值的时候，只要在其范围内的常量就能成功赋值
System.out.println(c);
}
}
运算符
运算符的分类
算术运算符
赋值运算符
比较运算符|关系运算符
逻辑运算符
条件运算符
位运算符
操作数：运算符左右两边的数据称作为操作数
表达式：运算符连接操作数整体称作为表达式
语句：;代表一个语句的结尾
单目运算符|一元运算符：操作数只有一个，符号：+(正号) -(负号) ++ –
双目运算符|二元运算符：操作数只有两个，符号：+ - * /
三目运算符|三元运算符：条件运算符
算术运算符
+ - * / %（取余） ++ –
+：
1)正号->可以省略
2)加法运算
3)字符串连接符
当+左右两边存在字符串类型的数据，当前的+作为字符串的连接符存在，会把左右两边的数据连接成为一个字符串
-：
1)负号
2)减法运算
*：
1)乘法运算
/：
1)除法运算
%：
1)取模|模|取余
当第一个操作数<第二个操作数，结果就为第一个操作数
++和–：
1)++：自增
++a | a++ --> a = a + 1;单独出现时只影响自己不影响其他结果，都是自身+1
i = ++a | i = a++ --> i = a + 1; | i = a;a+1;参与输出、赋值、运算时，放在操作数前，自身+1，然后再参与运算；放在操作数后，先参与运算，然后自身+1。
2)–：自减
--a | a-- --> a = a - 1;单独出现时只影响自己不影响其他结果，都是自身-1
i = --a | i = a-- --> i = a - 1; | i = a;a-1;参与输出、赋值、运算时，放在操作数前，自身-1，然后再参与运算；放在操作数后，先参与运算，然后自身-1。
注意: 一个变量的值一旦改变不可恢复
public class Demo{
public static void main(String[] agrs){
int a=1,b=2,c=4,d=5,num=0;
num = a+b;
System.out.println(num);
num = c/b;
System.out.println(num);
num = b*c;
System.out.println(num);
num = c%b;
System.out.println(num);
num = b%c; //当第一个操作数<第二个操作数，结果就为第一个操作数
System.out.println(num);
a++;
System.out.println(a);
b++;
System.out.println(b);
System.out.println(c++); //参与输出、赋值、运算时，++放在操作数后，先参与运算，然后自身+1
System.out.println(++d); //参与输出、赋值、运算时，++放在操作数前，自身+1，然后再参与运算
a=1;
b=1;
c=++a;
System.out.println(c);
c=b++;
System.out.println(c);
}
}
赋值运算符
= += -= *= /= %=
基础赋值运算符
=
在java中=是自由向左运算的符号
优先级是最低的
扩展赋值运算符(算数运算符+基本赋值运算符)
+= : a+=3; a=a+3;
-=
*=
/=
%= : a%=3; a=a%3;
推荐使用扩展赋值运算符
优点:
1.提高执行效率 (编译期间,编译器会自动编译成扩展赋值运算符)
2.自动做强制类型转换
public class Demo{
public static void main(String[] args){
int a=1,b=2,c=4;
byte d=5;
a += b; //a = a+b;
System.out.println(a);
b %= c; //b = b%c;
System.out.println(b);
d *= c; //d = (byte)(d*c);d为byte类型，在和int类型变量c运算时，会将byte转换为参与运算的变量中最大范围的那个类型,得到的结果也为参与运算的变量中最大范围的那个类型，使用扩展赋值运算符运算时会自动的将计算结果转换为被赋值变量的数据类型
System.out.println(d);
}
}
关系运算符|比较运算符
> < >= <= == !=
使用> < >= <= 运算符，可以参与运算的数据类型有：byte,short,int,long,char,float,double
使用== != 运算符，任意类型的数据都可以参与运算
关系运算符运算的结果是一个boolean类型的结果
public class Demo{
public static void main(String[] args){
boolean flag;
int a=5,b=10;
flag = a>b;
System.out.println(flag);
flag = a>=5;
System.out.println(flag);
flag = a==b;
System.out.println(flag);
flag = a!=b;
System.out.println(flag);
}
}
逻辑运算符
& | ! ^ && ||
逻辑运算符使用时，要求两边的操作数都为boolean类型->boolean类型的值|结果为boolean类型的表达式
& 与 : 两变都为true结果才为true,一个为false就是false
| 或 : 两边都为false才是false,一个为true就是true
! 非 : 取反 !true->false !false->true
^ 异或 : 相同为false,不同为true
短路:
&&和||：左边的操作数已经能够决定最终的结果，右边的操作数不在执行
public class Demo{
public static void main(String[] agrs){
boolean flag;
int a=5,b=10,c=0;
flag = b==10 & a>5; //flag = true & false;
System.out.println(flag); //flase
flag = b==10 & a==5; //flag = true & true;
System.out.println(flag); //true
flag = b==10 | a>5; //flag = true & false;
System.out.println(flag); //true
flag = b!=10 & a>5; //flag = false & false;
System.out.println(flag); //flase
flag = !(b==10); //flag = !true;
System.out.println(flag); //flase
flag = b==10 ^ a>5; //flag = true ^ false;
System.out.println(flag); //true
flag = b==10 && b>(a=a+5); //flag = true ^ false;第一个条件为true所以需要看第二个条件是否为true，全为true整个表达式结果为true
System.out.println(flag); //false
System.out.println(a); //a参与了运算
flag = a>(b=b+5) && b>(c=c+1); //flag = false ^ true;第一个条件为false，因为&&需要全部为true整个表达式结果才为true，所以不需要看后面的条件是否为true，整个表达式结果为false
System.out.println(flag); //false
System.out.println(b); //b参与了运算
System.out.println(c); //c没有参与运算
a=5;b=10;c=0;
flag = b==10 || b>(a=a+5); //flag = true ^ false;第一个条件为true，所以不需要看第二个条件是否为true。b==10 || b>(a=a+5)表达式结果为true;
System.out.println(flag); //true
System.out.println(a); //a没有参与运算
flag = a>(b=b+5) || b>(c=c+1); //flag = false ^ true;第一个条件为false，因为||需要全部为false整个表达式结果才为false，所以需要看后面的条件是否为false。a>(b=b+5) || b>(c=c+1)表达式结果为true
System.out.println(flag); //true
System.out.println(b); //b参与了运算
System.out.println(c); //c参与运算
}
}
条件运算符
? :
条件表达式 ? 值1 : 值2 ;
条件表达式就是值为boolean类型的表达式
执行流程:
1.计算条件表达式，得到一个boolean结果
2.如果条件表达式的结果为true，最终的结果为值1
2.如果条件表达式的结果为false，最终的结果为值2
条件运算符最终肯定能够得到一个执行结果，不是值1就是值2
public class Demo{
public static void main(String[] args){
int a=1,b=2;
String str="";
str = a>b?"对啦!":"错啦!";
System.out.println(str);
}
}
位运算符
& | ^ >> <<
位运算符: -->了解
对二进制的操作数进行某种规则的运算
以下三个运算符两边的操作数为boolean 作为逻辑运算符,两边的操作数为整数,作为位运算符
&：先把两个操作数转为二进制,同一位置的两个数,一个为0就是0,两个都为1才是1,结果转为十进制
|：先把两个操作数转为二进制,同一位置的两个数,一个为1就是1,两个都为0才是0
^：先把两个操作数转为二进制,同一位置的两个数,相同为0,不同为1
位移运算符:
>>右移
左边的操作数转为二进制,向右移动右边操作数个位数,移动的位数舍弃,结果转为十进制
<< 左移
左边的操作数转为二进制,向左移动右边操作数个位数,空位补0,结果转为十进制
规律:
>>右移相当于/2 a>>b -> a/2^b
<< 左移相当于*2 a<<b -> a*2^b
位运算符效率高,对二进制的数据做运算
public class Demo{
public static void main(String[] args){
int a=0b101,b=2;
System.out.println(a);
System.out.println(a>>2);//将二进制数0b101向右移动2位，移动后为0b1;
System.out.println(0b1);
System.out.println(a<<2);//将二进制数0b101向左移动2位，移动后为0b10100;
System.out.println(0b10100);
}
}
运算符的优先级
单目算数位关系,逻辑三目后赋值
Scanner
基本数据类型:
数据类型 变量名 = 数据值;
int i = 1;
引用数据类型:
1)导包
指定要使用的引用数据类型的位置
import 包名.类名;
位置: 类的上面
2)创建引用数据类型的引用
引用数据类型 变量名|引用 = new 引用数据类型();
3)使用功能
引用.方法名();
Scanner : 接收用户键盘输入的内容
1)导包: import java.util.Scanner;
2)创建一个Scanner类型的引用
Scanner sc = new Scanner(System.in);
3)使用功能
sc.nextInt() 接收用户键盘输入的int类型的数据
sc.nextByte() 接收用户键盘输入的byte类型的数据
sc.nextShort() 接收用户键盘输入的short类型的数据
sc.nextLong() 接收用户键盘输入的long类型的数据
sc.nextDouble() 接收用户键盘输入的double类型的数据
sc.nextFloat() 接收用户键盘输入的float类型的数据
sc.next() 接收用户收入的字符串类型的数据
从有效字符开始接收(非空格),遇到空格就停止接收,直到遇到enter功能结束
以上这些系列的next功能,都是从有效字符开始接收
sc.nextLine()接收用户输入的一整行的数据,直到遇到enter结束
当nextLine功能的上面存在系列的next功能时候,注意处理之前的系列的next遗留的enter问题,处理方式在sc.nextLine()代码上方增加一行代码sc.nextLine();
import java.util.Scanner; //导入Scanner包
public class Demo{
public static void main(String[] args){
int i=0;
byte b=0;
short s=0;
long lo=0L;
double d=0.0;
float f=0.0f;
String str="";
Scanner sc = new Scanner(System.in); //初始化，创建一个Scanner类型的引用
System.out.println("请输入一个整数");
i = sc.nextInt();
System.out.println("输入的是："+i);
System.out.println("请输入一个byte范围的整数");
b = sc.nextByte();
System.out.println("输入的是："+b);
System.out.println("请输入一个short范围的整数");
s = sc.nextShort();
System.out.println("输入的是："+s);
System.out.println("请输入一个long范围的整数");
lo = sc.nextLong();
System.out.println("输入的是："+lo);
System.out.println("请输入一个double范围的小数");
d = sc.nextDouble();
System.out.println("输入的是："+d);
System.out.println("请输入一个float范围的小数");
f = sc.nextFloat();
System.out.println("输入的是："+f);
System.out.println("请输入不包含空格的字符串");
str = sc.next(); //从有效字符开始接收(非空格),遇到空格就停止接收,直到遇到enter功能结束
System.out.println("输入的是："+str);
sc.nextLine(); //用来处理next()遗留的enter问题
System.out.println("请输入任意字符串");
str = sc.nextLine();
System.out.println("输入的是："+str);
}
}
Random随机数
Random 声明随机数
1.导包 import java.util.Random;
2.创建类型的引用 Random ran = new Random();
3.使用功能
ran.nextInt() 生成一个int类型范围内的随机数
ran.nextInt(整数n) 生成一个 [0,n) 之间的随机整数
ran.nextDouble() 生成一个 double类型的随机小数->[0.0,1.0)
总结公式:
[min,max) 随机整数 ran.nextInt(max-min)+min
ran.nextInt(max)->[0,max)
ran.nextInt(max)+min ->[0,max) + min -> [min,max+min)
ran.nextInt(max-min)+min ->[0,max-min) + min -> [min,max)
[min,max] 随机整数 ran.nextInt(max-min+1)+min
import java.util.Random;
public class Demo{
public static void main(String[] args){
int i=0;
double d=0.0;
Random ran = new Random();
i = ran.nextInt();
System.out.println("生成的随机Int类型的数为："+i);
d = ran.nextDouble();
System.out.println("生成的随机Double类型的数为："+d);
//nextInt(整数n)默认生成的数为[0,n)之间的整数
//生成一个[20,70]的整数
i = ran.nextInt(70-20+1)+20; //[min,max] 随机整数 ran.nextInt(max-min+1)+min
//生成一个[20,70)的整数
i = ran.nextInt(70-20)+20; //[min,max) 随机整数 ran.nextInt(max-min)+min
}
}
591
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
