活动地址：CSDN21天学习挑战赛
一、Java基本数据类型有几种，如何表示，取值范围以及注意事项？
数据类型——为了定义变量，限定变量的存储空间大小。
Java中的数据类型
Java中的基本数据类型有4类8种
整数类型（4）
| 1.字节型 byte | 1个字节 | -2的7次方~2的7次方-1 |
|---|---|---|
| 2. 短整型 short | 2个字节 | -2的15次方~2的15次方-1 |
| 3. 整型 int | 4个字节 | -2的31次方~2的31次方-1 |
| 4. 长整型 long | 8个字节 | -2的63次方~2的63次方-1 |
浮点类型（2）
| 1. 单精度浮点型 float | 4个字节 | 8位的有效数字 |
|---|---|---|
| 2. 双精度浮点型 double | 8个字节 | 16位的有效数字 |
字符类型（1）
| 1.字符型 char | 2个字节 | 0~65535 |
|---|
布尔类型（1）
| 1.布尔型 boolean | 1个字节 | true/false |
|---|
数据内存存储空间的计算
1个字节8位2进制，因此计算数据类型的存储空间的取值范围。
首先，第一位代表正负。0属于正数范围。
计算过程：负数是 -（2的字节位数-1的次方）
正数是2的字节位数-1的次方-1
数据类型 —— 为了定义变量，限定变量的存储空间大小
变量的组成：
数据类型
名称
初始值
作用域
创建Java变量：
1 . 先定义，后赋值。
定义格式：数据类型 名称;
例如: int num;
赋值[=]格式: 名称=数据值;
例如: num=123;
2 . 定义+赋值
定义+赋值格式: 数据类型 名称 = 数据值;
例如: int num = 123;
例如：整型
public class ZhengShuType{
public static void main(String args[]){
//字节型 byte 1个字节8位2进制 -2的7次方~2的7次方-1
//1.先定义，后赋值。
byte bytenum1;
bytenum1 = 100;
System.out.println("bytenum1=="+bytenum1);
//2.定义+赋值
byte bytenum2=127;
System.out.println("bytenum2=="+bytenum2);
//当我们赋值给字节型变量的具体数据值超过字节型取值访问时就会报错
//短整型 short 2个字节 -2的15次方~2的15次方-1
//1.先定义，后赋值。
short shortnum1;
shortnum1 = 200;
System.out.println("shortnum1=="+shortnum1);
//2.定义+赋值
short shortnum2=2000;
System.out.println("shortnum2=="+shortnum2);
//当我们赋值给短整型变量的具体数据值超过短整型取值访问时就会报错
//3.整型 int 4个字节 -2的31次方~2的31次方-1
//1.先定义，后赋值。
int intnum1;
intnum1 = 20000;
System.out.println("intnum1=="+intnum1);
//2.定义+赋值
int intnum2=2000000000;
System.out.println("intnum2=="+intnum2);
//当我们赋值给整型变量的具体数据值超过整型取值访问时就会报错
//4.长整型 long 8个字节 -2的63次方~2的63次方-1
//1.先定义，后赋值。
long longnum1;
longnum1= 30000;
System.out.println("longnum1=="+longnum1);
//2.定义+赋值
long longnum2=3000000000000000000L;
System.out.println("longnum2=="+longnum2);
//当我们赋值给长整型变量的具体数据值超过长整型取值访问时就会报错
//我们在给长整型变量赋值的时候，要给数据值添加“L”、“l”作为后缀
//在程序中出现了没有变量保存的整数数据值时，程序就认为这个数据值就是int
int num1=123;
int num2=num1+200;
System.out.println("num2=="+num2);
}
}
例如：浮点型
public class XiaoShuType{
public static void main(String args[]){
//单精度浮点型 float 4个字节 8位的有效数字
//1.先定义，后赋值。
float floatnum1;
//floatnum1 = 100;
floatnum1 = 100.199F;
System.out.println("floatnum1=="+floatnum1);
//2.定义+赋值
float floatnum2=100.199f;
System.out.println("floatnum2=="+floatnum2);
//单精度浮点型数据在赋值的时候需要添加“F”、“f”作为后缀
//双精度浮点型 double 8个字节 16位的有效数字
//1.先定义，后赋值。
double doublenum1;
//doublenum1 = 200;
doublenum1= 200.199;
System.out.println("doublenum1=="+doublenum1);
//2.定义+赋值
double doublenum2=200.199D;
System.out.println("doublenum2=="+doublenum2);
//双精度浮点型数据在赋值的时候可以添加“D”/“d”作为后缀,也可以省略
//在程序中出现了没有变量保存的小数数据值时，程序就认为这个数据值就是double
}
}
例如：字符型
public class CharType{
public static void main(String args[]){
//字符型 char 2个字节 0--65535
//单个字符 A
//字符型数据在赋值的时候需要单引号包围
//字符型是可以保存汉字
char charvalue='好';
System.out.println("charvalue=="+charvalue);
//转义字符
// 斜杠 \ 转义 \\
System.out.println("f:\\test\\my.txt");
// 双引号 " 转义 \"
// 单引号 ' 转义 \'
System.out.println("张三说:\"你好\"");
// 制表符 【Tab键】 转义 \t
System.out.println("hello\tworld");
// 换行 转义 \n
System.out.println("hello\nworld");
}
}
二、Java中基本数据类型之间的转换以及注意事项？
1.boolean类型是不参与基本数据类型之间的转换。
2.基本数据类型的精度排序【由低到高顺序】
byte —> short —> char —> int —> long —> float —> double
3.将数据类型精度低的转换成数据类型精度高的----隐式数据类型转换【自动数据类型转换】
隐式数据类型转换【自动数据类型转换】不需要修改程序，直接赋值即可完成。
可以直接赋予具体的数据值，也可以将变量赋值。
例如：int —> doubole [隐式数据类型转换【自动数据类型转换】]
public class DataTypeSwitch1{
public static void main(String args[]){
//int--->doubole [隐式数据类型转换【自动数据类型转换】]
//直接赋予具体的数据值
double doublevalue = 100;
System.out.println("doublevalue=="+doublevalue);
//可以将变量赋值
int intnum=300;
double doublevalue2=intnum;
System.out.println("doublevalue2=="+doublevalue2);
}
}
4.将数据类型精度高的转换成数据类型精度低的–显式数据类型转换【强制数据类型转换】
显式数据类型转换【强制数据类型转换】需要修改程序。
格式：低精度数据类型 变量名称 = (精度低数据类型)精度高的数据值【变量】;
例如：double —> int[隐式数据类型转换【自动数据类型转换】]
public class DataTypeSwitch2{
public static void main(String args[]){
//double--->int[显式数据类型转换【强制数据类型转换】]
//格式：低精度数据类型 变量名称 = (精度低数据类型)精度高的数据值【变量】;
//将小数转换成整数不会“四舍五入”，而是直接舍弃小数部分
int intnum1=(int)12.8;
System.out.println("intnum1=="+intnum1);
double doublevalue=12.8d;
int value=(int)doublevalue;
System.out.println("value="+value);
}
}
5.char与int的转换
char的取值范围就是整数
1. char —> int [[隐式数据类型转换【自动数据类型转换】]]
2. int —> char[[显式数据类型转换【强制数据类型转换】]]
例如：
public class CharAndInt{
public static void main(String args[]){
//char的取值范围就是整数
//1.char---->int [[隐式数据类型转换【自动数据类型转换】]]
char chatvalue1='好';
int intvalue1=chatvalue1; //隐式数据类型转换
System.out.println("intvalue1="+intvalue1);//intvalue1=22909
//2.int---->char[[显式数据类型转换【强制数据类型转换】]]
int intvalue2=22909;
char charvalue2=(char)intvalue2;//显式数据类型转换
System.out.println("charvalue2="+charvalue2);
}
}
6.int转换成byte
当整数超过取值范围以后，会从最小值向前推进计算。
数轴会变成闭环进行循环推进
public class IntToByte{
public static void main(String args[]){
byte bytevalue=(byte)300;
System.out.println("bytevalue="+bytevalue);
//byte bytevalue1=127;
//byte bytevalue2=(byte)(bytevalue1+1);
//System.out.println("bytevalue2="+bytevalue2);
}
}
三、赋值运算符与赋值表达式
赋值运算符：“=”例如：int num = 100;
四、算术运算符与算数表达式
算术运算符：+ - * / % ++ --例如：
public class SuanShu{
public static void main(String args[]){
//+ - * / %
int num1=10;
int num2=3;
System.out.println(num1+"+"+num2+"="+(num1+num2));
System.out.println(num1+"-"+num2+"="+(num1-num2));
System.out.println(num1+"*"+num2+"="+(num1*num2));
//当参数算术运算的数据是整数时，运算结果就是整数
System.out.println(num1+"/"+num2+"="+(num1/num2));
System.out.println(num1+"%"+num2+"="+(num1%num2));
}
}
在混合运算过程中，运算结果的数据类型以运算过程中精度最高的数据类型为准
public class SuanShu2{
public static void main(String args[]){
//四则混合运算，参数运算的数据类型不是同一类
//当参与算术运算的数据类型不是同一类时，
//它的运算结果的数据类型是精度最高的数据类型
byte b=100;
short s=200;
int i=300;
long l=400L;
float f=3.14f;
double d=2.7;
char c='A';
//-1545.5599853515625----double
System.out.println(b+s-i*l/c+f);
}
}
五、“++”与“- -”的具体用法
“++”——自动加1
1.变量++；——【先用后加】
2.++变量；——【先加后用】
“- -”—— 自动减1
3.变量- -；【先用后减】
4.- -变量；【先减后用】
例如：
public class SuanShu3{
public static void main(String args[]){
//“++”————>自动加1
//1.变量++;【先用后加】
/*
int num1=10;
System.out.println("变量++=="+(num1++));//10 先用
System.out.println("num1=="+num1);//11 后加
*/
//2.++变量；【先加后用】
/*
int num1=10;
System.out.println("++变量=="+(++num1));//11 先加
System.out.println("num1=="+num1);//11 后用
*/
//“--”————> 自动减1
//3.变量--；【先用后减】
/*
int num1=10;
System.out.println("变量--=="+(num1--));//10 先用
System.out.println("num1=="+num1);//9 后加
*/
//4.--变量；【先减后用】
int num1=10;
System.out.println("--变量=="+(--num1));//9 先用
System.out.println("num1=="+num1);//9 后加
}
}
六、关系运算符与关系表达式
关系运算符：> < >= <= == !=
public class GuanXi{
public static void main(String args[]){
//关系运算符: > < >= <= == !=
//关系运算符的结果一定是boolean值
int num1=10;
int num2=3;
System.out.println(num1+" > "+num2+"="+(num1>num2));
System.out.println(num1+" < "+num2+"="+(num1<num2));
System.out.println(num1+" >= "+num2+"="+(num1>=num2));
System.out.println(num1+" <= "+num2+"="+(num1<=num2));
System.out.println(num1+" == "+num2+"="+(num1==num2));
System.out.println(num1+" != "+num2+"="+(num1!=num2));
}
}
七、逻辑运算符与逻辑表达式
逻辑运算符分为两大类：
1.逻辑运算符
2.位运算符
逻辑运算符：逻辑或 || 逻辑与 && 逻辑反 ！
逻辑运算符的运算值和运算结果一定是boolean
例如：
public class LuoJi1{
public static void main(String args[]){
int num1=10;
int num2=3;
//逻辑或 ||
boolean b1 =((num1+num2)>10) || ((num1-num2)<3) ;
System.out.println("b1=="+b1);
//逻辑与 &&
boolean b2 =((num1+num2)>10) && ((num1-num2)<3) ;
System.out.println("b2=="+b2);
//逻辑反 !
boolean b3 =!(((num1+num2)>10) && ((num1-num2)<3)) ;
System.out.println("b3=="+b3);
}
}
八、短路与和短路或
短路或–逻辑或的运算规则
【运算符号左右两边都是false的时候，运算结果就一定是false,如果出现一个true,运算结果就一定是true】
短路或—短路就是运算符号只运算一边
当运算符号左边的结果为true时候，右边不用计算，结果就一定是true.
短路与–逻辑与的运算规则
【运算符号左右两边都是true的时候，运算结果就一定是true,如果出现一个false,运算结果就一定是false】
短路与—短路就是运算符号只运算一边
当运算符号左边的结果为false时候，右边不用计算，结果就一定是false
例如
public class LuoJi2{
public static void main(String args[]){
//短路或:当运算符号左边的结果为true时候，右边不用计算，结果就一定是true.
int num1=10;
//System.out.println(num1/0);
boolean b1= (num1 < 20) || ((num1/0)>10);
System.out.println("b1="+b1);
//短路与:当运算符号左边的结果为false时候，右边不用计算，结果就一定是false
int num2=100;
boolean b2= (num2 < 20) && ((num2/0)>10);
System.out.println("b2="+b2);
}
}
九、位运算符
位运算：就是将参与运算的数据转换成2进制【0101001】
10进制与2进制的转换
1. 原码
原码就是符号位加上真值的绝对值, 即用第一位表示符号, 其余位表示值.
2. 反码
反码的表示方法是:
正数的反码是其本身【原码】
负数的反码是在其原码的基础上, 符号位不变，其余各个位取反.
3. 补码
补码的表示方法是:
正数的补码就是其本身【原码】
负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)
整数的2进制就是源码
负数的2进制实质上补码表示。
-3 => 10000011—>11111100—>11111101【负数的原码取反+1】{符号位不变}
-3 => 00000011【3】—>11111100【取反】—>11111101【+1】 【负数的绝对值的原码的取反+1】
-7 => 00000111【7】—>11111000【取反】—>11111001【+1】
-12 => 00001100【12】—>11110011【取反】—>11110100【+1】
常见的6种位运算符号
1. & 按位与 相同位为1则为1，不同为0，相同位为0则为0。
例如：3 & -7
0000 0011 【3】
1111 1001 【-7】
0000 0001 【1】
2. | 按位或 相同位只要一个为1即为1。
例如：3 | -7
0000 0011 【3】
1111 1001 【-7】
1111 1011 【-5】
3. ^ 按位异或 相同位不同则为1，相同则为0。
例如：3 ^ -7
0000 0011 【3】
1111 1001 【-7】
1111 1010 【-6】
4. ~取反 0和1全部取反
例如：~3
0000 0011 【3】
1111 1100 —> 1111 1011【+1】 —> 1000 0100【取反】 【-4】
5. <<左移位 2进制整体向左移动指定的位数
例如 : 3 << 2
0000 0011 【3】
0000 0110 移动1位
0000 1100 移动2位 —> 【12】
6. >>右移 2进制整体向右移动指定的位数
例如 : 3 >> 2
0000 0011 【3】
0000 0001 移动1位
0000 0000 移动2位 —> 【0】
例如：
public class LuoJi3{
public static void main(String args[]){
//1.& 按位与 相同为1，不同为0。
int num1=3;
int num2=-7;
System.out.println(num1 & num2); // 1
//2.| 按位或 相同位只要一个为1即为1。
System.out.println(num1 | num2); // -5
//3.^ 按位异或 相同位不同则为1，相同则为0。
System.out.println(num1 ^ num2); // -6
//4.~取反 0和1全部取反
System.out.println(~num1); // -4
//5.<<左移位 2进制整体向左移动指定的位数
System.out.println(num1 << 2); //
//6.>>右移位 2进制整体向右移动指定的位数
System.out.println(num1 >> 2); // 0
System.out.println(2 << 3);
}
}
十、运算符号的优先级
总结
428
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
