Java基础（1）-数据类型

Java语法规范

  • 所有的Java语句必须以;结尾！
  • 无论是()、[]还是{}，所有的括号必须一一匹配！
  • 主方法的代码只能写在{}中！

Java基础语法（面向过程）

变量和关键字

变量

  • 变量就是一个可变的量，例如定义一个int类型的变量（int就是整数类型）：

    1
    2
    3
    int a = 10;
    a = 20;
    a = 30;

  • 我们能够随意更改它的值，也就是说它的值是随时可变的，我们称为变量。变量可以是类的变量，也可以是方法内部的局部变量（我们现阶段主要用局部变量，类变量在面向对象再讲解）

  • 变量和C语言中的变量不同，Java中的变量是存放在JVM管理的内存中，C语言的变量存放在内存（某些情况下需要手动释放内存，而Java会自动帮助我们清理变量占据的内存）Java和C++很类似，但是没有指针！Java也叫C++–

  • Java是强类型语言，只有明确定义了变量之后，你才能使用！一旦被指定某个数据类型，那么它将始终被认为是对应的类型（和JS不一样！）

  • 定义一个变量的格式如下：

    1
    2
    [类型] [标识符(名字)] = [初始值(可选)]
    int a = 10;

  • 注意：标识符不能为以下内容：

  • 标识符以由大小写字母、数字、下划线(_)和美元符号($)组成，但是不能以数字开头。

  • 大小写敏感！

  • 不能有空格、@、#、+、-、/ 等符号

  • 应该使用有意义的名称，达到见名知意的目的，最好以小写字母开头

  • 不可以是 true 和 false

  • 不能与Java语言的关键字重名

关键字

  • 还有基本数据类型、流程控制语句，先了解

常量

  • 常量就是无法修改值的变量，常量的值，只能定义一次：

    1
    2
    final int a = 10;
    a = 10;  //报错！

  • 常量前面必须添加final关键字（C语言里面是const，虽然Java也有，但是不能使用！）

  • 这只是final关键字的第一个用法，后面还会有更多的用法。

注释

  • 养成注释的好习惯，不然以后自己都看不懂自己的代码！注释包括单行注释和多行注释：
    1
    2
    3
    4
    5
    6
    // 我是单行注释
    /** 
    *我是
    *多行注释
    */
    //TODO 待做标记

基本数据类型

  • Java中的数据类型分为基本数据类型和引用类型两大类

整数类型

  • 整数类型是最容易理解的类型！既然我们知道了计算机中的二进制数字是如何表示的，那么我们就可以很轻松的以二进制的形式来表达我们十进制的内容了。

  • 在Java中，整数类型包括以下几个：

  • byte 字节型 （8个bit，也就是1个字节）范围：-128~+127

  • short 短整形（16个bit，也就是2个字节）范围：-32768~+32767

  • int 整形（32个bit，也就是4个字节）最常用的类型！

  • long 长整形（64个bit，也就是8个字节）最后需要添加l或L

  • long都装不下怎么办？BigInteger！

  • 数字已经达到byte的最大值了，还能加吗？为了便于理解，以4bit为例：

  • 0111 + 0001 = 1000 => -8（你没看错，就是这样！）

  • 整数还能使用8进制、16进制表示：

  • 十进制为15 = 八进制表示为017 = 十六进制表示为 0xF = 二进制表示 1111 (代码里面不能使用二进制！)

字符类型和字符串

  • 在Java中，存在字符类型，它能够代表一个字符：

  • char 字符型（16个bit，也就是2字节，它不带符号！）范围是0 ~ 65535

  • 使用Unicode表示就是：\u0000 ~ \uffff

  • 字符要用单引号扩起来！比如 char c = ‘淦’;

  • 字符其实本质也是数字，但是这些数字通过编码表进行映射，代表了不同的字符，比如字符'A'的ASCII码就是数字65，所以，char类型其实可以转换为上面的整数类型。

  • Java的char采用Unicode编码表（不是ASCII编码！），Unicode编码表包含ASCII的所有内容，同时还包括了全世界的语言，ASCII只有1字节，而Unicode编码是2字节，能够代表65536种文字，足以包含全世界的文字了！（我们编译出来的字节码文件也是使用Unicode编码的，所以利用这种特性，其实Java支持中文变量名称、方法名称甚至是类名）

  • 既然char只能代表一个字符，那怎么才能包含一句话呢？（关于数组，我们这里先不了解，数组我们放在面向对象章节讲解）

  • String就是Java中的字符串类型（注意，它是一个类，创建出来的字符串本质是一个对象，不是我们的基本类型）字符串就像它的名字一样，代表一串字符，也就是一句完整的话。

  • 字符串用双引号括起来！比如：String str = “B站青空霞光女粉”;

    1
    String str = "B站青空霞光女粉";

小数类型

  • 小数类型比较难理解（比较难理解指的是原理，不是使用）首先来看看Java中的小数类型包含哪些：
  • float 单精度浮点型 （32bit，4字节）
  • double 双精度浮点型（64bit，8字节）
    1
    2
    double d1 = 1.234;
    float f1 = 1.2f;

布尔类型

隐式类型转换

  • 隐式类型转换支持字节数小的类型自动转换为字节数大的类型，整数类型自动转换为小数类型，转换规则如下：

  • byte→short(char)→int→long→float→double

  • 为什么long比float大，还能转换为float呢？小数的存储规则让float的最大值比long还大，只是可能会丢失某些位上的精度！

  • 所以，如下的代码就能够正常运行：

    1
    2
    3
    4
    5
    6
    7
    8
    byte b = 9;
    short s = b;
    int i = s;
    long l = i;
    float f = l;
    double d = f;
    System.out.println(d);
    //输出 9.0

显示类型转换

  • 显示类型转换也叫做强制类型转换，也就是说，违反隐式转换的规则，牺牲精度强行进行类型转换

    1
    2
    3
    4
    int i = 128;
    byte b = (byte)i;
    System.out.println(b);
    //输出 -128

  • 为什么结果是-128？精度丢失了！

  • int 类型的128表示：00000000 00000000 00000000 10000000

  • byte类型转换后表示：xxxxxxxx xxxxxxxx xxxxxxxx 10000000 => -128

数据类型自动提升

  • 在参与运算时（也可以位于表达式中时，自增自减除外），所有的byte型、short型和char的值将被提升到int型：

    1
    2
    3
    byte b = 105;
    b = b + 1;   //报错！
    System.out.println(b);

  • 这个特性是由 Java虚拟机规范 定义的，也是为了提高运行的效率。其他的特性还有：

  • 如果一个操作数是long型，计算结果就是long型

  • 如果一个操作数是float型，计算结果就是float型

  • 如果一个操作数是double型，计算结果就是double型

运算符

赋值和算数运算符

  • 赋值运算符=是最常用的运算符，其实就是将我们等号右边的结果，传递给等号左边的变量，例如：

    1
    2
    3
    int a = 10;
    int b = 1 + 8;
    int c = 5 * 5;

  • 算术运算符也就是我们在小学阶段学习的+ - * / %，分别代表加减乘除还有取余，例如

    1
    2
    3
    4
    int a = 2;
    int b = 3;
    int c = a * b;
    //结果为6

  • 需要注意的是，+还可以用作字符串连接符使用：

    1
    System.out.println("青空霞光" + "nb");  //青空霞光nb

  • 当然，字符串可以直接连接其他类型，但是会全部当做字符串处理：

    1
    2
    int a = 6, b = 66;
    System.out.println("青空霞光" + a + b); // 青空霞光666

  • 算术运算符还包括++和--也就是自增和自减，以自增为例：

    1
    2
    3
    int a = 10;
    a++;
    System.out.println(a); //输出为11

  • 自增自减运算符放在变量的前后的返回值是有区别的：

    1
    2
    3
    int a = 10;
    System.out.println(++a);  //11 （先自增，再返回值）
    System.out.println(a);  //11
    1
    2
    3
    int a = 10;
    System.out.println(a++);  //10 （先返回值，再自增）
    System.out.println(a);   //11

  • 为了使得代码更简洁，你还可以使用扩展的赋值运算符，包括+=、-=、/=、*=、%=，和自增自减类似，先执行运算，再返回结果，同时自身改变：

    1
    2
    int a = 10;
    System.out.println(a += 2);  //等价于 a = a + 2

关系运算法

  • 关系运算符的结果只能是布尔类型，也就是要么为真要么为假，关系运算符包括：

    1
    2
    > < == //大于小于等于
    >= <=  !=  //大于等于，小于等于，不等于

  • 关系运算符一般只用于基本类型的比较，运算结果只能是boolean：

    1
    2
    3
    4
    5
    int a = 10;
    int b = 2;
    boolean x = a > b;
    System.out.println(x);
    //结果为 true

逻辑运算符

  • 逻辑运算符两边只能是boolean类型或是关系/逻辑运算表达式，返回值只能是boolean类型！逻辑运算符包括：

    1
    2
    3
    && //与运算，要求两边同时为true才能返回true
    || //或运算，要求两边至少要有一个为true才能返回true
    ! //非运算，一般放在表达式最前面，表达式用括号扩起来，表示对表达式的结果进行反转

  • 举例：

    1
    2
    3
    4
    int a = 10;
    int b = 2;
    boolean x = a > b && a < b;  //怎么可能同时满足呢
    System.out.println(x);   //false
    1
    2
    3
    4
    int a = 10;
    int b = 2;
    boolean x = a > b || a <= b;  //一定有一个满足！
    System.out.println(x);   //true
    1
    2
    3
    4
    int a = 10;
    int b = 2;
    boolean x = !(a > b); //对结果进行反转，本来应该是true
    System.out.println(x); //false

    位运算符

    1
    2
    3
    4
    & //按位与，注意，返回的是运算后的同类型值，不是boolean！
    | //按位或
    ^ //按位异或 0 ^ 0 = 0
    ~ //按位非

  • 按位运算实际上是根据值的二进制编码来计算结果，例如按位与，以4bit为例：

  • 0101 & 0100 = 0100 （只有同时为1对应位才得1）

    1
    2
    int a = 7, b = 15;
    System.out.println(a & b); //结果为7

三目运算符

  • 三目运算符其实是为了简化代码而生，可以根据条件是否满足来决定返回值，格式如下：

    1
    2
    3
    int a = 7, b = 15;
    String str = a > b ? "行" : "不行";  // 判断条件(只能是boolean,或返回boolean的表达式) ? 满足的返回值 : 不满足的返回值 
    System.out.println("汉堡做的行不行？"+str);  //汉堡做的行不行？不行

  • 此处理解有助于理解后面的if-else语句