Java数据类型、变量与运算符

数据类型

基本数据类型

整型

数据类型	关键字	内存占用	范围
字节型	byte	1字节	-128~127
短整型	short	2字节	-32768~32767
整形	int	4字节	-2^31~2^31-1
长整型	long	8字节	-2^63~2^63-1

浮点型

数据类型	关键字	内存占用
单精度浮点数	float	4字节
双精度浮点数	double	8字节

字符型

数据类型	关键字	内存占用	范围
字符型	char	2字节	0-65535

布尔型

数据类型	关键字	范围
布尔型	boolean	true和false

引用数据类型

注意

1. 在java中，Int与long所占字符数与操作系统位数无关。
2. 整型和浮点型都是带有符号的。
3. 整型默认为int，浮点型默认为double.
4. 1字节为8bit，1KB=1024Byte, 1MB=1024KB, 1GB=1024MB.

变量

整型变量

整型变量

public class test {
    public static void main(String[] args) {
        //在定义时定义初始量
        int a = 10;
        //在定义时没给初始量，但使用前必须设置初值
        int b;
        b = 10;
    }
}

int的包装类型为Integer.

长整型变量

public class test {
    public static void main(String[] args) {
        //当赋值不超过int范围时，后面可加L，可不加
        long a = 100L;      //一般使用大写L，便于区分
        long b = 100;
        //当赋值超过int范围时，后面必须加L
        long c = 1000000000L;
    }
}

long的包装类型为Long.

短整型变量

public class test {
    public static void main(String[] args) {
        short a = 10;
    }
}

short的包装类型为Short.

字节变量

public class test {
    public static void main(String[] args) {
        byte a = 10;
    }
}

byte的包装类型为Byte.

浮点型变量

双精度浮点型

public class test {
    public static void main(String[] args) {
        double a = 3.14;    //双精度浮点型的初始化
    }
}

输出小数

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

让我们来观察上述代码，在往下翻查看之前，让我们来想想，上述代码的结果会是我们想要得到的0.5吗？

非常显然，结果不是我们想要的0.5，而是0，这是因为在Java中，int与int相除的结果仍然是int，并且它会舍弃小数部分，那么为了得到0.5，我们必须引入浮点型，让我们来尝试改变一下代码的定义类型。

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

现在，再次观察上述代码，和之前一样，在往下翻看之前，让我们先思考一下，上述代码会得到什么样的结果？能得到我们想要的0.5吗？

非常显然，此时我们成功得到了我们想要的结果，因此，我们可以知道，如果我们想得到小数，必须要引入更加精准的浮点类型，但此时我们心中也许会有一个新的疑问，浮点型真的有我们想象中的那么精确吗？让我们一起来看看下述代码。

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

上述代码能够得到1.21吗？

神奇的是，我们发现，结果并不是1.21，也就是说，浮点型并没有我们想象中的那么精确，它也存在一定的误差。

double的包装类型为Double.

单精度浮点型

public class test {
    public static void main(String[] args) {
        float a = 1.0f;    //单精度浮点型的初始化
    }
}

float的包装类型为Float.

字符型变量

初始化

public class test {
    public static void main(String[] args) {
        char c1 = 'A';  //字母字符
        char c2 = '1';  //数字字符
    }
}

char的包装类型为Character.

布尔型变量

public class test {
    public static void main(String[] args) {
        boolean a = false;
    }
}

boolean的包装类型为Boolean.

类型转换

隐式

public class test {
    public static void main(String[] args) {
        int a = 100;
        long b = 10l;
        b = a;  //此时由小到大，编译器会自动将a从int类型提升到long类型
        
        double c = 1.1;
        float d = 1.0f;
        c = d;  //同理，此时d会自动从float到double
    }
}

观察上述代码，我们可以发现，当我们将一个变量从一个小类型变为一个大类型时，编译器会自动将其提升为大类型，因此我们称这样的转换为隐形转换，也就是说我们不需要自己手动进行类型的转换。

显式

public class test {
    public static void main(String[] args) {
        int a = 100;
        long b = 10l;
        a = (int)b;  //此时由大到小，我们需要将long强转为int

        double c = 1.1;
        float d = 1.0f;
        d = (float)c;  //同理，我们需要强转double到float
    }
}

观察上述代码，我们可以发现当我们将一个变量从一个大类型变为一个小类型时，我们需要手动将大类型变为小类型，因为Java为一个强类型编程语言，若不进行强转，在编译过程中也许会发生数据的丢失，因此编译器会报错。

注意

强制类型转换不一定能成功，不相干的类型之间不能相互转换。