目录

​编辑

一、字面常量

1、字面常量的定义

2、字面常量的分类

二、数据类型

三、变量

1、变量的概念

2、语法格式

3、整型变量

（1）整型变量

（2）长整型变量 

（3）短整型变量 

 （4）字节型变量

 4、浮点型变量

（1）双精度浮点型

（2）单精度浮点型

5、字符型变量

6、布尔型变量

7、类型转换

（1）自动类型转换(隐式)

（2）强制类型转换(显式)

8、类型提升

（1）int与long之间：int会被提升为long

例如：

（2）byte与byte的运算

 四、字符串类型

1、int 转成 String

一、字面常量

1、字面常量的定义

在了解字面常量的概念前，我们先举个例子：

在上篇博客的HelloWorld程序中， System.Out.println("Hello World")； 语句，不论程序何时运行，输出的都是Hello World，其实"Hello World"就是字面常量。

public class Demo{
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);
}
}

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

在这里，我们要重点关注一下布尔常量，这是因为它和我们在c语言中的认知有所差异，在c语言中，我们将0看作为真，将非0看作为假，但是在Java中，我们不能用0和1来表示真假，这个时候我们就要运用到布尔常量，Java语言规定，true为真，false为假

二、数据类型

那么这个表格中关于数据类型所能表示的数的范围是怎么得出的呢？

我们先来用字节型的数据类型来举例：

字节型的数据类型大小为一个字节，也就是八个比特位，我们用二进制来表示：0000  0000 

那么当它有最大值时，表示为0111 1111  也就是127

当它有最小值的时候，表示为1000 0000  也就是-128

其它的数据类型所能表示的数据的大小我们也可以用相同的方法进行计算

现在，我们用一段代码来验证一下int类型数据的范围：

public class Test {
    public static void main(String[] args) {
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
    }
}

 这段代码的运行结果是：

注意：

Interger 是一个类型，学名：包装类

当前的Integer类型可以当成int类型的plus版，功能比简单的int类型多

也就是说，int类型的最小值为-2147483648，最大值为2147483647，与表中数据相符

那么我们再来计算一下long类型数据的范围：

public class Test {
    public static void main(String[] args) {
        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);
    }
}

 最大值为：9223372036854775807   最小值为：-9223372036854775808

注意：

不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节

整形和浮点型都是带有符号的

整型默认为int型，浮点型默认为double

如果想表示长整型则需在数据后面加上L，若想要表述单精度浮点型则需在数据后面加上F

字符串属于引用类型

 虽然我们在学c语言的时候，已经学了什么是字节，但是在学Java的时候我们可以对这个知识点进行再一次的巩固

那么什么是字节呢？

字节是计算机中表示空间大小的基本单位.

计算机使用二进制表示数据. 我们认为 8 个二进制位(bit) 为一个字节(Byte).

我们平时的计算机为 8GB 内存, 意思是 8G 个字节.

其中 1KB = 1024 Byte, 1MB = 1024 KB, 1GB = 1024 MB.

所以 8GB 相当于 80 多亿个字节

三、变量

1、变量的概念

2、语法格式

在Java语言中的语法格式与C语言中的类似，我们定义变量的语法格式为：

数据类型 变量名 = 初始值;

 同样的，我们使用代码来进行理解：

int a = 10; // 定义整形变量a，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; // a是变量，a中的值是可以修改的，注意：= 在java中表示赋值，即将100交给a，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);

3、整型变量

（1）整型变量

在进行整型变量的定义的时候，我们可以使用不同的方法来进行变量的定义：

int a = 10;
System.Out.println(a);

int b;
b = 10;
System.Out.println(b);

int c;
System.Out.println(c);
c = 100;

int d = 12345678901234; // 编译时报错，初值超过了int的范围

（2）长整型变量 

在Java中，我们和C语言一样，用long来表示长整型变量，但是在Java中使用长整型变量的时候，我们必须在数据的最后加上L，这是因为在Java中，整型默认为int类型，只有加上L计算机才会将数据识别为long类型

int a = 10;

long b = 10; // long定义的长整型变量

long c = 10L; // 为了区分int和long类型，一般建议：long类型变量的初始值之后加L或者l

long d = 10l; // 一般更加以加大写L，因为小写l与1不好区分

 此外，我们在对long类型计算数据的存储范围的时候，使用以下的代码来实现：

        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);

注意事项：

1. 长整型变量的初始值后加L或者l，推荐加L

2. 长整型不论在那个系统下都占8个字节

3. 长整型的表示范围为： -  ~   -1

4. long的包装类型为Long

（3）短整型变量 

short a = 10;
System.Out.println(a);

那么如何计算short类型表示的变量的范围呢？

System.Out.println(Short.MIN_VALUE);
System.Out.println(Short.MAX_VALUE);

注意事项：

1. short在任何系统下都占2个字节

2. short的表示范围为：-32768 ~ 32767

3. 使用时注意不要超过范围

4. short的包装类型为Short

 （4）字节型变量

byte b = 10;
System.Out.println(b);

那么如何计算字节型类型表示的变量的范围呢？

System.Out.println(Byte.MIN_VALUE);
System.Out.println(Byte.MAX_VALUE);

注意事项：

1. byte在任何系统下都占1个字节

2. byte的范围是：-128 ~ 127

3. 字节的包装类型为Byte

 4、浮点型变量

（1）双精度浮点型

double d = 3.14;
System.Out.println(d);

那么我们来看一下下面这段代码，输出结果会不会是0.5呢？

int a = 1;
int b = 2;
System.out.println(a / b);

答案是：不会

这是因为a是int类型的变量，而b也为int类型，当a/b后得到的结果仍然为int类型，将小数点省略，因此如果想要得到0.5，那么我们应该使用double类型来进行计算

double a = 1.0;
double b = 2.0;
System.out.println(a / b); // 输出0.5

我们来看第二段代码：

double num = 1.1;
System.out.println(num * num); // 输出1.21吗？

 那么为什么会出现这样的结果呢？

double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值

注意事项：

1. double在任何系统下都占8个字节

2. 浮点数与整数在内存中的存储方式不同，不能单纯使用 的形式来计算

3. double的包装类型为Double

4. double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。

（2）单精度浮点型

float num = 1.0F; 
System.out.println(num);

float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 float. float的包装类型为Float.

5、字符型变量

char c1 = 'A'; // 大写字母
char c2 = '1'; // 数字字符
char c3 = '帅';//中文字符
System.out.println(c3);
System.out.println(c1);
System.out.println(c2);

注意：java中的字符可以存放整形

注意事项：

1. Java 中使用 单引号 + 单个字母 的形式表示字符字面值.

2. 计算机中的字符本质上是一个整数 . 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文。

3.char的包装类型为Character

有时候，我们在执行Javac的时候可能会出现以下错误：

Test.java:3: 错误: 未结束的字符文字

char ch = '鍛?';

^

这个时候，我们只需要在执行 javac 时加上 -encoding UTF-8 选项即可

javac -encoding UTF-8 Test.java

6、布尔型变量

那么布尔型变量在Java中如何使用呢？我们来用代码实现

ystem.out.println(b);
b = false;
System.out.println(b);

注意事项;

1. boolean 类型的变量只有两种取值 , true 表示真 , false 表示假 .

2. Java 的 boolean 类型和 int 不能相互转换 , 不存在 1 表示 true, 0 表示 false 这样的用法 .

3. Java 虚拟机规范中，并没有明确规定 boolean 占几个字节，也没有专门用来处理 boolean 的字节码指令，在 Oracle公司的虚拟机实现中， boolean 占 1 个字节。

4. boolean的包装类型为Boolean

那么我们来看下这段代码是否正确呢?

boolean value = true;
System.out.println(value + 1);

 答案是：错误！

这是因为变量value是布尔型变量，而数字1为int类型，两者无法相加，所以会导致编译错误

7、类型转换

Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验

有时我们会碰到下面这种代码：

int a = 10;
long b = 100L;
b = a; // 可以通过编译
a = b; // 编译失败

那么为什么第二个式子无法通过编译呢？

这是因为a是int类型的变量，而b是long类型的变量，long类型比int类型的范围要大，当long转化成int类型的时候，容易导致四个字节的数据的缺失，Java编译器会认为这不安全从而进行报错。

（1）自动类型转换(隐式)

System.Out.println(1024); // 整型默认情况下是int
System.Out.println(3.14); // 浮点型默认情况下是double
int a = 100;
long b = 10L;
b = a; // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
a = b; // 编译报错，long的范围比int范围大，会有数据丢失，不安全
float f = 3.14F;
double d = 5.12;
d = f; // 编译器会将f转换为double，然后进行赋值
f = d; // double表示数据范围大，直接将float交给double会有数据丢失，不安全
byte b1 = 100; // 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
byte b2 = 257; // 编译失败，257超过了byte的数据范围，有数据丢失

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; // double-->float, 数据范围由大到小，需要强转，否则编译失败
a = d; // 报错，类型不兼容
a = (int)d; // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃
byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显示转换，否则报错
boolean flag = true;
a = flag; // 编译失败：类型不兼容
flag = a; // 编译失败：类型不兼容

8、类型提升

（1）int与long之间：int会被提升为long

例如：

int a = 10;
long b = 20;
int c = a + b; // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long

（2）byte与byte的运算

我们来看如下代码：

byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
// 编译报错
Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte c = a + b;

总结：

byte 和 byte 都是相同类型 , 但是出现编译报错 . 原因是 , 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a 和 b 都提升成 int, 再进行计算 , 得到的结果也是 int, 这是赋给 c, 就会出现上述错误 .

由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据 . 为了硬件上实现方便 , 诸如 byte 和 short 这种低于 4 个字节的类型 , 会先提升成 int, 再参与计算

那么我们该如何正确书写呢？

byte a = 10;
byte b = 20;
byte c = (byte)(a + b);
System.out.println(c);

 通过上面，我们可以对类型提升做出一个小结

1. 不同类型的数据混合运算 , 范围小的会提升成范围大的 .

2. 对于 short, byte 这种比 4 个字节小的类型 , 会先提升成 4 个字节的 int , 再运算 .

 四、字符串类型

public static void main(String[] args) {
String s1 = "hello";
String s2 = " world";
System.out.println(s1);
System.out.println(s2);
System.out.println(s1+s2); // s1+s2表示：将s1和s2进行拼接
}

int num = 10;
// 方法1
String str1 = num + ""; 
// 方法2
String str2 = String.valueOf(num);

public class Test {
    public static void main(String[] args) {
        int c = 10;
        int d = 20;
        System.out.println(c+d + "hello");
        System.out.println("hello" + c+d);
    }
}

这段代码的运行结果将会超出你的意料

这是因为在第一个式子中，c和d先进行计算得到结果30再和字符串进行结合进行输出，但是在第二个式子中，hello作为字符串先出现在前面，与后面的c和d结合，一起作为字符串输出，那么如果我们想输出Hello30该如何编写代码呢？

 System.out.println("hello" + (c+d));

2. String 转成 int

String str = "100";
int num = Integer.parseInt(str);

OVER ！