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 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);

	}

}