Java中的基本数据类型讲解（数值型、字符型、布尔型）

数据类型

• 数据类型的分类

  分为 基本数据类型和引用数据类型

  • 基本数据类型

    基本数据类型分为数值型、字符型和布尔类型

    • 数值型

      数值型分为整数型和浮点型（小数型）

      • 整数型

        包含:int、 short、 byte、long

      • 浮点型(小数型)

        包含：float、double

    • 字符型（char）

    • 布尔型（boolean）

  • 引用数据类型

    比如：数组，对象、string、接口等

---

• 整数型

  包含int 、short 、float 、 double

  表示的是有符号的数值

  类型	占用字节数	取值范围
  byte	1	-2^7 ~ 2^7-1
  short	2	-2^15 ~ 2^15-1
  int	4	-2^31 ~ 2^31-1
  long	8	-2^63 ~ 2^63-1

  注意事项：

  1. 占用的字节数越大，取值范围也就越大，存储的数据也就越大

  2. 现实开发中，我们应选择合适的数据类型，切记不要超过数据类型的取值范围

     补充：开发中一般使用int类型来代替short和byte类型

     代码展示：

     public class Test{
     	// 编写main方法，写法固定，程序的入口，能被虚拟机
     	public static void mian(String[] args){
             int age = 12;
             System.out.println("年龄为" + age);
             // 输出 年龄为 12
         }
     }
     

  3. 整数固定值常量，可包含十进制、十六进制和八进制，但是不包含二进制

     代码展示

     public class ConstantTest{
         public static void main(String[] args){
             // 八进制固定值常量
             int num = 017;
          	System.out.println(num);// 输出为15
     		// 十六进制固定值常量
             int num2 = 0xFF;
             System.out.println(num2);// 输出为255
         }
     }
     

  4. 整数固定值常量默认值为int类型，int类型的取值范围是-2^31~231-1 ,大约在正负21亿左右，在整数固定值常量末尾加小写“l”或大写“L”就变为了long类型常量

     建议：使用大写“L”，因为小写的l易与1产生混淆

     public class ConstantDemo{
         // 编写main方法，写法固定，是程序的入口，，main方法中唯一能改变的就是“args”的名字，能被虚拟机识别并执行
         public static void main(String[] args){
      		int num = 10000000000;
             System.out.println(num); // 编译错误，过大的整数
         }
     }
     

     运行截图：
     

     注意：使用整数固定值常量时切忌不要超出int类型的取值范围

     public class ConstantTest{
         public static void main(String args[]){
             long num = 10000000000L;
             //正确 10000000000L属于long类型的固定值常量
             System.out.println(num); 
         }
     }
     

     public class ConstantTest{
         public static void main(String[] args){
             long num = 10000000000;
             System.out.println(num);// 出现编译错误
         }
     }
     

     public class ConstantTest{
         public static void main(String[] args){
             int num = 100000 * 100000; 
             System.out.println(num);// 预计：10,000,000,000 实际：1410065408
         }
     }
     

     预计结果和实际结果不符的原因：

     编译时，100000 * 100000两输相乘的数都没超出int类型的取值范围，所以编译执行时，两个int类型做运算，返回的结果还是int类型

  整数如何在内存中存取的？

  存储：把整数转换成二进制，然后再存储到内存空间中

  读取：把内存中的二进制转为十进制，然后再取出

  画图说明：
  

  代码展示：

  public class IntDemo{
      public static void main(String[] args){
          int age = 7;
          System.out.println("年龄为" + age);
      }
  }
  

---

• 浮点型

  float（又称为单精度类型）	占4字节	保留小数点6-7位
  double（又称为双精度类型）	占8字节	保留小数点15-16位

  注意：

  1. 浮点型占用的字节数越大，表示的精确度就越高

     占用的字节数越大，并不意味着取值范围就越大

  2. double表示小数更高，现实开发中，一般使用double较多

  3. 因为小数存储方式不同，尽量不要对小数做特别精确的计算

     public class DoubleTest{
         public static void main(String[] args){
             // 预计输出 0.0003 实际输出 3.0000000000000003E-4
             System.out.println(0.0001 + 0.0002);
         }
     }
     

  4. 小数固定值常量默认为double类型，在小数固定值常量末尾加上一个小写“f”|大写“F”，那该常量就变为了float类型的常量

     代码展示：

     public class DoubleTest{
         public static void main(String[] args){
             float f = 3.14;// 编译错误
             System.out.println(f);
         }
     }
     

     截图：
     

     原因：3.14默认为double类型

     ---

     代码展示：

     public class DoubleTest1{
         public static void main(String[] args){
             float f = 3.14f; // 编译成功
             System.out.println("f = " + f);// 输出 f = 3.14
         }
     }
     

     截图：
     
     原因：因为在该小数固定值末尾加了一个小写的“f”，那该常量就变为了float类型

  5. 小数固定值常量有哪些？

     十进制小数固定值常量 ，例如：3.14、123.45等

     科学计数法表示的常量，例如：3.14E3、3.14E-3等

     代码展示：

     public class Test{
         public static void main(String args[]){
             float f = 3.14e3f;
             System.out.println("F = " + f);
            	double d = 3.14E-3;
             System.out.println("D = " + d);
         }
     }
     

     运行截图：
     

     3.14e3 等效于小数点向右移动三位，结果为3140.0

     3.14E-3等效于小数点向左移动三位，结果为0.00314

     注意：科学计数法中的“E”可以为小写字母“e”,也可以为大写字母“E”

• 布尔型（boolean）

  值	条件成立|不成立	真|假
  true	成立	真
  false	不成立	假

  使用场合：常用于条件判断，条件成立返回true，条件不成立返回false

  public class BooleanTest{
      public static void main(String[] args){
          boolean flag = true;
          System.out.println(flag);// 输出true
          flag = false;
          System.out.println(flag);// 输出false
          flag = 3>5;
          System.out.println(flag); // 输出false
          flag = 3<5;
          System.out.println(flag); // 输出true
      }
  }
  

  运行截图：
  

  问题：boolean类型占几个字节？

  答：在java规范中，没有明确规定boolean类型的字节数，我觉得占1位，因为1位可以表述两种可能，要么为true要么为false，也觉得占1字节，因为文件存储的最小单位就是字节

• 字符型（char）

  占2个字节，表示的是无符号的数值，取值范围在0~65535

  字符固定值常量：使用一对‘’单引号包裹起来的一个字符，称为字符常量

  public class CharTest{
      public static void main(String[] args){
          char c = 'a'; // 正确
          char c1 = '你好'; // 错误
          char c2 = '号';// 正确
          char c3 = '11';// 错误
          char c4  = '9'; //正确
          char c5 = ' ';// 正确
          char c6 = '';// 错误
      }
  }
  

  注意：

  1. char，占2个字节，可存储65536个字符，一个英文|中文字符在内存中占两个字节

  字符和字符串的关系：

  字符和字符串有着密切联系，字符串由多个任意的字符组成，类似羊肉和羊肉串的关系。

  字符串（String）

  在Java中，String类型（字符串类型）属于引用数据类型

  字符串固定值常量：使用一对双引号“”包裹起来的内容（任意多个字符），我们称为字符串常量

  代码展示：

  public class StringDemo{
      public static void main(String[] args){
          String name = "Java";
          String hobby = "打篮球";
          String nullStr = "";
          String eng = "hello World";
          System.out.println("我的名字为" + name); // 我的名字为Java
          System.out.println("我的爱好为" + hobby);// 我的爱好为打篮球
          System.out.println(nullStr);//  空串
          System.out.println(eng);// hello World
      }
  }
  

  运行结果：
  

  字符串的特点：

  字符串和别的数据类型做“+”操作，实际上做的就是连接符操作（拼接操作），并且返回的结果是String类型（字符串类型）

  分析：String str = “Hello” + 10;

  描述：先将10从int类型隐式类型转换转换为String类型，然后将转换出来的“10”与"Hello"做拼接操作

  public class StringDemo{
      public static void main(String[] args){
          String str = "Hello" + 10;
          System.out.println(str);// 输出Hello10
          String str1 = 20 + "Hello" + 10;
          System.out.println(str1);//输出 “20Hello10”
          // 经常 “+” 使用于以下类似场合
          int age = 15;
          System.out.println("年龄为" + age);// 输出年龄为 15
      }
  }
  

  运行截图：
  

  字符是如何在内存中存储的？

  思路：根据编码表，查找字符（数字、字母）所对应正整数

  存储：把需要存储的字符对照编码表，然后找到字符所对应的正整数，最后将该正整数转换为二进制，存入内存对应的存储空间中—>编码

  读取：通过变量名找到对应存储空间中的数值，然后将数值从二进制转换为十进制，在将十进制的数值对照编码表取出对应的字符–>解码

  画图分析：
  

  代码展示：

  public class CharDemo{
      public static void main(String[] args){
          char c = 'a';
          System.out.println(c);
      }
  }
  

  注意：字符无法直接转换为二进制，只有数值可以

  ---

  输出语句能输出什么内容？

  System.out.println(value)

  System.out.print(value)

  输出的Value就是数据，指的是常量 | 变量数据

  ---

  常见的编码表

  ASCII：用来现实现代英语和西欧语言的编码表

  GBK：用来表示中文用的编码

  Unicode：万国码、统一码

  核心：Unicode编码表几乎包含了全世界所有的语言

  注意：

  1. java采用的是Unicode编码表，意味着java几乎能使用全世界所有的语言，例如：标识符可以使用中文表示,但是不建议使用中文

     public class 哈哈{
         public static void main(String[] args){
             System.out.println("Hello World");
         }
     }
     

     运行截图：
     

  ASCII和Unicode编码表

  ASCII编码表前128位和Unicode编码表前128位一模一样

  '0' --对应的正整数为--> 48

  'a'--对应的正整数为--> 97

  'A'--对应的正整数为-->65

  帮助记忆：

  英文字母（A_Z，az）：大写字母(a_{z)和小写字母(A}Z)相差32，a表示97，A表示65，每次增1

  正整数（0~9）：0表示48,1表示49，每次增1

  代码展示：

  public class CharTest{
      public static void main(String[] args){
          System.out.println((int)'a');//97
          System.out.println((int)'b');//98
          System.out.println((int)'B');//66
          System.out.println((int)'A');//65
          System.out.println((int)'1');//49
          System.out.println((int)'0');//48
      }
  }
  

  运行截图：
  

  如何查看char类型的字符所对应的正整数?

  1. 使用强制类型转换

     代码展示

     public class CharTest{
         public static void main(String[] args){
             System.out.println((int)'a');//97
         }
     }
     

  2. 使用int类型的变量来接受

     代码展示:

     public class CharTest{
         public static void main(String[] args){
             int charInt = 'a';
        		System.out.println(charInt);//97     
         }
     }
     

Int类型和Char类型的区别

共同点：int 类型和char 类型在内存中存储的都是整数

正因为此共同点，意味着int类型和char类型可以互相装换

int类型–转为–>char类型

要求：int类型必须为正整数，并且未超过char类型的取值范围（0~65535），char类型强调的是无符号

char–转为–>int类型

要求：没有任何要求，所有的char类型的字符都可转换为int类型

代码展示：

// char -- 转为 -- >int 类型
public class CharIntDemo{
    public static void main(String[] args){
        System.out.println((int)'a');
        int charInt = '0';
        System.out.println(charInt);
    }
}

代码展示:

// int --转为-->char类型
public class CharIntDemo{
    public static void main(String[] args){
        System.out.println((char)75);// K
        System.out.println((char)48);// 0
        char c = 78;
        System.out.println(c);// N
        char c1 = 49;
        System.out.println(c1); // 1
    }
}

运行截图：

不同点：

1. int类型占用4个字节，char类型占用2个字节，int类型的取值范围比char类型大
2. char类型强调的是无符号，int类型强调的是有符号，int类型在内存中可以存储正|负整数，char类型在内存中只能存正整数，不能存负整数

此文章于11月20日编辑完毕，小编也是个初学者，或许有些内容写的有错误的，我对我自己的要求：有错改之，无错加冕。还望大家能在评论区指点迷津，不胜感激，同时也希望大家口下留情！！