Java 变量(基本数据类型)

前言

1、基本变量类型

  • 变量是用来命名一个数据的标识符。

  • 一个变量的类型,决定了该变量可以包含什么样的值。

  • Java 中有八种基本类型,都是 Java 语言预先定义好的,并且是关键字。

类型 数据类型 封装类 尺寸 长度 默认值 范围
整型 byte Byte 1 字节 8 位 0 -128 ~ 127
short Short 2 字节 16 位 0 -32768 ~ 32767
int Integer 4 字节 32 位 0 -2^31 ~ 2^31 -1
long Long 8 字节 64 位 0 -2^63 ~ 2^63 -1
浮点型 float Float 4 字节 32 位 0.0f N/A
double Double 8 字节 64 位 0.0d N/A
字符型 char Character 2 字节 16 位 \u0000 0 ~ 65535
布尔型 boolean Boolean N/A 1 位 fasle true/false
  • 变量

    1
    2
    3
    4
    int num = 5;
    float floatNum = 5.99f;
    char letter = 'D';
    boolean bool = true;
  • 整型默认的值是 int 类型的。

  • 浮点型默认的小数值是 double 类型的。

  • char 只能存放一个字符,超过一个字符就会产生编译错误。

  • 虽然布尔型真正存放的数据是 0(false)、1(true),但是,不能直接使用 0 和 1 进行赋值。

  • int 和 Integer 的区别

    • int 是基本类型 32 位长度的整数。
    • Integer 是类类型,是 int 的封装类。
    • intInteger 之间可以通过自动装箱 自动拆箱 互相转换。

2、字面值

  • 给基本类型的变量赋值的方式叫做字面值

  • 创建一个对象会用到 new 关键字,但是给一个基本类型变量赋值却不是用 new,因为基本类型是 Java 语言里的一种内置的特殊数据类型,并不是某个类的对象。

    1
    2
    float hp = 313f;
    int armor = 24;
  • 整数 字面值

    • 当以 l 或者 L 结尾的时候,一个整数字面值是 long 类型,否则就是 int 类型。
    • 建议使用大写的 L 而非小写的 l,因为容易和 1 混淆。
    • byte、short、int 和 long 的值都可以通过 int 类型的字面值来创建。

    • 整数的字面值可以用如下四种进制来表示

      • 十进制 : 基 10,包含从 0-9 的数字,平常用的就是这种。
      • 十六进制: 基 16,包含从 0-9 的数字,和从 A-F 的字母。
      • 八进制 : 基 8,包含从 0-7 的数字。
      • 二进制 : 基 2,包含 0 和 1,从 JAVA7 开始就可以创建 二进制的字面值了。
      1
      2
      3
      4
      5
      long val = 26L;               // 以 L 结尾的字面值表示 long 型
      int decVal = 26; // 默认就是 int 型
      int hexVal = 0x1a; // 16 进制
      int oxVal = 032; // 8 进制
      int binVal = 0b11010; // 2 进制
  • 浮点数 字面值

    • 当以 f 或者 F 结尾的时候,就表示一个 float 类型的浮点数,否则就是 double 类型(以 d 或者 D 结尾,写不写都可以)。
    • 浮点数还可以用 E 或者 e 表示(科学计数法)。

      • e2 表示 10 的二次方,即 100。
      • 1.234e2 = 1.234x100。
      1
      2
      3
      float f1 = 123.4F;            // 以F结尾的字面值表示 float 类型
      double d1 = 123.4; // 默认就是 double 类型
      double d2 = 1.234e2; // 科学计数法表示 double
  • 字符和字符串 字面值

    • 字符的字面值放在单引号中。
    • 字符串的字面值放在双引号中。

    • 需要注意的是,\ 表示转义,比如需要表示制表符,回车换行,双引号等就需要用 \t\r\n\" 的方式进行。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      char a= 'c';                  // 字符
      String name = "盖伦"; // 字符串

      char tab = '\t'; // 制表符
      char carriageReturn = '\r'; // 回车
      char newLine = '\n'; // 换行
      char singleQuote = '\''; // 单引号
      char doubleQuote = '\"'; // 双引号
      char backslash = '\\'; // 反斜杠

3、类型转换

  • 不同类型之间的数据可以互相类型转换,但是要满足一定的规则。

  • 转换规则

    • 精度高的数据类型就像容量大的杯子,可以放更大的数据。大杯子往小杯子里倒东西,有的时候放的下,有的时候就会有溢出。
    • 精度低的数据类型就像容量小的杯子,只能放更小的数据。小杯子往大杯子里倒东西,大杯子怎么都放得下。
  • 强制转换

    • 强制转换的意思就是,转是可以转的,但是不对转换之后的值负责。

    • 虽然 short 和 char 都是 16 位的,长度是一样的,但是彼此之间,依然需要进行强制转换。

      1
      2
      3
      4
      5
      6
      7
      8
      char c = 'A';
      short s = 80;

      // 进行强制转换
      c = (char) s;

      // 直接进行转换,会出现编译错误
      s = c;
  • 低精度向高精度转换

    • 低精度向高精度转换是可以正常转换的。

      1
      2
      3
      4
      5
      long l = 50;
      int i = 50;

      // int 比较小,要放进比较大的 long,随便怎么样,都放的进去
      l = i;
  • 高精度向低精度转换

    • 高精度向低精度转换,是有风险的:有的时候是可以转换的;有的时候不可以转换,这个时候就只能采用强制转换。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      byte b = 5;
      int i1 = 10;
      int i2 = 300;

      // 因为 i1 的值是在 byte 范围之内,所以即便进行强制转换,最后得到的值,也是 10
      b = (byte) i1;

      // 因为 i2 的值是在 byte 范围之外,所以就会按照 byte 的长度 8 位进行截取后,其值为 00101100 即 44
      b =(byte) i2;

4、命名规则

  • 变量命名必须满足一系列的条件,不能随意命名。

  • 命名规则

    • 变量命名只能使用 字母、数字、$、_。
    • 变量第一个字符 只能使用 字母、$、_,不能使用数字。
    • _ 是下划线,不是 - 减号或者 —— 破折号
  • 在命名的时候,尽量使用完整的单词进行命名,而不是使用缩写。

  • 在命名的时候,不能只使用关键字,但是可以包含关键字。

  • 中文也是可以用来命名变量的,但是在实际工作中别这么干。

5、作用域

  • 变量处于不同的位置,有不同的名称,分别是

    • 字段,属性
    • 参数
    • 局部变量
  • 不同名称的变量,其作用域是不一样的。

  • 字段,属性,Field

    • 当一个变量被声明在类下面,变量就叫做 字段 或者 属性、成员变量、Field。
    • 其作用域是从其声明的位置开始的整个类。
  • 参数

    • 如果一个变量,是声明在一个方法上的,就叫做参数。
    • 参数的作用域即为该方法内的所有代码,其他方法不能访问该参数,类里面也不能访问该参数。
  • 局部变量

    • 声明在方法内的变量,叫做局部变量。
    • 其作用域在声明开始的位置,到其所处于的块结束位置。

6、修饰符

  • final

    • final 修饰一个变量,有很多种说法,比如不能改变等等。

    • 准确的描述是 当一个变量被 final 修饰的时候,该变量只有一次赋值的机会。

    • final 修饰的变量在方法中,可以先初始化再赋值。但是如果是全局变量,必须在初始化的时赋值,不然会报错。

      1
      2
      // 全局变量
      public final int itemTotalnumber = 6;
    • static 和 final 一块用来修饰成员变量和成员方法,可简单理解为 “全局常量”。

    • 对于变量,表示一旦给值就不可修改,并且通过类名可以访问。

    • 对于方法,表示不可覆盖,并且可以通过类名直接访问。

      1
      2
      // 全局常量
      public static final int HOURS_OF_DAY = 24;
    • final 修饰 类、方法、基本类型变量、引用 的时候分别有不同的意思。


























修饰类型 说明
该类不能够被继承
方法 该方法不能够被重写
引用 该引用只有一次指向对象的机会
基本类型变量 该变量只有一次赋值机会

7、表达式

  • 表达式:以 ; 结尾的一段代码,即为一个表达式。

  • ; 也是一个完整的表达式。

  • 表达式是由变量、操作符以及方法调用所构成的结构。

8、块

  • :从 { 开始 到对应的 } 结束,即一个块。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    {              // 代码块
    ...
    }

    static { // 静态 代码块
    ...
    }

    public class HelloWorld { // 类对应的块

    public static void main(String[] args) { // 主方法对应的块
    System.out.println("abc");
    }
    }
文章目录
  1. 1. 前言
  2. 2. 1、基本变量类型
  3. 3. 2、字面值
  4. 4. 3、类型转换
  5. 5. 4、命名规则
  6. 6. 5、作用域
  7. 7. 6、修饰符
  8. 8. 7、表达式
  9. 9. 8、块
隐藏目录