java数据类型

java 当中的数据类型

基本类型：八种

byte short int long （整型家族）
float double (浮点家族）
char (字符）
boolen(布尔类型）
和c语言对比
增加了c 所没有的byte 和 boolen
个别所占字节数发生了变化

引用类型

string (字符串类型)
和c语言对比
c中从来没有说过什么字符串类型，我们在 c 里面学习的字符串要么是保存至字符数组要么是字符指针，请再次注意，c里面是没有字符串类型的。

变量

常量

1.字面常量

10 // int 字面值常量(十进制)
010 // int 字面值常量(八进制) 由数字 0 开头. 010 也就是十进制的 8
0x10 // int 字面值常量(十六进制) 由数字 0x 开头. 0x10 也就是十进制的 16
10L // long 字面值常量. 也可以写作 10l (小写的L)
1.0 // double 字面值常量. 也可以写作 1.0d 或者 1.0D
1.5e2 // double 字面值常量. 科学计数法表示. 相当于 1.5 * 10^2
1.0f // float 字面值常量, 也可以写作 1.0F
true // boolen 字面值常量, 同样的还有 false
‘a’ // char 字面值常量, 单引号中只能有一个字符
“abc” // String 字面值常量, 双引号中可以有多个字符.

final 关键字修饰的常量

java 中常量前的关键字是final（c是const)
常变量在编译和运行时的区别
变量：运行期间可以改变，并且它的值是在运行的时候才能知道。
常量：在编译期间它的值就已经确定了，并且在运行期间不可以改变

public class Second {
	public static void main(String[] args) {
       int a=10;
       int c=a+20;
       System.out.println(a);//10
       System.out.println(c);//30
       final int b=20;
       //b=21;
       int d=b+1;//
       System.out.println(b);//20
       System.out.println(d);//21
 	}
}

目前来看没有什么问题，放开注释
也就是

final int b=20;
b=21;

可以看到代码连编译都过不了。重点看一下下面的三行

 final int b=20;
 //b=21;
  int d=b+1;

在此代码中，执行 int d=b+1 的时候，这时候 b 已经是一个常量，在所有出现b 的地方都已经被替换为 20，也就是在编译的时候就已经对d 做出了运算,知道d=21.
具体可查看java 反汇编
操作命令： javap -c +文件名

常量一旦被定义就不能修改

public static void main(String[] args) {
		final int a;
		int b=a+10;
	}

一定要初始化，才能使用。具体是不是在定义的时候初始化，没有关系。但仅能初始化一次

类型转换

如果把大类型赋值给小类型的时候一定要强转。
java 编译器审核的相对严格一些，在c中可能只是一个警告。

int 和 boolean 之间或者其他数据类型和 boolean 之间都是不可以进行相互转换的。

小tips
这里有一个点，看到别人问了，所以做一点补充。
这里我们来看一下下面这段小代码有没有什么问题，编译会报错吗？

int sum=0;
			//Math.pow(x,y);
			while(temp!=0) {
				sum+=Math.pow(temp%10,count);
				temp=temp/10;

答案是：不会报错，正常通过了！
事实上，pow的返回值是double 类型

可是我们却用了一个Int 类型接受，难道不应该和上面一样出现类型不兼容的问题吗？
妙就妙在这里的是一个复合运算符，会自动进行转换。

如果我们把代码改成sum=sum+Math.pow(temp%10,count);
这样一定会报错说类型不兼容的。
所以复合运算符有点强！
简而言之但是在+=情况下可以正常工作，因为运算符会隐式执行从右变量类型到左变量类型的类型转换，因此无需显式转换。
下面贴一张图来理解以下这句话。

整型提升

public class Second {
	public static void main(String[] args) {
		int a=10;
		long b=20;
		int c=(int)(a+b);
		//int c=a+b；error
	}

为什么运行注释掉的代码会这样呢？
出现这样情况的原因：b是一个long 类型。当 int 和 long 混合运算的时候, int 会提升成 long, 得到的结果仍然是 long 类型, 需要使用 long 类型的变量来 接收结果. 如果非要用 int 来接收结果, 就需要使用强制类型转换.

public class Second {
	public static void main(String[] args) {
		byte a=10;
		byte b=20;
		byte c=(byte)(a+b);
		//byte c=a+b; error
	}

很奇怪？为什么，注释的地方不对呢？明明里面没有涉及到int 会出现这样的报错？
byte 和 byte 都是相同类型, 但是出现编译报错.。
原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a 和 b 都 提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.

由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short 这种低于 4 个字节的类型, 会先提升成 int, 再参与计算， 就是我们常说的空间换时间。