java2：原理数据类型

最新推荐文章于 2022-06-30 13:59:12 发布

浪漫的偷笑

最新推荐文章于 2022-06-30 13:59:12 发布

阅读量318

点赞数

本文链接：https://blog.csdn.net/u013304677/article/details/83043706

版权

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

	}

}