java2：原理数据类型

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 00000000min 10000000 00000000 00000000 00000000max 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 100110 0a 0000 101011 0b 0000 101112 0c 0000 110013 0d 0000 110114 0e 0000 111015 0f 0000 111116 10 0001 000017 11 0001 000118 12 0001 001019 13 0001 001120 14 0001 010021 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 64OS 64 Java 32OS 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);

}

}

本文出自 “浪漫的偷笑” 博客，请务必保留此出处http://lmdtx.blog.51cto.com/6942028/1698304