Java 编程入门学习笔记-day02
1. 复习
class ReviewTest{
public static void main(String[] args){
//拓展1
char c1 = '5';
char c2 = 5;
System.out.println(c1 == c2);//false
char c3 = 97;
char c4 = 'a';
System.out.println(c3 == c4);//true
System.out.println(c4 + 1);//98
System.out.println((int)c4);//97
int i = 10;
System.out.println((float)i);//10.0
//拓展2：
System.out.println(0.1 + 0.2);
System.out.println((0.1 + 0.2) == 0.3);//false
}
}
2. 进制与进制间的运算
2.1 进制
class BinaryTest {
public static void main(String[] args) {
int num1 = 0b10;//二进制
int num2 = 0127;//八进制
int num3 = 234;//十进制
int num4 = 0X234F;//十六进制
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
System.out.println(num4);
int i = 128;
System.out.println((byte)i);//-128
//开发中，如果需要涉及进制之间的转换的话，可以使用Integer类中提供的相关方法
System.out.println(Integer.toBinaryString(12321));
System.out.println(Integer.toHexString(12321));
System.out.println(Integer.toOctalString(12321));
}
}
2.2 二进制与十进制间的转换
- 原码、反码、补码
正数的原码、反码、补码三码合一
二进制的整数有如下三种形式：（负数）
原码：直接将一个数值换成二进制数。最高位是符号位
负数的反码：是对原码按位取反，只是最高位（符号位）确定为1。
负数的补码：其反码加1。
计算机以二进制补码的形式保存所有的整数。
正数的原码、反码、补码都相同
负数的补码是其反码+1
3. 算术运算符
/*
一、测试算术运算符的使用
+ - + - * / % (前)++ (后)++ (前)-- (后)-- +
*/
class AriTest {
public static void main(String[] args) {
int i1 = +12;
System.out.println(i1);
//除法： /
int m1 = 12;
int n1 = 5;
int result1 = m1 / n1;
System.out.println(result1);//2
double result2 = m1 / n1;
System.out.println(result2);//2.0
double result3 = m1 / n1 + 0.0;
System.out.println(result3);//2.0
double result4 = m1 / (n1 + 0.0);
System.out.println(result4);//2.4
double result5 = (double)m1 / n1;
System.out.println(result5);//2.4
int result = m1 / n1 * n1;
System.out.println(result);//10
//取余（取模）： %
//结果的符号与被模数的符号相同
//开发中常常使用 %运算来判断是否可以除尽的场景。比如：判断一个数是否是一个偶数。
int k1 = 13;
int j1 = 5;
System.out.println(k1 % j1);//3
int k2 = -13;
int j2 = 5;
System.out.println(k2 % j2);//-3
int k3 = 13;
int j3 = -5;
System.out.println(k3 % j3);//3
int k4 = -13;
int j4 = -5;
System.out.println(k4 % j4);//-3
/*
(前)++ : 先自增1，后运算
(后)++ : 先运算，后自增1
*/
int a1 = 10;
int b1 = a1++;
System.out.println("a1 = " + a1);//11
System.out.println("b1 = " + b1);//10
int a2 = 10;
int b2 = ++a2;
System.out.println("a2 = " + a2);//11
System.out.println("b2 = " + b2);//11
short s = 10;
s = (short)(s + 1);
System.out.println(s);
short s1 = 10;
//s1++;//自增1，没有改变变量本身的数据类型
++s1;
System.out.println(s1);
//结论：开发中如果出现每次增长1情况，建议使用++的操作，而不使用+1的操作。
/*
(前)-- : 先自减1，后运算
(后)-- : 先运算，后自减1
*/
//+ :作为字符串的连接运算，运算结果为String
int num = 10;
String strNum = num + "";
System.out.println(strNum);
//字符串转换为基本数据类型：编译失败
//int num1 = (int)strNum;
//System.out.println(num1);
//String如何转换为int？后面讲到Integer会讲到。
int num2 = Integer.parseInt(strNum);
System.out.println(num2 + 1);
}
}
- 练习
/*
算术运算符的课后练习：
随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：
例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1
*/
class AriExer {
public static void main(String[] args) {
int num = 435;
int ge = num % 10;//个位
int shi = num / 10 % 10;//十位
//int shi = num % 100 / 10;//十位
int bai = num / 100;//百位
System.out.println("个位数：" + ge);
System.out.println("十位数：" + shi);
System.out.println("百位数：" + bai);
}
}
4. 赋值运算符
/*
二、赋值运算符的使用
= += -= *= /= %=
赋值运算符，尤其是+= -= *= /= %=，运算的结果，不改变原有变量的数据类型！
*/
class SetValueTest {
public static void main(String[] args) {
// = 赋值符号
int n1 = 10;
//情况1：两个变量的值相同时，连续赋值
int n2,n3;
n2 = n3 = 100;
//情况2：两个变量的值不同：
int n4 = 100;
int n5 = 200;
//情况2可以改为如下形式：
int n6 = 100,n7 = 200;
// +=
int m = 20;
m += 3; //与 m = m + 3 类似
System.out.println(m);//23
m %= 3; //与 m = m % 3 类似
System.out.println(m);//2
//特别的：
short s1 = 10;
s1 += 3; // s1 = s1 + 3?
System.out.println(s1);//13
//结论：开发中，需要某个整数增长值为n，则可以使用 += n的方式，要优于 + n的方式
//题目：
int i1 = 2;
i1 *= i1++; //i1 = i1 * i1++
System.out.println(i1);
//练习
int i = 1;
i *= 0.1; //编译能通过
System.out.println(i);// 0
i++;
System.out.println(i);//1
//练习
int m1 = 2;
int n = 3;
n *= m1++; // n = n * m1++
System.out.println("m1=" + m1);//3
System.out.println("n=" + n);//6
//练习
int k = 10;
k += (k++) + (++k); //k = k + (k++) + (++k)
System.out.println(k);//32
}
}
5.比较运算符
/*
三、比较运算符（关系运算符）
== != > < >= <= instanceof
1. 比较运算符的结果都是boolean类型
2. 特别关注 == 与 = 的区别
*/
class CompareTest {
public static void main(String[] args) {
boolean b1 = false;
boolean b2 = true;
//System.out.println(b1 == b2);//false
//System.out.println(b1 = b2);//true
if(b1 = b2){//if(b1 == b2){
System.out.println("1111");
}else{
System.out.println("2222");
}
int i = 10;
int j = 20;
System.out.println(i == j);//false
System.out.println(i = j);//20
}
}
6.逻辑运算符
/*
四、逻辑运算符的使用
& && | || ! ^
说明：
1. 逻辑运算符只能适用于boolean类型的变量
2. 运算的结果也是boolean类型
3. 重点区分：& && 、 | ||
*/
class LogicTest {
public static void main(String[] args) {
boolean b = true;
System.out.println("!b = " + !b);//false
/*
& 与 && 的相同点：当符号左边是true时，会执行符号右边的操作。
不同点：
&:当符号左边是false时，仍然会执行符号右边的操作。
&&:当符号左边是false时，不会执行符号右边的操作。
结论：开发中，建议使用 &&
*/
boolean b1 = true;
b1 = false;
int a1 = 10;
if(b1 & (a1++ > 0)){
System.out.println("执行if语句");
}else{
System.out.println("执行else语句");
}
System.out.println("a1 = " + a1);
boolean b2 = true;
b2 = false;
int a2 = 10;
if(b2 && (a2++ > 0)){
System.out.println("执行if语句");
}else{
System.out.println("执行else语句");
}
System.out.println("a2 = " + a2);
/*
| 与 || 相同点：当符号左边是false时，二者都会执行符号右边的操作
不同点：
|：当符号左边是true时，仍然执行符号右边的操作
||：当符号左边是true时，不再执行符号右边的操作
结论：开发中，建议使用 ||
*/
System.out.println("###########");
boolean b3 = false;
b3 = true;
int a3 = 10;
if(b3 | (a3++ > 0)){
System.out.println("执行if语句");
}else{
System.out.println("执行else语句");
}
System.out.println("a3 = " + a3);
boolean b4 = false;
b4 = true;
int a4 = 10;
if(b4 || (a4++ > 0)){
System.out.println("执行if语句");
}else{
System.out.println("执行else语句");
}
System.out.println("a4 = " + a4);
}
}
7.位运算符
7.1 << >> >>>
/*
五、位运算符的使用
<< >> >>> & | ^ ~
说明:
1. 位运算符针对的是数值类型的变量或常量
2. 在一定范围内，每左移一位(<<)，则相当于原数据 * 2。 ---> 过犹不及
3. >> : 如果是正数右移，则高位补0；
如果是负数右移，则高位补1
4. 在一定范围内，每右移一位(>>)，则相当于原数据 / 2。
5. >>> : 无符号右移，不管这个整数是正数还是负数，无符号右移后，高位都使用0补齐。
面试题： 最高效的方式计算2 * 8 ? 2 << 3 或 8 << 1
*/
class BitTest {
public static void main(String[] args) {
System.out.println("3 << 2 : " + (3 << 2));
System.out.println("-3 << 2 : " + (-3 << 2));
System.out.println("3 << 29 : " + (3 << 29));
System.out.println("3 << 30 : " + (3 << 30));
System.out.println("23 >> 2 : " + (23 >> 2));
System.out.println("-23 >> 2 : " + (-23 >> 2));
}
}
7.2 & | ^ ~
//举例：如何交换两个变量的值
int m = 10;
int n = 5;
System.out.println("m = " + m + ",n = " + n);
//交换两个变量的值
//方式1：掌握，定义一个临时变量
//优点：适用于各种数据类型
int temp = m;
m = n;
n = temp;
//方式2：好处：不需要额外开辟一块内存空间。
//弊端：① 可读性差 ② 有可能超出变量的储值范围 ③ 适用范围有限：数值类型
//m = m + n;
//n = m - n;
//m = m - n;
//方式3：好处：不需要额外开辟一块内存空间。
//弊端：① 可读性更差 ③ 适用范围有限：数值类型
//m = m ^ n;
//n = m ^ n;
//m = m ^ n;
System.out.println("m = " + m + ",n = " + n);
8. 三元运算符
/*
六、三元运算符的使用
格式： (条件表达式)? 表达式1 : 表达式2
1. 要求表达式1 和 表达式2 的类型得一致。
2. 三元运算符的使用都可以转换为if-else这样的分支结构。
反之，if-else分支结构不一定能转换为三元运算符。
3. 如果三元运算符和if-else结构都可以使用的话，建议使用三元运算符，因为执行效率更高！
*/
class SanYuanTest {
public static void main(String[] args) {
int m = 10;
int n = 10;
//获取两个数的较大值
int max = (m > n)? m : n;
System.out.println(max);
double d1 = (m > n)? 1 : 0.1;
String maxStr1 = (m > n)? "m大" : "n大";
//String s = 10;//编译不通过
String maxStr2 = (m > n)? "m大" : ((m == n)? "相等" : "n大");
System.out.println(maxStr2);
//练习：如何获取三个数的最大值？
int i = 10;
int j = 13;
int k = 5;
int max1 = (i > j)? i : j;
int max2 = (max1 > k)? max1 : k;
System.out.println(max2);
//可以嵌套：
//int max2 = (((i > j)? i : j) > k)? ((i > j)? i : j) : k;
}
}
9. 运算符的优先级
- 多种运算符集合在一起，是有执行的先后顺序的，即为优先级：
- 我们不用刻意记忆上述的优先级。大家在使用时，可以通过()标识优先级比较高的结构即可。
2996
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
