Java基础复习
1 进制
世界上又两种人，认识二进制的和不认识二进制的人
1.1 常见进制
283975 #按照权值进行分型
2 * 10^5 #该位置数字乘以权值
+ 8 *10^
+ 3*10^3
+ 9*10^2
+ 7*10^1
+ 5*10^0
# 权值 = 10^N 十进制数
- 十进制：逢10进1，计算权值时以10为底的n次幂
- 二进制：逢2进1，计算权值时以2为底的n次幂
- 八进制：逢8进1，计算权值时以8为底的n次幂
- 十六进制：逢16进1，计算权值时以16为底的n次幂(1..9、A...F)
0xffff 使用前缀ox表示该数字为十六进制数 07使用0前缀表示八进制 0b二进制
示例：00110110转换为十进制数
2^1 + 2^2 + 2^4 + 2^5 = 2+4+16+32 = 54
示例：0x2371转换为十进制数
1*16^0 + 7*16^1 + 3*16^2 + 2*16^3 = 1+112+768+8192 = 9073
1.2 进制对照
二进制
八进制
十六进制
十进制
0000
0
0
0
0001
1
1
1
0010
2
2
2
0011
3
3
3
0100
4
4
4
0101
5
5
5
0110
6
6
6
0111
7
7
7
1000
10
8
8
1001
11
9
9
1010
12
A
10
1011
13
B
11
1100
14
C
12
1101
15
D
13
1110
16
E
14
1111
17
F
15
10000
20
F1
16
10001
21
F2
17
ps. 0b1111 1111 = 0x ff ps.计算机底层存储数据使用二进制
示例：将十六进制数 0x2B3C7F82转换为二进制
2 B 3 C 7 F 8 2
0010 1011 0011 1100 0111 1111 1000 0010
示例：将二进制数 01111010111010101010110010101100转十六进制
0111 1010 1110 1010 1010 1100 1010 1100
6 A E A A C A C
结果为：0x6AEAACAC
1.3 符号位
正数的补码是其原码，负数的补码为其反码加一
ps.反码即该编码各位上的数依次取反的结果
示例：
0000 0111 byte型整数：十六进制 0x07 十进制 7
1110 0110 byte型负数：十六进制 0x1A 十进制 26
减一：1110 0110 - 1 = 1110 0101 取反：0001 1010
byte型
最大值：1111 1111 ： -1
最小值：1000 1000 ： -128
short型
最大值：0111 1111 1111 1111 = 0x7FFFF = 32767
最小值：1000 0000 0000 0000 = 0x8000 = -32768
int型
最大值：0111 1111 1111... = 0x7FFFFFFF
最小值：1000 0000 0000... = 0x80000000
long型
最大值：0x7FFFFFFFFFFFFFFF
最小值：0x8000000000000000
char型
最大值：0xFFFF
最小值：0x0000
2 运算符
2.1 位运算符
位运算
运算
示例
<<
左移(保留符号位)
3<<2 = 12 (左移两位 3_2_2)
>>
右移(保留符号位)
3>>1=1 （0011 => 0001）
>>>
无符号右移
3>>>1
&
与运算
6 & 3 = 2
|
或运算
6 | 3 = 7
^
异或运算
6 ^ 3 = 5
~
取反
~ 6 = -7
示例：
public class BinaryTest{
public static void main(String[] args){
byte b = (byte)0xC2; // 0x000000C2
System.out.println(b);
System.out.println(b << 2); //-248
}
}
ps.位运算是直接对二进制进行运算
public class BinaryTest{
public static void main(String[] args){
int n1 = 0xd7;
int n2 = 0xc5;
// int n1 = 0x7a;
// int n2 = 0x9c;
/* d7:1101 0111
c5:1100 0101
&: 1100 0101
|: 1101 0111
^: 0001 0110
ni:0011 1010
n2:0011 1010
*/
// 0111 1010
// 1001 1100
// 0001 1000 = 24
System.out.println(n1 & n2);
// 0111 1010
// 1001 1100
// 1111 1110 = 254
System.out.println(n1 | n2);
// 0111 1010
// 1000 0101 = -123
System.out.println(~n1);
// 1001 1100
// 0110 0011 = -157
System.out.println(~n2);
// 0111 1010
// 1001 1100
// 1110 0110 = 230
System.out.println(n1 ^ n2);
}
}
2.2 自增注意事项
int n = 10;
n = n++;
system.out.println("n="+n);
//n的值为10 赋值语句从右至左
// 右n的值为10待赋值给左
// 右n自增为11
// 将待赋值的10赋值给左侧
//结束
2.3 += 和 + 的区别
short s =3;
s = s+2; //发生了类型变化 右侧为int型
s+=2; // 未发生类型变化
2.4 比较运算符
运算符
运算
范例
结果
适用范围
==
相等于
1 == 1
true
所有数据
!=
不等于
1 != 1
false
所有数据
<
小于
2<3
true
基本数据
>
大于
2>3
false
基本数据
<=
小等于
2<=3
true
基本数据
>=
大等于
2>3
false
基本数据
instanceof
2.5 逻辑运算符
- &逻辑与
- |逻辑或
- !逻辑非
- && 短路与
- ||短路或
- ^逻辑异或
ps. & 运算两边都会参与运算 不会短路 && 运算会短路
a
b
a&b
a|b
!a
a&&b
a^b
a||b
true
fase
true
true
fase
true
fase
true
true
fase
fase
true
fase
fase
true
true
fase
true
fase
true
true
fase
true
true
fase
true
fase
fase
true
fase
fase
fase
示例：
3<x<6 //错误写法
x>3 & x<6
int x = 1;
int y = 1;
if(x++ == 2 & ++ y =2) System.out.println("判断为真！")；
//此处 x最终为2 y最终为2
int x = 1;
int y = 1;
if(x++ == 2 && ++ y =2) System.out.println("判断为真！")；
//此处 x最终为2 y最终为1 发生了运算短路
2.5 三目运算符
(条件表达式)?表达式1:表达式2
表示式为ture取表达式1的值
表达式为fals取表达式2的值
变量如下： int n = 10; int m = 20; int k = 40; int max; 示例：取两个数中较大的数 max = (n>m)?n:m; 示例：取出三个数中的较大数 max = (n>m)？(n>k)?n:k:(m>k)?m:k
2.6 运算符优先级
从左到右，搞优先级优先进行运算
3 流程控制
- 顺序结构：程序按顺序从上到下执行
- 分支结构：根据判断条件选择分支进行执行
- 循环结构：按照循环条件进行循环执行
3.1 分支结构
3.1.1 基本if语句
当括号中的条件为真时执行后面的分支内容。
ps.java中分支结构括号中的内容必须时布尔型
if(a == 0) System.out.println("a等于0")；
if(a != 0 ){
System.out.println("a不等于0")；
System.out.println("请重新输入!");
}
3.1.2 if-else语句
当括号中的条件为真时，执行if后的分支内容，括号条件为假时，执行else后的分支内容。
if(a == 0) System.out.println("a等于0")；
else{
System.out.println("a不等于0")；
System.out.println("请重新输入!");
}
3.1.3 if-else嵌套
判断规则与if-else相同，将if-else进行嵌套。
if(a == 0) System.out.println("a等于0");
else if(a == 1) System.out.println("a等于0");
else {
if (a==3) System.out.println("a等于3");
System.out.println("a不等于1或者0");
}
3.1.4 switch分支结构
选择变量
变量的数据类型：byte，int，char，short，String，枚举型
基本结构
switch(变量){
case 常量1：
...
break；
case 常量2：
...
break;
case 常量3：
...
break;
case 常量4：
...
break;
case 常量5：
...
break;
default:
...
break;
}
3.2 循环结构
在某些条件满足的情况下，反复执行特定代码的功能，包含一下四个部分。
- 初始化部分(init_statement)
- 循环条件部分(test_exp)
- 循环体部分(body_statement)
- 迭代部分(alter_statement)
ps.while循环、do/while循环、for循环
while循环
语法格式
while(布尔型测试表达式){
...
循环条件修改语句；
}
示例：
public void testWhile(){
int count;
//初始化语句
int i = 1;
//循环因子
while(i<10){ //循环条件
count += i;
//循环体语句
i++;
//迭代语句
}
System.out.println("count:"+count);
}
do-while循环
语法格式
do{
...
循环条件修改语句；
}while(布尔型测试表达式)
示例：
public void testDoWhile{
int result = 0,i=1;
//初始化语句及循环因子
do{
result+=i
//循环体语句
i++
//迭代语句
}while(i<=5)//循环条件
System.out.println("result:"+result);
}
for循环
语法格式
for(初始化语句;布尔测试表达式;循环条件修改语句){
...
}
int count;
for(int i=1; i<100; i++) count+=i;
System.out.println("count:"+count);
无限循环
当循环次数不确定时，优选while循环。
示例：
boolean flag = true;
while(flag){ ... }
do{...}while(flag)//至少循环一次
示例：
boolean flag = true;
for(;;;){...}
for(;flag;){...}
3.3 特殊流程控制
3.3.1 break 语句
break语句用于终止某个语句块的执行。
示例：
for(int i=0; i<10; i++)
if( i==3 ) break;
label：for(int i=0; i<10; i++){
for(int i=0; i<10; i++)
if( i==3 ) break lable;
}
3.3.2 countinue语句
只能用于循环语句，跳过某次循环。
3.3.3 return语句
结束方法，方法执行的返回。
4 方法
某种功能的封装 方法 = 方法签名 + 方法体
方法是类或对象行为特征的抽象，也成为函数。Java中方法不能独立存在，必须在类中定义。
语法格式
权限修饰符 返回值类型 方法名(参数类型 参数1,参数类型 形参2,...){
...
return 返回值;
}
示例：
public String printHello(int name){//方法签名
Stirng hello = "Hello! "+ name;
return hello;
}
public static void main(String args[]){
//方法调用
String welcome = printHello();
//int a = printHello(); ×
}
形式参数：在方法被调用时用于接收外部传入的数据的变量
参数类型：形式参数的数据类型
返回值：方法在执行完毕后返还给调用它的程序的数据
返回值类型：方法要返回的结构的数据类型
实际参数：调用方法时实际穿个函数形式参数的数据
ps. 返回值为void的方法表示无返回值
4.1 重载
重载让方法调用变得简单
在同一个类中，方法名相同，参数不同就形成重载。参数不同体现在类型不同、顺序不同、参数个数不同。
示例：
public class OverLoadTest{
public static int add(int a, int b){
return a+b;
}
public static int add(int a, byte b){
return a+b;
}
public static int add(int a, double b){
return (int)a+b;
}
}
4.2 方法的参数传递
java中只有值传递，形参是实参的一个复制品。
4.3 方法调用的原理
4.3.1 栈帧
方法栈中的组成单元，包括了方法及其局部变量。
4.3.2 方法栈
一个先进后出的结构，用于存放方法，其单元由栈帧组成。
4.3.3 方法栈原理
说明：
- main函数中调用add方法
- main函数调用参数传递后压栈
- 开始add方法的方法体执行
- add方法中又调用test方法
- add方法入栈
- 进行test方法执行
- test执行完成出栈
- add执行完成出栈 (将返回值拷贝到临时空间)
- main方法执行 (从临时取获得返回值继续执行)
4.4 跨类调用方法
通过类名大写加上.的方式可以访问该类的静态方法。
public class Method{
public static String getMethod(){
return "Method";
}
}
public class Test{
public static void main(String[] args){
String method = Method.getMethod;
Sysem.out.println()
}
}
