###简介

Java语言提供了八种基本类型。

其中，6种数字类型（4个整数型，2个浮点型），1种字符类型，还有1种布尔型，它们分别是：
```
byte：整数类型，8位
short：整数类型，16位
int：整数类型，32位
long：整数类型，64位
float：浮点类型，64位
double：浮点类型，双精度，64位
boolean：布尔类型
char：字符串类型
```

它们是用来定义和保存数字、单个字符、布尔类型的东西，他们也可以统称为“变量”。

他们的定义方式是：基本类型名 空格 自定义变量名称 等号 数值。如：`int sum = 20;`

###整体认知（装载至菜鸟教程）

#### 1、整数类型：byte
```
byte 数据类型是8位、有符号的，以二进制补码表示的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
例子：byte a = 100，byte b = -50。

补充：也就说说该值范围为：-128 至 127，常用于类型编码。
```

#### 2、整数类型：short
```
short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
默认值是 0；
例子：short s = 1000，short r = -20000。

补充：也就说说该值范围为：-32768 至 32767。
```

#### 3、整数类型：int
```
int 数据类型是32位、有符号的以二进制补码表示的整数；
最小值是 -2,147,483,648（-2^31）；
最大值是 2,147,483,647（2^31 - 1）；
一般地整型变量默认为 int 类型；
默认值是 0 ；
例子：int a = 100000, int b = -200000。

补充：也就说说该值范围为：-2147483648 至 2147483647，常用于中度数据自增值。
```

#### 4、整数类型：long
```
long 数据类型是 64 位、有符号的以二进制补码表示的整数；
最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
这种类型主要使用在需要比较大整数的系统上；
默认值是 0L；
例子： long a = 100000L，Long b = -200000L。
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

补充：该类型是最大的整数类型，常用于高度的数据自增值，不建议使用。
```

#### 5、浮点型：float
```
float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
float 在储存大型浮点数组的时候可节省内存空间；
默认值是 0.0f；
浮点数不能用来表示精确的值，如货币；
例子：float f1 = 234.5f。

补充：单精度，不建议用于与金额相关的功能。
```

#### 6、浮点型：double
```
double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
浮点数的默认类型为double类型；
double类型同样不能表示精确的值，如货币；
默认值是 0.0d；
例子：double d1 = 123.4。

补充：双精度，建议用于与金额相关的功能。
```

#### 7、布尔型：boolean
```
boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
这种类型只作为一种标志来记录 true/false 情况；
默认值是 false；
例子：boolean one = true。
```

#### 8、字符类型：char
```
char类型是一个单一的 16 位 Unicode 字符；
最小值是 \u0000（即为0）；
最大值是 \uffff（即为65,535）；
char 数据类型可以储存任何字符，但只能存一个；
例子：char letter = 'A';。
```

###下面我们来进入到测试学习阶段：

我们先创建一个`Test1`类，用来做调试，并写入以下代码进行调试:
```java
public class Test1 {
	
	public static void main(String[] args) {
		// 范围是-128~127之间。
		byte       b = 3;
		// 短整型，范围是-32768~32767之间。
		short      s = -200;
		// 整型,范围是负的2的31次方到正的2的31次方减1。
		int        i = 1000; 
		// 长整型，范围为负的2的63次方到正的2的63次方减1。
		long       l = -999999999;
		// 浮点型，就是带小数点的数。范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。
		float      f = 6.12f; 
		// 双精度型，就是比float的范围更大的带小数点的数。范围在4.9e-324~1.8e308，赋值时必须在数字后加上d或D。
		double     d = 1234567890.123456d; 
		// 布尔型，只有true（真）和false（假）两个取值。
		boolean bool = true; 
		// 用单引号赋值,只能存一个字符。
		char       c = 'A'; 
 
		System.out.println(b);
		System.out.println(s);
		System.out.println(i);
		System.out.println(l);
		System.out.println(f);
		System.out.println(d);
		System.out.println(bool);
		System.out.println(c);
	}
}
```
输出结果:

![](https://vpsbm.com/public/upload/20200119175729_803.png)

Java种的运算符与PHP或者大多数编程语言的运算符一样，均支持`+`、`-`、`*`、`/`、`%`、`++`、`--`等操作。

下面我们来做一些关于数据类型间运算的加深记忆练习。

现在，你已经学到了一种定义变量的方式，那么，这个有什么用呢？

你可以用这个来做一个简单的计算题。

比如`333.22 * (992+33333/233)`

```java
public class Test1 {

public static void main(String[] args) {
        float a = 333.5f;
        int   b = 992;
        int   c = 1231;
        int   d = 2;
        // 定义一个变量sum来接受计算的结果
        float sum = a * (b + c / d);
        System.out.println("计算333.5 * (992 + 1231 / 2)");
        // 第一种计算方式，把计算结果先放进sum中，最后打印sum
        System.out.println(sum);
        // 第2种计算方式，直接在输出的时候计算并打印
        System.out.println(a * (b + c / d));
    }
}
```
运行之后，打印：

![](https://vpsbm.com/public/upload/20200120092132_610.png)

基本类型的定义和使用方式就是这样简单。

简单的代码里面包含有不少规则和编译原理：

####1、在上面的代码中，为什么使用`float sum = a * (b + c / d)`，而不建议写为`double sum = a * (b + c / d)`呢？

原因是：

在第一段代码中，你可以看到八种基本类型的赋值范围，这样可以根据你的需要去选择，虽然可以用`long`或`double`存`1`，但是范围越大的类型，占的空间越大，所以需要按需选择。

在基本类型中，他们之间是可以转换的，一个算式计算完之后，结果会自动转换成高级别的类型。

级别的从高到底为：双精度型(`double`) > 浮点型(`float`) > 长整型(`long`) > 整形(`int`) > `byte`。

上面的算式中包含了整形（`b、c、d`）、和浮点型（`a`），其中级别最高的是`float`，所以最后计算的结果会自动转换成`float`，需要用float型 接受。

另外，用比`float`级别更高的`double`也是可以的，但`double`的字节占用数会更大，你可以试试。

####2、低级类型是可以直接转换成高级类型吗？

原因是：

首先声明下，基本类型是没有高低级别之分，上面所说的低级和高级类型，仅仅是指他们转换的优先级。

然后我们再回答这个问题，是可以转换的，看下面案例代码：
```java
public class Test1 {

public static void main(String[] args) {
        // 定义一个整形
        int  i = 99;
        // 定义一个长整形
        long l = 888888888888888888l;
        // 定义一个双精度型
        double d = 9999999999999999999999999d;
        // 定义一个浮点型
        float  f = 3.1415555555555f;

l = i; // 把i赋值给l
        d = i; // 把i赋值给d
        f = i; // 把i赋值给f
        System.out.println(l);
        System.out.println(d);
        System.out.println(f);
    }
}
```
运行结果：

![](https://vpsbm.com/public/upload/20200120092831_200.png)

不同的类型相互赋值就是一个类型转换的过程。

####3、高级类型是可以直接转换成低级类型吗？

答案是：

可以的，不过需要显式的加上强转代码。

如果你直接按照上面的方法强转，会报错：
```java
public class Test1 {

public static void main(String[] args) {
        // 定义一个整形
        int  i = 99;
        // 定义一个长整形
        long l = 888888888888888888l;
        // 定义一个双精度型
        double d = 9999999999999999999999999d;
        // 定义一个浮点型
        float  f = 3.1415555555555f;

i = l; // 把l赋值给i
        i = d; // 把d赋值给i
        i = f; // 把f赋值给i
        System.out.println(l);
        System.out.println(d);
        System.out.println(f);
    }
}
```
上面的代码在第13行开始就会报错，我们可以通过android studio的提示查看错误原因，如下图:

![](https://vpsbm.com/public/upload/20200120093258_209.png)

同时点击灯泡还会给出修正代码的方案，例如点击案例里面的`Cast to 'int'`就把自动把改行代码修复正确，正确的代码如下：
```java
public class Test1 {

public static void main(String[] args) {
        // 定义一个整形
        int  i = 99;
        // 定义一个长整形
        long l = 888888888888888888l;
        // 定义一个双精度型
        double d = 9999999999999999999999999d;
        // 定义一个浮点型
        float  f = 3.1415555555555f;

i = (int) l; // 把l赋值给i
        System.out.println(i);

i = (int) d; // 把d赋值给i

System.out.println(i);

i = (int) f; // 把f赋值给i
        System.out.println(i);
    }
}
```
结果如下：

![](https://vpsbm.com/public/upload/20200120093639_537.png)

我们可以看到，强转之后，原来的浮点型数据丢失了精度。

总结：

Java种的数据类型存在优先级，当低类型往高类型转换时，无需申明转换后的类型。

而当高类型转低类型时，则需要申明转换后的类型。

### 注意

在Java中我们还较常用到一个`String`类，其首字母必须大写，其表示使用字符串类型，而`char`时字符类型，虽然少了一个字，但其实际上的作用时完全不同的。
```
1、char表示字符，定义时用单引号，只能存储一个字符，如char c='x';

而String表示字符串，定义时用双引号，可以存储一个或多个字符，如String name="tom";

2、char是基本数据类型，而String 是一个类，具有面向对象的特征，可以调用方法，如name.length()获取字符串的长度。
```

具体案例如下：
```java
public class Test1 {

public static void main(String[] args) {
        // 只能存储单个字符，你改成XX就会报错
        char c = 'X';
        // 用于存储字符串
        String str = "小黄牛真帅";
        // String是个类，可以调用其内置函数，例如输出字符串长度
        System.out.println(str.length());
    }
}
```

已有0条评论

添加新评论☺

如果认为本文对您有所帮助请赞助本站

支付宝扫一扫赞助

已有0条评论

添加新评论☺