进制转换
计算机底层是基于二进制。底层是基于数字电路 0 1
进制
十进制 满10进1 0-9
二进制 满2进1 0,1 0b或0B开头
八进制 满8进1 0-7 0开头
十六进制满16进1 0-9 A-F 0x或0X开头
数据单位
bit位：最小单位
byte字节： 1byte=8bit 1B=8b 范围-128--127
1KB=1024B 1MB=1024KB1GB=1024MB1TB=1024GB
R进制的基本概念
R进制有R个基数，逢R进位，进位当R
十进制(0-9) 二进制(0,1)
0 0000
1 0001
2 0010
3 0011
4 0100
5 0101
6 0110
7 0111
8 1000
9 1001
10 1010
权重：
R进制的权重从低位开始 R^(位数-1)
十进制：
1203(10)=3*10^0+0*10^1+2*10^2+1*10^3
二进制转十进制:按权重相加
1011(2)=1*2^0+1*2^1+0*2^2+1*2^3=11(10)
任何进制转十进制都可以
十进制转二进制
14/2=7......0
7/2=3.......1
3/2=1.......1
1/2=0.......1
余数倒写 1110（2）
十进制转R进制 用R除
八进制
基数0-7
0012(8)
十六进制
基数 0-9ABCDEF
2A(16)=10*16^0+2*16^1(10)
二进制和八进制的转换 2^3=8
二进制 八进制
000 000
001 001
010 002
011 003
100 004
101 005
110 006
111 007
1 101 110(2)=156(8)
原码 反码 补码
byte 1个字节 11111111(2) 2^8-1=255(0-255 256个数) -128-127
计算机底层使用的是二进制的补码
最高位是符号位，0代表正数，1代表负数
原码
正数： +7(10) 00000111(2)
负数： -7(10) 10000111(2)
反码
正数： +7(10) 00000111(2) 正数的原码反码补码都一样
负数： -7(10) 11111000(2) 符号位1，其他位按位取反：0变1，1变0
补码
正数： +7(10) 00000111(2) 正数的原码反码补码都一样
负数： -7(10) 11111001(2) 补码就是反码+1
从内存中获取了11111001，这个数是多少
如果最高是0，是正数，后面各位按权相加
如果最高是1，是负数数，
补码-1，变成反码 11111001-1=11111000
反码的非符号位按位取反,变成原码 11111000取反10000111
后面各位按权相加
为什么使用补码
0的表示统一
原码 反码 补码
+0 00000000 00000000 00000000
-0 10000000 11111111 00000000
所有的减法运算都可以使用+补码
7-2=7+(-2)
-2 10000010 11111101 11111110
00000111
+11111110
--------------------
00000101
常量
字面值常量
定义常量
public static void main(String[] args) {
//字面值常量
System.out.println(1);
System.out.println(1.1);
System.out.println('a');
//还是输出内存中的1，重新分空间，存储1，不是上面那个1，无法获取内存地址
System.out.println(1);
}赋值运算符
= 等号右边的值赋给左边
交换两个数
算术运算符
public static void main(String[] args) {
//算法运算符 + - *(乘) /(除) %(模运算，取余)
System.out.println(5+2);
System.out.println(5-2);
System.out.println(5*2);
System.out.println(5/2);
System.out.println(5%2);
//除法运算有误差，以后有专门计算除法的方法
System.out.println(10.0/3);
}
public static void main(String[] args) {
// += /= */ /= %=
int a=1;
a+=5;
System.out.println(a);
int b=1;
b=b+5;
System.out.println(b);
}
public static void main(String[] args) {
int i=1;
System.out.println("i="+i);
//自增，变量自己+1 i+=1;
//++在后，当前位置，先使用原来的值，用完以后+1
//System.out.println(i++);;
//++在前，当前位置，先+1，然后使用
System.out.println(++i);
System.out.println("i="+i);
//测试--i 和 i--
}运算符的优先级
不用记，我们以后不知道优先级，自己添加小括号()控制优先级，无论多少层都是小括号嵌套
int a=((5+2)*5)*5;
键盘输入
导入包 位置:package和定义类中间
import java.util.Scanner;
创建对象
Scanner scanner=new Scanner(System.in);
调用方法
int num=scanner.nextInt();
关闭对象
scanner.close();
快捷键
导入包ctrl+shift+o
自动生成方法返回值变量 ctrl+shift+L
类型转换
基本类型的转换：boolean类型不能和其他七种类型转换
注意点：
- 整数字面值常量int，小数字面值常量double
- byte,short赋值的时候，主要不超过对应的范围，整数字面值常量int不需要转换
也就是说在使用的时候可以 整数可以直接赋值成int型，小数可以直接赋值给double型
但是不能把小数赋值成float型，不能把整数赋值成long型，声明long常量必须加“l”或“L”，声明float型后面要加“f”或‘F’（尾数为7位）
public static void main(String[] args) {
//整数字面值常量int，小数字面值常量double
int i=1111;
double d=1.111;
float f=13.2F;
System.out.println(Long.MAX_VALUE);
long mylong=9999999999L;
}
public static void main(String[] args) {
//整数字面值常量int，小数字面值常量double
//byte,short赋值的时候，主要不超过对应的范围，整数字面值常量int不需要转换
byte b1=127;
byte b2=128;
}自动类型转换
基本条件：
兼容类型目标类型大于源类型 左边=右边 小的赋值给大的
转换规则 byte,short,char—>int—>long—>float—>double
byte,short,char相互之间补转换，他们参与运算首先转换为int类型
如果一个操作数为double型，则整个表达式可提升为double型
public static void main(String[] args) {
// int i1=1;
// int i2=2;
// int i3=i1+i2;
// byte b1=1;
// byte b2=2;
// short s1=1;
// int s2=s1+b;
// int b3=b1+b2;
// int i=1;
// float f=1.1F;
// float j=i+f;
// int i=1;
// double d=1.1;
// double j=i+d;
}强制类型转换
注意：
1）运算结果不会改变本身的变量类型，比如short s1=10; s1=s1+2//编译失败；s1+=2；//不会改变数据类型,是因为这个包含了强制类型转换
2）字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型 如：String a=“43”；int i = Integer.parseInt(a)
3）boolean不能转换成其他的数据类型
基本条件：
兼容类型目标类型小于源类型 大的赋值给小的
目标=(数据类型)源
可能造成数据精度丢失或溢出
int i=1;
byte b1=5;
//+=会自动做强转，b1=(byte)(b1+i)
b1+=i;
byte b2=5;
b2=(byte) (b2+i);
byte b=(byte) 130;
System.out.println(b);
// 0000 0000 1000 0010
// 10000010 (补码)
// 10000001 (反码)
// 11111110 (源码)
System.out.println((byte)(127));
System.out.println((byte)(127+1));
System.out.println((byte)(127+2));字符和数字是兼容类型
public static void main(String[] args) {
char c='a';
char c1=(char) (c+1);
System.out.println(c);
System.out.println(c1);
int j=c1;
System.out.println(j);
System.out.println((char)j);
}boolean和和关系运算符
boolean类型只有两个取值 true false，后面的选择结构和循环结构中用来判断一个条件是否成立，决定后面的代码块是否执行
关系运算符：做比较，判断，关系运算的结果也是一个boolean值
> >= < <= !=(不等) ==(相等)
instance of 检查是否是类的对象，比如“hello”instance of String 为true
public static void main(String[] args) {
// boolean b1=true;
// boolean b2=false;
// System.out.println("b1="+b1);
// System.out.println("b2="+b2);
//
// int zhangScore=70;
// int liScore=80;
// System.out.println("张三的成绩是否大于李四的成绩？"+(zhangScore>liScore));
// boolean isHigh=zhangScore>liScore;
// System.out.println("张三的成绩是否大于李四的成绩？"+isHigh);
System.out.println("100>=100:"+(100>=100));
System.out.println("100>100:"+(100>100));
System.out.println("100==100:"+(100==100));
System.out.println("100!=100:"+(100!=100));
System.out.println("100==100:"+(100=100));
}
}程序逻辑结构
顺序结构选择结构（分支结构）循环结构
基本选择结构
if(条件){
//满足条件执行的代码块
}
如果满足条件只执行一条语句,{}可以省
如果满足条件只执行多条语句,{}不能省
编码规范： 不要省
public class MyTest13 {
//如果考试成绩大于98分，奖励
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("输入成绩");
int score=scanner.nextInt();
//后面不要有;，逻辑错误，条件控制的就是;空语句
if(score>98){
System.out.println("奖励1");
System.out.println("奖励2");
}
System.out.println("程序结束");
}
}逻辑运算符
连接简单条件，构成复制的条件
&& 逻辑与 并且 两边都为真，结果才为真
|| 逻辑或 或者 两边都为假，结果才为假
！ 逻辑非 取反 真变假，假变真
短路特性
||和&&具有短路特性，&&就是前面已经是false了后面判断条件将不会执行,||就是前面是true后，后面将不会执行
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
