数据类型与变量

---

一、字面常量

常量即程序运行期间，固定不变的量称为常量。

public class Demo1 {
	public static void main(String[] args){
		System.out.println("hello world!");//字符串常量
		System.out.println(100);           //整形常量
		System.out.println(3.14);          //浮点数据常量
		System.out.println('A');           //字符类型常量
		System.out.println(true);          //布尔类型常量
		System.out.println(false);
	}
}

另外注意，前面的一篇博客以及这篇全部是在cmd上进行编程的，打开方式是win+R,在cmd上，在添加了注释之后，编译器无法识别文字，会报错，这时有更简单的方法，在Java文件窗口按住Shift同时选择要进行编译的文件右键选择在此处打开…具体如下图所示，编译时需要输入javac -encoding utf-8 文件名即可编译成功。

注意：字符串、整形，浮点型、字符型以及布尔型，在Java中都称为数据类型。

二、数据类型

在Java中数据类型主要分为两类：剧本数据类型和引用数据类型。基本数据类型有四类八种：
1.四类：整型、浮点型、字符型以及布尔型。
2.八种：

注意：
1.不论是在16位系统还是32位系统，int都占四个字节，long都占八个字节。
2.整形和浮点型都是有符号的
3.整形默认int型，浮点型默认double。
4.字符串属于引用类型。

三、变量

经常改变的内容，成为变量，而数据类型就是用来定义不同种类变量的。
格式如下：

public static void main(String[] args){
		int a=10;
		double d=3.14;
		char c='A';
		boolean b=true;
		System.out.println(a);
		System.out.println(d);
		System.out.println(c);
		System.out.println(b);
		a=100;
		System.out.println(a);
		//注意：在一行可以定义多个相同类型的变量
		int a1=10,a2=20,a3=30;
		System.out.println(a1);
		System.out.println(a2);
		System.out.println(a3);
	}

整型变量

public static void main(String[] args){
		//1.在定义时给出初始值
		int a=10;
		System.out.println(a);
		//2.在定义时没有给初始值，但使用前必须设置初值
		int b;
		b=10;
		System.out.println(b);
		//3.使用方式二定义后，在使用前如果没有赋值，则编译期间会报错
		int c;
		System.out.println(c);
		c=100;
		//int型变量所能表示的范围：
		System.out.println(Integer.Min_VALUE);
		System.out.println(Integer.MAX_VALUE);
		//注意：在定义int型变量时，所赋值不能超过int的范围
		int d=12345678901234;//编译时报错，初值超过了int的范围
	}

注意：
1.在给变量设置初始值时，值不能超过int的表示范围，否则会导致溢出。
2.变量在使用之前必须要赋初值，否则会编译报错。
针对其中的长整型：

public static void main(String[] args){
		int a=10;
		long b=10;//long定义的长整型变量
		long c=10L;//为了区分int和long类型，一般建议：long类型变量的初始化之后加L或者l。一般更多写L，因为l和1不好区分。
		//long型变量所能表示的范围：这个数据范围远超过int的表示范围，足够绝大部分的工程场景使用
		System.out.println(Long.MIN_VALUE);
		System.out.println(Long.MAX_VALUE);
	}	

假如建立这样一个程序，

public class longStatic{
	public static void main(String[] args){
		long a=12345678901234;
		System.out.println(a);
	}
}

a的范围在long的取值范围之间，但结果还是会报错。

这是为什么呢？
原因是：整形都默认为int型，所以这里的范围超过了int型的范围，所以会报错。在后面加上后缀L即可。
短整型变量：

		short e=10;
		System.out.println(e);
		//short型变量所能表示的范围：
		System.out.println(Short.MIN_VALUE);
		System.out.println(Short.MAX_VALUE);

字节型变量：

        byte f=10;
		System.out.println(f);
		//byte型变量所能表示的范围
		System.out.println(Byte.MIN_VALUE);
		System.out.println(Byte.MAX_VALUE);

浮点型变量

	public static void main(String[] args){
		double d=3.14;
		System.out.println(d);
	}

代码一：

	public static void main(String[] args){
		int a=1;
		int b=2;
		System.out.println(a/b);
	}

结果：

会发现这里和C语言一样，int/int=int(会直接舍弃小数部分)，如果想得到0.5，需要使用double类型计算。

	public static void main(String[] args){
		double a=1.0;
		double b=2.0;
		System.out.println(a/b);
	}

代码二：

	public static void main(String[] args){
		double num=1.1;
		System.out.println(num*num);
	}

注意：
1.浮点数与整数在内存中的存储方式不同，不能单纯使用2^n的形式来计算。
2.double类型的内存布局遵守IEEE754标准（和C语言一样），尝试使用有限的内存空间表示可能无限的小数，势必会存在一定的精度误差，因为浮点数是个近似值，并不是精确值。
对于单精度浮点型

	public static void main(String[] args){
		float num=1.0f;//写作1.0F也可以
		System.out.println(num);
	}

注意：float类型在Java中占四个字节，同样遵守IEEE754标准，由于表示的数据精度范围较小，一般工程上用到浮点数优先考虑double，不太推荐使用float。

字符型变量

	public static void main(String[] args){
		char c1='A';//大写字母
		char c2='1';//数字字符
		System.out.println(c1);
		System.out.println(c2);
		//Java中的字符可以存放整形
		char c3='帅';
		System.out.println(c3);
	}	

注意事项：
1.Java中使用单引号+单个字母的形式表示字符字面值。
2.计算机中的字符本质上是一个整数，在C语言中使用ASCII表示字符，而Java中使用Unicode表示字符，因此一个字符占用两个字节，表示字符的种类更多，包括中文。

布尔型常量

    public static void main(String[] args){
		boolean b=true;
		System.out.println(b);
		b=false;
		System.out.println(b);
	}

注意：
1.boolean类型的变量只有两种取值，true表示真，false表示假。
2.Java的boolean类型和int不能相互交换，不存在1表示true，0表示false这样的用法。

	public static void main(String[] args){
		boolean value=true;
		System.out.println(value+1);
	}

---

四、类型转换

	public static void main(String[] args){
		int a=10;
		long b=100L;
		b=a;//通过编译
		a=b;//编译失败
	}

在Java中，当参与运算数据类型不一致时，就会进行类型转换。Java种类型转换分为两类：自动类型转换（隐式）和强制类型转换（显式）。

隐式类型转换

隐式类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动处理。特点：数据范围小的转为数据范围大的时会自动进行。

	public static void main(String[] args){
		System.out.println(1024);
		System.out.println(3.14);
		int a=100;
		long b=10L;
		b=a;//a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升成long类型,然后赋值
		a=b;//编译报错，long的范围比int范围大，会有数据丢失，不安全
	}

这里存在一个问题：
byte a=10;10为int类型，赋值给int类型明明会有数据丢失。相当于上边的a=b。而这个语句为什么能编译通过？
这里根据我自己的理解做出解释（如有不当欢迎指正）：把b赋值给a，这里的a是变量，系统不清楚具体的值是多少，所以会出现编译报错。

显式类型转换

强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。特点：数据范围大得到数据范围小的。
示例如下：

public class change{
	public static void main(String[] args){
		int a=10;
		long b=100L;
		b=a;//int-->long，由小到大，隐式转换
		a=(int)b;//long-->int,由大到小，需要强转，否则编译失败
		
		float f=3.14F;
		double d=5.12;
		d=f;//float-->double，由小变大，隐式转换
		f=(float)d;//bouble-->float,由大变小，需要强转，否则编译失败
		
		a=d;//报错，类型不兼容
		a=(int)d;//double没有int表示的数据范围大，需要强转，小数点之后舍弃
		
		boolean flag=true;
		a=flag;//编译失败，类型不兼容
		flag=a;
	}
}

下面有一个点是我本人之前比较疑惑的一点，不知道大家有没有问题，拿出来讲一下：

		byte b1=100;//100默认为int,没有超过byte范围，隐式转换
		byte b2=(byte)257;//257默认为int，超过byte范围，需要显式转换，否则报错
		System.out.println(b2);//1

针对第二行，我之前在想，为什么257不在byte的范围内强转还是可以转为byte,后来得知257确实是不在一个字节的范围内，他会截断最低位的一个字节赋值给b2,也就会出现b2的输出结果为1.

五、类型提升

不同类型进行相互运算时，数据类型小的会被提升到数据类型大的。

int和long之间：int会被提升为long

	public static void main(String[] args){
		int a=10;
		long b=20;
		int c=a+b;//编译出错，int+long会被提升为long,赋值给int会丢失数据
		long d=a+b;//编译成功
	}

byte和byte的运算

	public static void main(String[] args){
		byte a=10;
		byte b=20;
		byte c=a+b;
		System.out.println(c);
	}

原因：byte和byte都是相同类型，但是计算a+b会先将a和b都提升成int，再进行计算，得到的结果也是int赋值给c，就会出现错误。
注意：由于计算机的CPU通常是按照四个字节为单位从内存中读写数据，为了硬件上实现方便，诸如byte和short这种低于四个字节的类型，会先提升为int，再计算。

六、字符串类型

在Java中使用String类定义字符串类型

		String s1="hello";
		String s2=" world";
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s1+s2);//s1+s2:将s1和s2拼接

int转成String

	public static void main(String[] args){
		int num=10;
		//法1
		String str1=num+"";
		//法2
		String str2=String.valueOf(num);
	}

String转为int

	public static  void main(String[] args){
		String str="100";
		int num=Integer.parseInt(str);
	}