**java的基础知识积累**
除号使用
System.out.println(10/4);//2;
double d = 10 / 4;
System.out.println(d);//2.0
System.out.println(10.0/4);//2.5
取模使用
a % b = a - a / b * b
System.out.println(10 % 3);//1
System.out.println(-10 % 3);//-1 -10 - (-10) / 3 * 3 = -10 - (-3)*3 = -10 + 9
System.out.println(10 % -3);//1 10 - 10 / (-3) * (-3) = 10 - (-3) * (-3) = 10 - 9
System.out.println(-10 % -3)//-1 -10 - (-10) / (-3) * (-3) = -10 - 3 * (-3) = -10 + 9
取模实质是要利用公式
a % b = a - a / b * b;
自增自减
int j = 8;
int k = j++;//等价 k = j;j = j + 1;
int r = ++j;//等价 j = j + 1;r = j
下面是算术运算符的习题
int i = 1;
i = i++;
System.out.println(i);//1
使用临时变量的规则
(1)temp = i;
(2)i = i + 1;
(3)i = temp;
int i = 1;
i = ++i;
System.out.println(i);//2
(1)i = i + 1;
(2)temp = i;
(3)i = temp;
int i1 = 10;
int i2 = 20;
int i = i1++;
System.out.println("i= " + i);//10
System.out.println("i2= " + i2);//20
i = --i2;
System.out.println("i= " + i);//19
System.out.println("i2= " + i2);//19
1.假如还有59天放假,问:合多少星期零几天
//下面是练习
public class ArithmeticOperatorExercise {
//编写一个main方法
public static void main(String[] args) {
int days = 59;
int leftdays = days % 7;
int xq = 59/7;
System.out.println(days + "天 合" + xq + "星期零" + leftdays +"天");
}
}
2.定义一个变量保存华氏温度,华氏温度转换赦制度的公式为:5/9*(华氏温度-100),请求出华氏温度对应的温度
double hs = 234.5;
double ss = 5.0 / 9 * (hs - 100);//此处要是5.0,否则计算机默认整除运算
System.out.println(hs + "华氏温度是" + ss + "摄氏度");
关系运算符
- 关系运算符的结果都是Boolean型,要么是true要么是false
- 关系运算符组成的表达式叫关系表达式
- 等于号(==)和赋值号(=)不可混淆
int a = 9;
int b = 8;
System.out.println(a > b);//T
System.out.println(a >= b);//T
System.out.println(a < b);//F
System.out.println(a <= b);//F
System.out.println(a == b);//F
System.out.println(a != b);//T
boolean flag = a > b;//T
System.out.println("flag = " + flag);//T
逻辑运算符
a | b | a&b (逻辑与) | a&&b (短路与) | a|b (逻辑或) | a||b (短路或) | !a (取反) | a^b (逻辑异或) |
---|---|---|---|---|---|---|---|
true | true | true | true | true | true | false | false |
true | false | false | false | true | true | false | true |
false | true | false | false | true | true | true | true |
false | false | false | false | false | false | true | false |
- 看表时,画一条竖线,一条横线
- 横线经过a和b的真假
- 竖线经过a和b运算的符号
- 交叉点即为结果真假
- 竖线经过a和b运算的符号
- 横线经过a和b的真假
-
a&b(a&&b)
同真为真,否则为假(基本上使用短路与(&&)效率更高)
区别:
短路与(&&)如果第一个条件为假,第二个条件不再判断(不运算第二个条件),结果自动为假
逻辑与(&)第一个条件为假,第二个条件要去判断(需要运算第二个条件),但结果仍为假
-
a|b(a||b)
有真则真,否则为假、
区别:
短路或(||)第一个条件为真了,不会再执行后面的条件,最终结果为真,效率高 -
!a
a真为假,a假为真
-
a^b
a和b不同时为真,否则为假
逻辑运算符练习
int x = 5;
int y = 5;
if(x++ == 6 & ++y ==6) {//第一个自增不管是最后结果是真还是假,都会实现
x = 11;
}
System.out.println("x = " + x "y = " + y );//6 6
int x =5, y = 5;
if(x++ == 6 && ++y ==6) {
x = 11;
}
System.out.println("x = " x + "y = " + y);//6 5
int x = 5, y= 5;
if(x++ == 5 | ++y ==5) {
x = 11;
}
System.out.println("x = " + x "y = " + y );//11 6
int x = 5, y= 5;
if(x++ == 5 || ++y ==5) {
x = 11;
}
System.out.println("x = " + x "y = " + y );//11 5
boolean x = true;
boolean y = false;
short z = 46;
if((z++ == 46)&&(t = true)) z++;//48
if((x = false) || (++z == 49)) z++;//49+1(虽然是短路或,但第一个条件是假,只有真才能使它短路)
System.out.println("z = " + z);//50
赋值运算符
运算顺序(从右到左)
复合运算符会进行类型转换
byte b = 3;
b += 2;//等价 b = (byte)(b + 2) -->此时不等价于 b = b + 1
三元运算符
条件表达式?表达式1:表达式2
为真返回1,为假返回2(一真大师)
public class TernaryOperator {
//编写一个main方法
public static void main(String[] args) {
int a = 10;
int b = 99;
int result = a > b ? a++ : b--;
System.out.println(result);//99(先赋值再--)
}
}
public class TernaryOperator {
//编写一个main方法
public static void main(String[] args) {
int a = 10;
int b = 99;
int result = a < b ? a++ : b--;
System.out.println("result " + result);//10
System.out.println("a = " + a);//11
System.out.println("b = " + b);//99
}
}
细节
- 表达式1和表达式2要为可以赋给变量的类型(或可以自动转换/强制转换)
- 可以转换为if-else语句
//实现三个数的最大值
int x = 100;
int y = 150;
int z = 300;
//自己写的
int ret = x > y ? (x > z ? x : z) : (y > z ? y : z);
//推荐使用,这里思路更清晰
//比如冒泡法等可以优化代码
int max1 = x > y ? x : y;
int max2 = max1 > z ? max1 : z;
//结果都是相同的
System.out.println("ret = " + ret);
运算符的优先级
- 只有单目运算符、赋值运算符是从右向左运算的
- 有大致的概念即可
. () {} : , | |
---|---|
R–>L | ++ —— ~(按位取反) !(data type) |
L–>R | * / % |
L–>R | + - |
L–>R | << >>(算术右移) >>> (无符号右移) |
L–>R | < > <= >= instanceof |
L–>R | == != |
L–>R | & |
L–>R | ^ |
L–>R | | |
L–>R | && |
L–>R | || |
L–>R | ? : |
R–>L | = *= /= %= |
+= -= <<= >>= | |
>>>= &= ^= |= |
- () {} 等不可分割的存在的符号
- 单目运算符
- 算术运算符
- 位移运算符
- 逻辑运算符
- 三元运算符
- 赋值运算符
标识符的命名规则和规范
1.规则
- 凡是可以自己起名字的地方都叫标识符
- 由26个英文字母大小写,0~9 _ 或$组成
- 数字不可以开头
- 不可以使用关键字和保留字,但能包含关键字和保留字
- 严格区分大小写,长度无限制
- 标识符不可含空格
xixi √
xixi12 √
1xixi ×
xi-xi ×(此处包含了减号) int a-b = 10;(×)
xi xi ×
xi$4 √
class ×
int ×
double ×
public ×
static ×
goto ×(goto是一个保留字)
stu_name √
2.规范(更加专业)
-
包名:多单词组成时所有的字母都小写
com.xixi.src
-
类名、接口名:多单词组成时,所有单词的首字母大写
XxxYyyZzz [大驼峰]
-
变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写
xxxYyyZzz [小驼峰 简称驼峰法]
tankShotGame
-
常量名:所有字母都大写。多单词时每个单词用下划线连接
xxx_yyy_zzz
TAX_RATE
关键字
有特殊含义,专门用途的字符串(单词)
使用时会自动高亮
不可再作为标识符,不可再用于定义变量和方法名
保留字
现有java版本尚未使用,但以后的版本可能会作为关键字使用。自己命名标识符时应当避免使用
byValue cast future generic inner operator outer rest var goto const
键盘输入语句
扫描器(对象)用于接受用户输入的数据
Scanner
- 导入该类的所在包, java.util.*
- 创建该类的对象(声明变量)
- 调用里面的功能
public class Input {
//编写一个main方法
public static void main(String[] args) {
//演示接受用户的输入
//创建一个Scanner对象,new创建一个对象
//scanner 就是Scanner类的对象
Scanner scanner = new Scanner(System.in);
System.out.println("请输入名字");
//程序到这里时,会等待用户输入
String name = scanner.next();//接受用户的输入的字符串
System.out.println("请输入年龄");
int age = scanner.nextInt();//接受用户的输入的int
System.out.println("请输入薪水");
double sal = scanner.nextDouble();//接受用户的输入的double
System.out.println("人的信息如下");
System.out.println("名字 = " + name
+ " 年龄 = " + age + " 薪水 = " + sal);
}
}
进制
-
二进制,满二进一(以0b或者0B开头)
int n1 = 0b1010;//10
-
十进制
-
八进制(以数字0开头)
int n2 = 01010;//520 //f -->15 //10 -->16
-
十六进制 0-9及A(10)-F(15){a(10)-f(15)} 满十六进一( 以数字0x开头)
int n3 = 0x10101;//65793
进制转换
- 其他进制转十进制
- 二进制转十进制
从最低位(右边)开始,将每个位上的数提取出来,乘以2的(位数-1)次方
然后求和0b110001100 = 4 + 8 + 2 ^ 7 + 2 ^ 8 = 12 + 128 + 256 = 396
- 八进制十进制
从最低位(右边)开始,将每个位上的数提取出来,乘以8的(位数-1)次方
然后求和0234 = 4 * 8 ^0 + 3 * 8 ^1 + 2 * 8 ^ 2 = 4 + 24 + 128 = 156
0246 = 6 + 4 * 8 + 2 * 8 * 8 = 6+32+128=166
- 十六进制转十进制
从最低位(右边)开始,将每个位上的数提取出来,乘以16的(位数-1)次方
然后求和0x23A = 10 * 16 ^ 0 + 3 * 16 ^1 + 2 * 16 ^ 2 = 10 + 48 + 512 = 570
0xA45 = 5 + 4 * 16 + 10 * 16 * 16 = 5+64+2560=2629
- 十进制转其他进制
- 十进制转二进制
将该数不断除以2,直到商为0为之,然后将每步得到的余数倒过来,就是对应的二进制
34 = 0b00100010
123 = 0b0111011
- 十进制转八进制
将该数不断除以8,直到商为0为之,然后将每步得到的余数倒过来,就是对应的八进制
131 = 0203
678 = 01246
- 十进制转十六进制
将该数不断除以16,直到商为0为之,然后将每步得到的余数倒过来,就是对应的十六进制
237 = 0xED
8912 = 0x22D0
- 二进制转八进制和十六进制
- 二进制转八进制
从低位开始,将二进制位每三位一组,转成对应的八进制数
0b 011(3) 010(2) 101(5)—>0325
0b011(3) 100(4) 101(5)—>0345
- 二进制转十六进制
从低位开始,将二进制位每四位一组,转成对应的十六进制数
0b 1101(13) 0101(5)—>0xD5
0b0011(3) 1001(9) 0110(6)—>0x396
-
八进制和十六进制转二进制
-
八进制转二进制
将八进制数每一位,转成对应的一个三位的二进制数即可
0 2(010) 3(011) 7(111)—->0b010011111
0 1(001) 2(010) 3(011) 0(000)—>0b001010011000
-
十六进制转二进制
将十六进制数每一位,转成对应的一个四位的二进制数即可
0x 2(0010) 3(0011) B(1011)—>0b001000111011
0x A(1010) B(1011) 2(0010) 9(1001)—>0b1010101100101001
-
原码、反码、补码
- 二进制的最高位是符号位:0表示正数,1表示负数(符号位直接向右旋转90% 0—>0 1—>-)
- 正数的原码、反码、补码都一样(三码合一)
- 负数的反码=它的原码符号位不变,其他位取反
- 负数的补码=它的反码+1,负数的反码 = 负数的补码-1
- 0的反码补码都是0
- java没有无符号数,java的数都是有符号的
- 在计算机运算时,都是以补码的方式来运算的(利用补码运算,使正数和负数统一起来)
- 当我们看运算结果时,要看原码
位运算符
1.& | ^ ~
-
按位与(&):两位全为1、结果为1,否则为0
-
按位或(|):两位有一个为1,结果为1,否则为0
-
按位异或(^):两位一个为0,一个为1,结果为1,否则为0
-
按位取反(~):0-1 1-0(符号位也需要取反)
public class BitOperator { //编写一个main方法 public static void main(String[] args) { System.out.println(2&3);//2 //原2 00000000 00000000 00000000 00000010 //正数原反补相同 //补2 00000000 00000000 00000000 00000010 //原3 00000000 00000000 00000000 00000011 //补3 00000000 00000000 00000000 00000011 //00000000 00000000 00000000 00000010 //00000000 00000000 00000000 00000011 //00000000 00000000 00000000 00000010(&后的补码,而这个数是正数,则即是原码) //打印出的就是 2 System.out.println(~-2);//1 //原10000000 00000000 00000000 00000010 //反11111111 11111111 11111111 11111101 //补11111111 11111111 11111111 11111110 //00000000 00000000 00000000 00000001(取反后的补码) //java取反符号位同样改变 // System.out.println(~2);//-3 //00000000 00000000 00000000 00000010 //11111111 11111111 11111111 11111101 //11111111 11111111 11111111 11111100 //10000000 00000000 00000000 00000011//-3 System.out.println(2|3);//3 //00000000 00000000 00000000 00000010 //00000000 00000000 00000000 00000011 //00000000 00000000 00000000 00000011//3 System.out.println(2^3);//1 //000000000 000000000 00000000 00000010 //000000000 000000000 00000000 00000011 //000000000 000000000 00000000 00000001//1 System.out.println(~-5);//4 //10000000 00000000 00000000 00000101 //11111111 11111111 11111111 11111010 //11111111 11111111 11111111 11111011 // //00000000 00000000 00000000 00000100//4 System.out.println(13&7);//5 //13原00000000 00000000 00000000 00001101 //7原 00000000 00000000 00000000 00000111 // 00000000 00000000 00000000 00000101//5 System.out.println(5|4);//5 //5原 00000000 00000000 00000000 00000101 //4原 00000000 00000000 00000000 00000100 //结果00000000 00000000 00000000 00000101//5 System.out.println(-3^3);//-2 //-3原10000000 00000000 00000000 00000011 //-3反11111111 11111111 11111111 11111100 //-3补 11111111 11111111 11111111 11111101 // //3原(补) 00000000 00000000 00000000 00000011 //结补 11111111 11111111 11111111 11111110 // //结反 11111111 11111111 11111111 11111101 //结原 10000000 00000000 00000000 00000010//-2 } }
2.>> << >>>
-
算术右移(>>):低位溢出,符号位不变,用符号位补溢出的高位
int a = 1 >> 2;// (标记a)000000(标记b)01----> 00(标记a)000000(标记b) //本质: 1 / 2 / 2 //标记b后的01已被吃掉 //标记a前面一个0是符号位,一个是补位
-
算术左移(<<):符号位不变,低位补0
int c = 1 << 2;// 00(标记a)000001(标记b)----> (标记a)000001(标记b)00 //本质:1 * 2 * 2 //标记a前的两个0已被左移吃掉了 //标记b后的两个0用于补位
-
逻辑右移(>>>):也叫无符号右移,低位溢出,高位补0
-
特别说明:无<<<符号
public class BitOperator02 {
//编写一个main方法
public static void main(String[] args) {
System.out.println(1 >> 2);//0 1 / 2 / 2
System.out.println(1 << 2);//4 1 * 2 * 2
System.out.println(4 << 3);//32 4 * 2 * 2 * 2
//00000100
//0010000 32
System.out.println(15 >> 2);//3 15 / 2 / 2
System.out.println(1 >> 2);//0
System.out.println(-1 >> 2);//-1
//10000000 00000000 00000000 00000001
//11111111 11111111 11111111 11111110
//11111111 11111111 11111111 11111111
//
//11111111 11111111 11111111 11111111
//11111111 11111111 11111111 11111110
//10000000 00000000 00000000 00000001
System.out.println(1 << 2);//4
System.out.println(-1 << 2);//-4
//10000000 00000000 00000000 00000001
//11111111 11111111 11111111 11111110
//11111111 11111111 11111111 11111111
//
//11111111 11111111 11111111 11111100
//11111111 11111111 11111111 11111011
//10000000 00000000 00000000 00000100//-4
System.out.println(3 >>> 2);//0
}
}
10000000 00000000 00000000 00000001
//11111111 11111111 11111111 11111110
//11111111 11111111 11111111 11111111
//
//11111111 11111111 11111111 11111111
//11111111 11111111 11111111 11111110
//10000000 00000000 00000000 00000001
System.out.println(1 << 2);//4
System.out.println(-1 << 2);//-4
//10000000 00000000 00000000 00000001
//11111111 11111111 11111111 11111110
//11111111 11111111 11111111 11111111
//
//11111111 11111111 11111111 11111100
//11111111 11111111 11111111 11111011
//10000000 00000000 00000000 00000100//-4
System.out.println(3 >>> 2);//0
}
}