Java 的运行原理
计算机可以处理数据计算逻辑
编程语言可以将人类的业务问题映射为数据计算逻辑
编辑Java源文件 xxx.java 接近人类语言
编译为 xxx.class 文件 这是 字节码，是Java虚拟机机器语言
机器语言 0 1 0 1 0 1
进制基础：0 1
在计算机内部只有 二进制
“～”取反运算 就是 0变1 1变0
补码：为了成本，解决负数问题，利用大数作为负数使用。
一种算法规定：以4位补码为例（理论，Java 8位 ==> 1 byte（-128～127） 16位 32位 (int) 64位 128位（Java不提供哦，太大太大））
正数的补码是他本身
高位为1的数作为负数使用
计算时候如果超过4位，自动溢出舍弃
补码是有部位的数 -8～7 不能表示超范围的数
在不超过范围情况下，补码满足数学运算，避免进行溢出计算
补码有对称现象
00 0000 -8 1000
01 0001 -7 1001
02 0010 -6 1010
03 0011 -5 1011
04 0100 -4 1100
05 0101 -3 1101
06 0110 -2 1110
07 0111 -1 1111
08 1000 00 0000
09 1001 01 0001
10 1010 02 0010
11 1011 03 0011
12 1100 04 0100
13 1101 05 0101
14 1110 06 0110
15 1111 07 0111
15 1111 + 1 = 10000 舍弃后 0000
1111 + 1 = 0000
？ + 1 = 0 ===> ? ==> -1
1111 + 1 = 0 ===> 1111 ===> -1
取反加1
～ -1 = 0 ～-2 = 1 ～-3 = 2
～（-n） = n - 1 ===> ～n = -（n + 1） ==> 1+～n = -n
EX:6的补码0110 ==> 取反 1001 ==> 加1 1010
package day02;/* * * int 类型在内存中是补码 * */public class Demo01 { public static void main(String[] args) { int i = -1;//在内存中i是32个1，以补码的形式存在！ System.out.println(Integer.toBinaryString(i)); i = 1;//31个0一个1，高位的0省略， System.out.println(Integer.toBinaryString(i)); }} Java中的数是补码 补码有正数也有服务 正数高位为0 负数高位为1 高位也就是符号位
int
-1 11111111 11111111 11111111 11111111
0 00000000 00000000 00000000 00000000
min 10000000 00000000 00000000 00000000
max 01111111 11111111 11111111 11111111
Java 采用补码计算，注意计算范围，避免溢出...
16进制 是2进制的简写形式
是2进制每4位对应一位的简写
本质上16进制就是2进制
16进制：是逢16进1 的计数规则
权： 256 16 1 每个数位上代表1的个数
321（16） 3*256+ 2*16+1= 801（10）
10进制 16进制 2进制
0 00 0000 0000
1 01 0000 0001
2 02 0000 0010
3 03 0000 0011
4 04 0000 0100
5 05 0000 0101
6 06 0000 0110
7 07 0000 0111
8 08 0000 1000
9 09 0000 1001
10 0a 0000 1010
11 0b 0000 1011
12 0c 0000 1100
13 0d 0000 1101
14 0e 0000 1110
15 0f 0000 1111
16 10 0001 0000
17 11 0001 0001
18 12 0001 0010
19 13 0001 0011
20 14 0001 0100
21 15 0001 0101
... ... ...
65 41 0100 0001
... .... ...
255 ff 1111 1111
-1: 1111 1111 1111 1111 1111 1111 1111 1111
f f f f f f f f
0: 0000 0000 0000 0000 0000 0000 0000 0000
0 0 0 0 0 0 0 0
min:1000 0000 0000 0000 0000 0000 0000 0000
8 0 0 0 0 0 0 0
max:0111 1111 1111 1111 1111 1111 1111 1111
7 f f f f f f f
package day02;/* * * 16进制 * 0xffffffff 就是表示16进制的ffffffff == > -1 * 就是简写，不用 11111111111111111111111111111111 */public class Demo02 { public static void main(String[] args) { int i = 0xffffffff;// -1 System.out.println(i); int max = 0x7fffffff; int min = 0x80000000; System.out.println(max); System.out.println(min); }} 利用 Java 虚拟机，将class翻译为机器语言
java内存
堆
java中的new运算就是在堆中创建：new创建的对象和数组
按照类型分配空间
由Java虚拟机的自动垃圾回收器来管理
栈
在局部的变量 也就是方法中声明的变量在栈中分配
栈 对应带 堆
方法区
从磁盘载入方法的内存，使用到那个方法载入那个方法。
Java 开发环境（32/64要傻傻分的清楚）
OS 64 Java 64
OS 64 Java 32
OS 32 Java 32
Java 5、6、7、8
JDK + Eclipse
Java 变量
逻辑上是一个代词
计算机内部代表一个数据
Java 是强类型语言：变量是强类型的
变量必须用明确类型声明
变量必须初始化以后才能使用
变量有作用域，离开作用域就回收
变量不能重复定义
违反了就有编译错误 E ... R ... R ... O ... R
package day02;/** * * Java 变量 * */public class Demo03 { public static void main(String[] args) { //int 是数据类型，整数类型，age是变量名 //System.out.println(age);//先声明才能使用,编译错误 age 没有找到 int age; //变量的声明，通知java有一个变量age //System.out.println(age);//没有初始化，编译错误，age 没有初始化 age = 18;//变量初始化 int QQ = 110; //int age;//重复定义，编译错误 System.out.println(age);//输出 System.out.println(QQ); {//代码块, String name = "lmdtx"; System.out.println(name); } //System.out.println(name);//变量有作用域，离开作用域就回收编译错误，没有name 变量 String name = "lmdtx"; System.out.println(name); //如果你敢学习下面的声明： int a; //小 int b; //心 int c; //老 int d; //子 int e; //打 int f; //死 int g; //你 }} Java 的数据类型
8中基本数据类型
byte 1字节 8位 存储1个字节数据
short 2字节 16位 兼容性问题，一般不用
int 4字节 32位 存储整数
long 8字节 64位 存储长整数
float 4字节 32位 存储浮点数
double 8字节 64位 存储双精度浮点数
char 2字节 16位 存储以一个字符
boolean 1字节 8位 存储逻辑变量 true false
Java 中的直接量 默认类型就是int
就是直接写出的数字
不能超过int 的范围
package day02;/* * 直接量：就是直接写出的数字 * int i = 5; * 其中 i是变量 而5是直接量 * i = 0xffff； * Java 中整数字面量（直接量）默认就是整数 * */public class Demo04 { public static void main(String[] args) { int i = 5; //i = 22222222222222; //编译错误，直接量超出int 范围啦 System.out.println(i); //long n = 222222222222222;//编译错误，直接量超出int 范围 ，WHY? 直接量默认为int long n =22222222222222L;//以L后缀的是long，就可以用咯 }}
在java中 使用long类型作为系统时间
1970年1月1日到现在的毫秒数（why？ UNIX诞生的元年）
package day02;public class Demo05 { public static void main(String[] args) { long now = System.currentTimeMillis();//1970年到现在的毫秒数 long year = now/1000/60/60/24/365 + 1970; System.out.println(year); long max = 0x7fffffffffffffffL;//long 时间的最大值 也就是时间耗尽的时刻 year = max/1000/60/60/24/365 + 1970; System.out.println(year); }}