《JAVASE系列》基本数据类型和变量

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

《JAVASE系列》基本数据类型和变量

前言

古之立大事者，不惟有超世之才，亦必有坚韧不拔之志！

1. 字面常量

常量即程序运行期间，固定不变的量称为常量

字符常量的分类：

1.字符串常量：即“ ”括起来的内容，比如"abced",“1234”。

2.整形常量： 即程序中直接写入的整数(无小数点)。

3.浮点数常量： 即程序中直接写入的小数。如3.14 , 0.21。

4.字符常量： 即’ ‘括起来的内容，只放一个字符，如’A’,‘我’。

5.布尔常量：只有两种：true 和 flase。

6.空常量： null。

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

代码示例

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

2.java的数据类型

在java当中，数据类型分为四类八种：

四类：整型，浮点型，字符型，布尔型。

八种：

解决疑惑：

为什么负数都比正数多多一个：

这是规定的, 以int类型为例：

如果单纯计算 0 的 二进制的话 第一位表示符号位：那么有两种表达方式：

00000000000000000000000000000000

10000000000000000000000000000000

所以计算机科学家们规定：

0的二进制为 00000000000000000000000000000000

-32768的二进制为 10000000000000000000000000000000

其他数据类型也是同理。

注意：

• 不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节。（java的安全性）

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

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

  以下用代码讲解细节：

  public class test{
      public static void main(String[] args){
           float = 3.14;
          //没有问题，但是3.14是double类型
          //所以float类型的数值要加个f
          float = 3.14f;
      }
  }
  

基础知识回顾：

什么是字节：

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

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

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

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

3.java 变量

3.1 变量是什么：

在一个java程序中，肯定不止有常量，还要需要可以改变的量，对于这些经常改变的内容，在Java程序中，称为变量。而数据类型就是用来定义不同种类变量的。

定义变量的语法格式：

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

代码示例：

public class test{
    public static void main(String[] args){
int 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的数值可以修改的，但是要在int类型的数值范围之内
// 注意：在一行可以定义多个相同类型的变量
int a1 = 10, a2 = 20, a3 = 30;
System.Out.println(a1);
System.Out.println(a2);
System.Out.println(a3);
    }
}

重点：

与c语言相比，java语言具有极高的安全性，所以每一个变量不能跟c语言一样不给初始值就直接使用
例如

public class test{
    public static void main(String[] args){
        int a;
        System.Out.println(a);
        //会编译失败。
    }
}

所以在使用之前给变量赋值：

public class test{
    public static void main(String[] args){
        int a;
        a = 100;
        System.Out.println(a);
    }
}

所以我们应该养成良好的代码习惯，在定义变量时，如果不想给他数值，可以先赋值为 0。

3.2 整形类的变量知识点

int 类型：

• int不论在何种系统下都是4个字节。
• 如果没有合适的初始值，可以设置为0。
• 在给变量设置初始值时，值不能超过int的表示范围，否则会导致溢出。
• 变量在使用之前必须要赋初值，否则编译报错。
• int的包装类型为 Integer

long类型

• 长整型变量的初始值后加L或者l，推荐加L（因为l会与1混淆）

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

• 长整型的表示范围为：$-2^{32}$ ~ $2^{32}-1$

• long的包装类型为Long

  public class test{
      public static void main(String[] avgs){
          long b = 314254L;
          //要加L  
      }
  }
  

short类型

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

2. short的表示范围为：-32768 ~ 32767
3. 使用时注意不要超过范围(一般使用比较少)
4. short的包装类型为Short

byte类型

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

2. byte的范围是：-128 ~ 127
3. 字节的包装类型为Byte

3.3 浮点数类的变量知识点

double类型（双精度浮点型）

思考：

public class test{
    public static void main(String[] avgs){
           int a = 1;		
           int b = 2;
           System.out.println(a / b);   
          // 输出 0.5 吗？
          
    }
}

在 Java 中, int 除以 int 的值仍然是 int(会直接舍弃小数部分)。

可以做到输出0.5的代码：

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

public class test2{
    public static void main(String[] avgs){
           int a = 1;
           int b = 2;
           System.out.println(a*1.0 / b*1.0);   
          // 将int类型提升为double类型
    }
}

思考：以下代码会输出1.21吗

public class test3{
    public static void main(String[] avgs){
        double num = 1.1;
        System.out.println(num * num);
    }
}

不会，结果应该是：1.2100000000000002

因为计算机在计算浮点数时，是计算不出准确值的，是有误差的。

知识点：

• double在任何系统下都占8个字节
• 浮点数与整数在内存中的存储方式不同，不能单纯使用$2^n$的形式来计算
• double的包装类型为Double
• double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。

float类型（单精度浮点型）

public class test{
    public static void main(String[] avgs){
        float a = 3.14F;
         System.out.println(a);
    }
}

知识点：

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

3.4字符型变量的知识点

public class test{
    public static void main(String[] avgs){
        char c1 = 'A';    // 大写字母
        char c2 = '1';    // 数字字符
        System.out.println(c1);
        System.out.println(c2);
        // 注意：java中的字符可以存放整形
        char c3 = '帅';
        System.out.println(c3);
    }
}

知识点：

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

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

3.5布尔型变量的知识点

public class test{
    public static void main(String[] avgs){
        boolean b = true;
        System.out.println(b);
        b = false;
        System.out.println(b);
    }
}

知识点

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

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

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

  专业文档解释：

  

  public class test{
      public static void main(String[] avgs){
          boolean value = true;
          System.out.println(value + 1);
  // 代码编译会出现如下错误
  //Test.java:4: 错误: 二元运算符 '+' 的操作数类型错误
  //这是因为布尔类型没有规定大小，加减无法判断跳过几个字节。
      }
  }
  
  

• boolean的包装类型为Boolean。

4.java 的类型转换

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

public class test{
    public static void main(String[] avgs){
        int a = 10;
        long b = 100L;
        b = a;   // 可以通过编译
        a = b;   // 编译失败
    }
}

4.1自动类型转换(隐式)

自动类型转换即:

代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。

特点：

数据范围小的转为数据范围大的时会自动进行。

public class test{
    public static void main(String[] avgs){
       
        System.Out.println(1024);  
        // 整型默认情况下是int
        System.Out.println(3.14);   
        // 浮点型默认情况下是double
       int a = 100;
       long b = 10L;
       b = a;//自动类型转换
       a = b;//编译失败
       

详细解释：

b = a ： a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值

a = b ： 编译报错，long的范围比int范围大，会有数据丢失，不安全

public class test{
    public static void main(String[] avgs){
       float f = 3.14F;
       double d = 5.12;
       d = f; 
       f = d; 
      byte b1 = 100;  
      byte b2 = 257; 
    }
}

详细解释：

d = f： 编译器会将 f 转换为double，然后进行赋值

f = d： double表示数据范围大，直接将float交给double会有数据丢失，不安全

byte b1 = 100： 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte。

byte b2 = 257： 编译失败，257超过了byte的数据范围，有数据丢失

4.2强制类型转换(显式)

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

总结：

1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型
2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失
3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查
4. 强制类型转换不一定能成功，不相干的类型不能互相转换

5.java 的 类型提升

类型提升的规则：

不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。

int 与 long 的运算

public class test{
    public static void main(String[] avgs){
        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  

byte 与 byte 的运算

public class test{
    public static void main(String[] avgs){
        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, 而c是byte类型，所以就会出现上述错误.

为什么要计算时要将byte类型提升为int类型：

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

修改：

public class test{
    public static void main(String[] avgs){
        byte a = 10;
        byte b = 20;
        byte c = (byte)(a + b);
        System.out.println(c);
    }
}

总结：

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

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

6.java 的字符串类型（了解）

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

效果：

在字符串拼接中实现运算：

public static void main13(String[] args) {
        int m = 10;
        int n = 20;
        System.out.println("a+b = "+(a+b));
        System.out.println("a-b = "+(a-b));
        System.out.println("a*b = "+(a*b));
        System.out.println("a/b = "+(a/b));
        
    }
}

总结

做一个有用的嘉心糖 ！ 与君共勉^ ^