android java数据类型,Android入门之四，Java基础：基本数据类型

Android入门之四，Java基础：基本数据类型

1年前

阅读 2092

评论 0

喜欢 0

###简介

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);

}

}

```

输出结果:


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));

}

}

```

运行之后，打印：


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

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

####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);

}

}

```

运行结果：


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

####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的提示查看错误原因，如下图:


同时点击灯泡还会给出修正代码的方案，例如点击案例里面的`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);

}

}

```

结果如下：


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

总结：

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());

}

}

```