Java数据类型和变量介绍

Java数据类型和变量介绍

这章我们就来介绍一下Java的各种类型的数据。

java的数据类型分为基本数据类型（整形，浮点型，字符型，布尔型）和引用类型（新增的类型）

整形

Java有4个整形，分别是int，long，short，byte。这些整形数据都是有符号的，Java中不存在无符号的类型

int

int在Java中始终占据4个字节。也就是32个bit位。作为一个有符号的整数，第一个bit表示符号，

所以正数（包括0）有2^{31个，负数有2}31个。

所以int表示的范围就是-2^31~231-1

也就是-2147483648~2147483647这么大。

其中要注意int的最大值加1就是最小值，最小值-1就是最大值。都是可以算出来的。

long

表示范围：

占8个字节，64位，表示数的范围是-2^63~263-1,可表示的范围更大了。
-9223372036854775808~9223372036854775807

表示形式：

在数字的最后加上L或者l表示这是一个long类型的数字。推荐使用L

short

表示范围：

占2个字节，32位。表示的范围是-2^15~215-1

-32 768 - 32 767

byte

java新增的数据类型，字节类型，占用一个字节，表示范围是-2^7~27-1

-128~127

字符型 char

单引号里面只有一个字母的叫做字符型。

char占据1个字节。范围就是-128~127

Unicode：

和C语言不同，C语言的字符是采用ASCII编码，但是在JAVA中，采用UｎIcode进行编码。

Unicode的范围是从u0000~uffff，所以在这个范围内的任意组合都会表示一个字符。

比如说：u2122就是™，u03c0就是Π

 System.out.println('u03c0');

浮点型 double

一般描述浮点型的数据，我们都是使用double多一点，因为它表示的更加精确。

占8个字节，数字的后面不用必须加上D，f

单精度浮点型（float)

单精度浮点数，占4个字节，数字的表示不太精确，一般在数字的最后加上f或F

注意（浮点型表示不精确）

另外一点需要注意的是，浮点型的表示可能不会那么的精确，因为无法用二进制准确的表示小数，就像十进制数无法准确的表示1/3一样。

double都不可以完全的表示。

布尔类型 boolean

Java当中的布尔类型是boolean，注意不是Java了哦。

注意事项：

1. java的布尔类型只能有两种取值，一种就是true，另一种就是false。
2. boolean不可以和int互相表示。在C语言中，0表示false，非0表示true。但是在Java中两者是没有任何关系的。

​ 这样赋值就会报错。

3. boolean因JVM不同而所占内存不同。在有些JVM中boolean占1bit，但是在另外一些JVM中boolean占1byte。

字符串（新，重要） String

String不同于上面的类型，属于引用类型。

Java中新增的一个就是字符串类型。就是可以存储一串字符的类型，不用像C语言那样还得借用字符数组才可以完成。

现在有了String，直接就可以定义一个由""引起来的字符串了。真的是太方便了。

拼接：

1.两个字符串可以进行拼接。必须要使用+才能用来拼接

 String s="sdsdssd";
 System.out.println(s+"aaaa");
 System.out.println("as"+"12");
 

        String a="PG ";
        String b="ONE";
        String c=a+b;//直接拼接
        System.out.println(c);//PG ONE

2.字符串可以和数字进行拼接，拼接完还是字符串

        System.out.println("abcd"+1+2);//abcd12
        System.out.println("abcd"+(1+2));//abcd3
        System.out.println(1+2+"abcd");//3abcd
        System.out.println(1+""+2+"abcd");//12abcd

所以，我们就可以充分利用这个特性来打印（比C方便）

        int a = 1;
        int b = 2;
        System.out.printf(" a = "+a+" b = "+b);
        // a = 1 b = 2

转义字符

对于字符串中含有""的字符串来说，要想成功打印出字符串中的所有元素，一个必不可少的事情就是转义字符。

1. 如果没有转义字符，编译器就把字符串内的字符看成是引号了，由此会引发错误。

2. 转义字符就是专门的将""转义的，从而能够让它们正常的输出。

    String s="my name is "xiao ming " ";

在两个""前面都分别加上,这样就会正常的输出了。

常见的转义字符

转义字符	用途
n	换行
t	水平制表符
'	单引号
"	双引号
\	反斜杠

注意u

我们前面介绍过Unicode码都是以u开头的，这个u也是转义字符。

但是和其他的转义字符不同的是，它可以出现在非字符串中，就是可以出现在字符串以外。

出现在字符串中

System.out.println("u0022+u0022");

实际上是“”+“”=“”就是个空串，什么也不打印。

出现在非字符串中：

注意注释也会中招哦：

 //C:user.

会报错：java: 非法的 Unicode 转义

变量

有了数据类型之后，就可以创建一个变量了。

变量初始化

在Java中不可以不对变量初始化就直接使用，必须要进行赋值才可以。

不初始化编译都不会通过。

命名规则

1. 变量不以_，$，数字开头
2. 变量名采用小驼峰，类名采用大驼峰
3. 变量名推荐使用名词词性

常量

常量分为字面值常量和final关键字定义的常量。

字面值常量

任何数据类型，不是以变量出现的就是字面值常量。

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修饰的就是代表常量了。

注意：

1.常量只能被赋值一次，被赋值之后就不能再被修改。

2.常量是在编译的时候就确定好值了，变量通常是在运行时才确定好值。

3.常量的命名通常大写。

类型转换

对于变量来说，不同的类型之间可以进行类型的转换。

Java是强类型语言，只能接受将低类型赋予高的，不能接受将高的赋予低的。

只能从低类型向高类型转换

只能将低类型int的值赋予高类型long的值，

不能将高类型long的值赋予低类型int的值，编译期间就会出错。

因为在编译期间，编译器不知道高类型long a的内部有着什么大小的值。为了防止int的内部会因为数值太大发生溢出，所以编译器此时就会报错。

强制类型转换

虽然说Java默认时不允许将高类型赋予低类型，但是还有强制这一个方法。

    public static void main(String[] args){
        long l=1111111111111111L;
        int a=(int)l;
    }

在高类型的前面加上低类型的括号，就可以被强制转换成低类型。

如果被转换的数值过大，被赋予低类型的时候将会发生截断。

boolean类型的转换

布尔类型不和别的类型发生转换。

int a = 10;
boolean b = true;
b = a; // 编译出错, 提示不兼容的类型
a = b; // 编译出错, 提示不兼容的类型

强制类型转换也不行：

int a = 10;
boolean b = false;
b = (boolean)a; // 编译出错, 提示不兼容的类型.

除非使用下面的方式：

    public static void main(String[] args){
        boolean b=false;
        int a=b?1:0;
        System.out.println("a= "+a);
    }

数值提升

1. 高类型和低类型进行混合运算的时候，为了提高效率，都会转化成高类型的进行运算。

   1）在接收的时候也要使用高类型的来进行接收。

    public static void main(String[] args){
           int a=10;
           long b=20L;
           int c=a+b;
       }//编译不通过，会提升说long类型的值不能赋予int
   

   2）将高类型强制类型转换成低类型

       public static void main(String[] args){
           int a=10;
           long b=20L;
           int c=(int)(a+b);
       }//编译通过，被强制转换成低类型
   

2. 对于byte，short，char这样的所占字节数小于4的，编译器为了提高效率，在编译的时候都把他们转换成int类型。

public static void main(String[] args){
        char a=1;
        char b=2;
        char c=(a+b);
    }//编译错误，c需要char类型的却提供了int

//使用int来接收
public static void main(String[] args){
        char a=1;
        char b=2;
        int c=(a+b);
    }
//强制类型转换    
public static void main(String[] args){
        char a=1;
        char b=2;
        char c=(char)(a+b);
    }

小结

1.高类型和低类型进行运算的时候，低类型会转换成高类型的参与运算。

2.对于所占字节小于4的类型，运算的时候都会转换成int来运算。

int和String的转换

我们使用Java中的包装类来实现

int转换成String

    public static void main(String[] args){
        int a=100;
        String ret1=String.valueOf(a);//使用包装类的函数
        String ret2=a+"";//使用字符串的拼接
        System.out.println(ret2);
        System.out.println(ret1);
    }

String转换成int

public static void main(String[] args){
        String a="123";
        int b=Integer.parseInt(a);
        System.out.println(b);
    }