「MoreThanJava」Day2：变量、数据类型和运算符

 

  • 「MoreThanJava」 宣扬的是 「学习，不止 CODE」，本系列 Java 基础教程是自己在结合各方面的知识之后，对 Java 基础的一个总回顾，旨在 「帮助新朋友快速高质量的学习」。
  • 当然 不论新老朋友 我相信您都可以 从中获益。如果觉得 「不错」 的朋友，欢迎 「关注 + 留言 + 分享」，文末有完整的获取链接，您的支持是我前进的最大的动力！

1|0Part 1. 数据类型


假设您遇到了以下撕碎的纸片，您觉得会是什么意思？

在不了解上下文的情况下，很难说出 MIX 的含义，它可能是罗马数字 1009，也可以是英语单词 mix 或者别的什么东西。

在不知道上下文的情况下，一串字母没有任何意义。

与一串字母一样，一串 01 的含义取决于如何使用。而决定这一串数据如何使用的方案被称为其 数据类型 (跟文件类型有些类似)。

1|18 种基本数据类型


Java 是一种强类型语言。这意味着必须为每一条数据声明一种类型。在 Java 中共有 8 种基本类型 (primitive type)，其中 4 种整型、2 种浮点类型、1 种字符类型、1 种表示真值的 boolean (布尔) 类型。

整型

整型被用来表示没有小数部分的数值，允许是负数。Java 提供了 4 种整型，具体内容如下：

类型 存储需求 取值范围
int 4 字节 -2147483648 ~ 2147483647 (刚超过 20 亿，这个数值也就是 232 对半分成正负值，32=4字节*每个字节8位)
short 2 字节 -32768 ~ 32767
long 8 字节 -9223372036854775808 ~ 9223372036854775807
byte 1 字节 -128 ~ 127

在通常情况下，int 类型最常用。但如果想要表示整个地球的居住人口，那么就需要使用 long 类型了。byte 和 short 类型主要用于特定的应用场合，例如，底层的文件处理或者存储空间很宝贵时的大数组 (因为节约内存)。

浮点类型

浮点类型用于表示有小数部分的数值。在 Java 中有两种浮点类型，具体内容如下：

类型 存储需求 取值范围
float 4 字节 大约 ±3.40282347E + 38F (大约有效数为 6 ~ 7)
double 8 字节 大约 ±1.7976931486231580E + 308 (大约有效数为 15 位)

double 表示这种类型的数值精度是 float 类型的两倍 (也有人称 double 为双精度数值)。

浮点数精度问题

问一个问题：0.1 + 0.2 = ？

先别奇怪，在 IDEA 中尝试着输出一下这句话就知道了：

System.out.println(0.1 + 0.2);

// 输出：0.30000000000000004

0.1 + 0.2 为什么会等于 0.30000000000000004？而不是我们想象中的 0.3？

这不是因为它们在计算时出现了错误，而是因为浮点数计算标准的要求。

首先我们要明确一点：编程中的浮点数并不能和数学中的小数看做同一个东西。

  • 编程中的浮点数的精度往往都是有限的，单精度的浮点数使用 32 位表示，而双精度的浮点数使用 64 位表示；
  • 数学中的小数系统可以通过引入无限序列....可以表示任意的实数；

请考虑使用 十进制 表示 1/3：

0.3333333333333333....

如果想要完整地表达 1/3 的精度，那么小数点之后的 3 需要无限地写下去。如果需要让你在一张纸上表达清晰，显然由于纸张大小的限制你无法无限地写下去...

0.1 和 0.2 在 二进制 中同 1/3 在 十进制 中一样，不属于整数的范畴，所以只能用近似值来代替，由于精度的限制 0.1 和 0.2 使用单精度浮点数表示的实际值为：0.100000001490116119384765625 和 0.20000000298023223876953125，把它们相加起来得到的结果与我们在一开始看到的非常相似：

在交易系统或者科学计算的场景中，如果需要更高的精度小数，可以使用具有 28 个有效位数的 decimal 或者直接使用分数，不过这些表示方法的开销也随着有效位数的增加而提高，我们应该按照需要选择最合适的方法。

重新回到最开始的问题 — 0.1 和 0.2 相加不等于 0.3 的原因包括以下两个：

  • 使用二进制表达十进制的小数时，某些数字无法被有限位的二进制小数表示；
  • 单精度和双精度的浮点数只包括 7 位或者 15 位的有效小数位，存储需要无限位表示的小数时只能存储近似值；

在使用单精度和双精度浮点数时也应该牢记它们只有 7 位和 15 位的有效位数。

char 类型

char 用来表示单个字符。在 Java 中 char 类型的数据使用 16 位来存储和表示，而许多编程语言则仅用 8 位。

char 类型的字面量值需要用 单引号 括起来。例如：'A' 是编码值为 65 的 字符常量，它与 "A" 不同，"A" 是仅包含字符 A 的 字符串 (String 类型)。

强烈建议：不要在程序中使用 char 类型，除非您确实需要处理 UTF-16 代码单元。

(更多相关资料放入了下面的自取资料，感兴趣可以去阅读一下更多 char 类型的东西，不感兴趣跳过即可...)

boolean 类型

boolean (布尔) 类型有两个值：false 和 true (注意这两个是布尔类型的字面常量也是保留字)，用来判断逻辑条件是否成立。

1|2对象类型


Java 中的所有数据都属于「基本数据类型」或「对象」中的一种。

虽然只有八种基本数据类型，但 Java 有许多满足您需求的相关类型的对象供您使用，例如，表示字符串的 String 类型。

我们会在之后的内容中更多地讨论对象 (因为 Java 是一种面向对象的编程语言)，现在，您需要了解以下信息：

  • 基本数据类型使用少量的固定字节数 (下面会详细介绍)；
  • 只有 8 种基本数据类型，您无法创建新的原始数据类型；
  • 一个对象是一个较大的数据块，可能使用很多字节的内存；
  • 对象类型的数据被称为 类；
  • Java 中已经封装了足够多的类用来满足您各类的需求，您也可以发明新的类来满足程序的特定需求；

2|0Part 2. 变量


计算机内存中有数以十亿计的字节用于存储机器指令和数据。

程序运行时，某些内存用于存储机器指令，而另外一些则用于存储数据。后来，当另一个程序运行时，以前保存的机器指令中的某些字节现在可以用来保存数据，而之前保存的数据中的某些字节现在可以保存机器指令。

计算机先驱 约翰·冯·诺依曼 (John von Neumann) 的想法是：使用相同的存储器来存储指令和数据。

回想一下，数据类型是一种使用位模式来表示值的方案。

可以把 变量 视为一个由一个或多个字节组成的小盒子，该盒子可以使用特定的数据类型保存值。

要将值存储在内存中，以后再取回它，则程序必须为每个变量指定一个名称，如 className/ payAmount (变量名采用小驼峰命名法)。

变量随运行程序的需要而变化。当正在运行的程序不再需要变量时，该内存部分可用于其他目的。

2|1声明变量


在 Java 中，每个变量都必须有一个类型 (type)。在声明变量时，需要先指定变量的类型，然后是变量名：

double salary;
int vacationDays;
long earthPopluation;
boolean finished;

可以看到，每个变量都以分号 (;) 结束。由于声明是一条完整的 Java 语句，而所有的 Java 语句都以分号结束，所以这里的分号是必须的。

变量命名

在 Java 中，变量命名需要遵循以下硬性规定和强烈建议遵守的非硬性规定：

硬性规则

  1. 变量名必须是一个以字母开头并由字母或数字构成的序列 (尽管 $ 是合法的，但不要在你自己的代码中使用这个字符，它只用在 Java 编译器或其他工具生成的名字中)；
  2. 每一个字符都有意义，且大小写敏感；
  3. 不要使用 Java 中的保留字；

《阿里巴巴 Java 开发手册》规则

  1. 【强制】 代码中的命名 (所有标识符) 均不能以下划线或美元符号开始，也不能以下划线或美元符号结束；(反例: $name)
  2. 【强制] 代码中的命名严禁使用拼音与英文混合的方式，更不允许直接使用中文的方式；(反例：DaZhePromotion - 打折)
  3. 【强制】 杜绝完全不规范的缩写，避免词不达意；(反例：condition 缩写成 condi)
  4. 【推荐】 为了达到代码自解释的目的，任何自定义编程元素在命名时，使用尽量完整的单词组合来表达其意；(反例：int a; 的随意命名方式)

2|2变量初始化


声明一个变量之后，必须用赋值语句对变量进行显式初始化，千万不要使用未初始化的变量的值。例如，Java 编译器认为下面的语句序列是错误的：

int amount;
System.out.println(amount); // ERROR -- variable not initialized

要相对一个已经声明过的变量进行赋值，就需要将变量名放在等号 (=) 左侧，再把一个适当取值放在等号的右侧：

int amount;
amount = 12;

也可以将变量的声明和初始化放在同一行中。例如：

int amount = 12;

最后，在 Java 中可以将声明放在代码中的任何地方。

但让变量尽可能地靠近变量第一次使用的地方，这是一种良好的程序编写风格。

2|3变量使用范例


我们来使用变量完成两个数的加减乘除：

int num1 = 2;
int num2 = 3;
System.out.println(num1 + num2);
System.out.println(num1 - num2);
System.out.println(num1 * num2);
System.out.println(num1 / num2);

3|0Part 3. 运算符


计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java 也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：

  • 算术运算符;
  • 关系运算符;
  • 位运算符;
  • 逻辑运算符;
  • 赋值运算符;
  • 其他运算符;

3|1算术运算符


算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。

表格中的实例假设整数变量 A 的值为 10，变量 B 的值为 20：

实例

下面的简单示例程序演示了算术运算符。复制并粘贴下面的 Java 程序并保存为 Test.java 文件，然后编译并运行这个程序：

public class Test {

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
        System.out.println("a + b = " + (a + b));
        System.out.println("a - b = " + (a - b));
        System.out.println("a * b = " + (a * b));
        System.out.println("b / a = " + (b / a));
        System.out.println("b % a = " + (b % a));
        System.out.println("c % a = " + (c % a));
        System.out.println("a++   = " + (a++));
        System.out.println("a--   = " + (a--));
        // 查看  d++ 与 ++d 的不同
        System.out.println("d++   = " + (d++));
        System.out.println("++d   = " + (++d));
    }
}

运行结果：

a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++   = 10
a--   = 11
d++   = 25
++d   = 27

i++ 与 ++i 到底有什么不同？

实际上，不管是前置 ++，还是后置 ++，都是先将变量的值加 1，然后才继续计算的。

二者之间真正的区别是：前置 ++ 是将变量的值加 1 后，使用增值后的变量进行运算的，而后置 ++ 是首先将变量赋值给一个临时变量，接下来对变量的值加 1，然后使用那个临时变量进行运算。

3|2关系运算符


下表为Java支持的关系运算符。

表格中的实例整数变量 A 的值为 10，变量 B 的值为 20：

实例

下面的简单示例程序演示了关系运算符。复制并粘贴下面的 Java 程序并保存为 Test.java 文件，然后编译并运行这个程序：

public class Test {

    public static void main(String[] args) {
        int a = 10;
        int b = 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));
        System.out.println("b >= a = " + (b >= a));
        System.out.println("b <= a = " + (b <= a));
    }
}

运行结果：

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

3|3位运算符


Java定义了位运算符，应用于整数类型 (int)，长整型 (long)，短整型 (short)，字符型 (char)，和字节型 (byte) 等类型。

位运算符作用在所有的位上，并且按位运算。假设 a = 60，b = 13; 它们的二进制格式表示将如下：

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A = 1100 0011

下表列出了位运算符的基本运算，假设整数变量 A 的值为 60 和变量 B 的值为 13：

实例

下面的简单示例程序演示了关系运算符。复制并粘贴下面的 Java 程序并保存为 Test.java 文件，然后编译并运行这个程序：

public class Test {

    public static void main(String[] args) {
        int a = 60; /* 60 = 0011 1100 */
        int b = 13; /* 13 = 0000 1101 */
        int c = 0;
        c = a & b;       /* 12 = 0000 1100 */
        System.out.println("a & b = " + c);

        c = a | b;       /* 61 = 0011 1101 */
        System.out.println("a | b = " + c);

        c = a ^ b;       /* 49 = 0011 0001 */
        System.out.println("a ^ b = " + c);

        c = ~a;          /*-61 = 1100 0011 */
        System.out.println("~a = " + c);

        c = a << 2;     /* 240 = 1111 0000 */
        System.out.println("a << 2 = " + c);

        c = a >> 2;     /* 15 = 1111 */
        System.out.println("a >> 2  = " + c);

        c = a >>> 2;     /* 15 = 0000 1111 */
        System.out.println("a >>> 2 = " + c);
    }
}

运行结果：

a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2  = 15
a >>> 2 = 15

3|4逻辑运算符


下表列出了逻辑运算符的基本运算，假设布尔变量 A 为真，变量 B 为假：

实例

下面的简单示例程序演示了关系运算符。复制并粘贴下面的 Java 程序并保存为 Test.java 文件，然后编译并运行这个程序：

public class Test {

    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        System.out.println("a && b = " + (a && b));
        System.out.println("a || b = " + (a || b));
        System.out.println("!(a && b) = " + !(a && b));
    }
}

运行结果：

a && b = false
a || b = true
!(a && b) = true

短路逻辑运算符

当使用与逻辑运算符时，在两个操作数都为 true 时，结果才为 true，但是当得到第一个操作为 false 时，其结果就必定是 false，这时候就不会再判断第二个操作了。

事实上，如果所有的逻辑表达式都有一部分不必计算，那将获得潜在的性能提升。

实例：

public class LuoJi {

    public static void main(String[] args) {
        int a = 5;//定义一个变量；
        boolean b = (a < 4) && (a++ < 10);
        System.out.println("使用短路逻辑运算符的结果为" + b);
        System.out.println("a的结果为" + a);
    }
}

运行结果：

使用短路逻辑运算符的结果为false
a的结果为5

3|5赋值运算符


下面是 Java 语言支持的赋值运算符：

实例

下面的简单示例程序演示了关系运算符。复制并粘贴下面的 Java 程序并保存为 Test.java 文件，然后编译并运行这个程序：

public class Test {

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 0;
        c = a + b;
        System.out.println("c = a + b = " + c);
        c += a;
        System.out.println("c += a  = " + c);
        c -= a;
        System.out.println("c -= a = " + c);
        c *= a;
        System.out.println("c *= a = " + c);
        a = 10;
        c = 15;
        c /= a;
        System.out.println("c /= a = " + c);
        a = 10;
        c = 15;
        c %= a;
        System.out.println("c %= a  = " + c);
        c <<= 2;
        System.out.println("c <<= 2 = " + c);
        c >>= 2;
        System.out.println("c >>= 2 = " + c);
        c >>= 2;
        System.out.println("c >>= 2 = " + c);
        c &= a;
        System.out.println("c &= a  = " + c);
        c ^= a;
        System.out.println("c ^= a   = " + c);
        c |= a;
        System.out.println("c |= a   = " + c);
    }
}

运行结果：

c = a + b = 30
c += a  = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a  = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a  = 0
c ^= a   = 10
c |= a   = 10

3|6其他运算符


条件运算符 (?😃

条件运算符也被称为三元运算符。该运算符有 3 个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

variable x = (expression) ? value if true : value if false

实例

下面的简单示例程序演示了关系运算符。复制并粘贴下面的 Java 程序并保存为 Test.java 文件，然后编译并运行这个程序：

public class Test {

    public static void main(String[] args) {
        int a, b;
        a = 10;
        // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
        b = (a == 1) ? 20 : 30;
        System.out.println("Value of b is : " + b);

        // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
        b = (a == 10) ? 20 : 30;
        System.out.println("Value of b is : " + b);
    }
}

运行结果：

Value of b is : 30
Value of b is : 20

instanceof 运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

instanceof 运算符使用格式如下：

( Object reference variable ) instanceof  (class/interface type)

如果运算符左侧变量所指的对象，是操作符右侧类或接口 (class/interface) 的一个对象，那么结果为真。

下面是一个例子：

String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

4|0要点回顾


  1. Java 是一种强类型语言，任何一种数据都属于 1 种基本类型或者对象类型 (类) 中的一种；
  2. 8 种基本数据类型；
  3. 为什么引入变量、如何定义使用变量以及变量名的命名规范；
  4. Java 中的运算符以及使用实例；

5|0练习


5|1获取用户输入 Scanner


java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。

下面是创建 Scanner 对象的基本语法：

Scanner scanner = new Scanner(System.in);

在下面的示例中，我们将使用该类的 nextLine() 方法，该方法用于读取字符串：

import java.util.Scanner;  // Import the Scanner class

class MyClass {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);  // Create a Scanner object
        System.out.println("Enter username");

        String userName = scanner.nextLine();  // Read user input
        System.out.println("Username is: " + userName);  // Output user input
    }
}

输入类型

在上面的示例中，我们使用了 nextLine() 用于读取字符串的方法。要阅读其他类型，请查看下表：

5|2练习 1：输入圆的半径计算周长和面积


参考答案：

import java.util.Scanner;

public class Tester {

    public static void main(String[] args) {
        System.out.println("请输入圆的半径：");

        Scanner scanner = new Scanner(System.in);
        int radius = scanner.nextInt();

        // 计算周长和面积
        double area = radius * radius * 3.14;
        double perimeter = 2 * 3.14 * radius;

        System.out.println("该圆的面积为：" + area);
        System.out.println("该圆的周长为：" + perimeter);
    }
}

5|3练习 2：输入年份判断是不是闰年


提示：

闰年需要满足：

  1. 能被 4 整除，并且不能被 100 整除；
  2. 或者能被 400 整除；

参考答案：

import java.util.Scanner;

public class Tester {

    public static void main(String[] args) {
        System.out.println("请输入年份：");

        Scanner scanner = new Scanner(System.in);
        int year = scanner.nextInt();

        boolean leapYear;

        boolean divisbleBy4 = year % 4 == 0;
        boolean notDivisbleBy100 = year % 100 != 0;
        boolean divisibleBy400 = year % 400 == 0;
        leapYear = (divisbleBy4 && notDivisbleBy100) || divisibleBy400;

        System.out.println("该年份是否是闰年：" + leapYear);
    }
}

6|0自取资料


6|1扩展阅读推荐


  1. Java 基本数据类型 | 菜鸟教程 - https://www.runoob.com/java/java-basic-datatypes.html
  2. 浮点类型精度深度讨论：
    1. 为什么 0.1 + 0.2 = 0.3？ - https://draveness.me/whys-the-design-decimal-and-rational/
    2. 为什么 0.1 + 0.2 = 0.300000004？ - https://draveness.me/whys-the-design-floating-point-arithmetic/#fn:2
  3. IEEE754标准: 浮点数在内存中的存储方式 - https://www.jianshu.com/p/8ee02e9bb57d
  4. 为什么Java中char类型不能完整表示一个字符？ - https://fookwood.com/java-string-charset-char

6|2推荐书籍


Java 核心技术·卷 I(原书第 11 版)

推荐理由： 这本书在知识体系完整充实的同时，又比《Thinking in Java》暴风式的知识洗礼来得轻松，新人入门书籍强烈推荐！

码出高效：Java开发手册

推荐理由： 阿里系出品。从最基础的计算机基础入手，到 Java 的方方面面，加上精美的配图和通俗易懂的解释，是非常适合新手阅读的一本儿关于 Java 的技术书籍。

7|0参考资料


  1. Introduction to Computer Science using Java - http://programmedlessons.org/Java9/index.html#part02
  2. Java 运算符 | 菜鸟教程 - https://www.runoob.com/java/java-operators.html
  3. 《Java 核心技术 卷I》(第11版)
  • 本文已收录至我的 Github 程序员成长系列 【More Than Java】，学习，不止 Code，欢迎 star：https://github.com/wmyskxz/MoreThanJava
  • 个人公众号 ：wmyskxz，个人独立域名博客：wmyskxz.com，坚持原创输出，下方扫码关注，2020，与您共同成长！

非常感谢各位人才能 看到这里，如果觉得本篇文章写得不错，觉得 「我没有三颗心脏」有点东西 的话，求点赞，求关注，求分享，求留言！

创作不易，各位的支持和认可，就是我创作的最大动力，我们下篇文章见！


__EOF__

本文作者：我没有三颗心脏
本文链接：https://www.cnblogs.com/wmyskxz/p/13236804.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！
posted @   我没有三颗心脏  阅读(380)  评论(0)  编辑  收藏  举报
编辑推荐：
· go语言实现终端里的倒计时
· 如何编写易于单元测试的代码
· 10年+ .NET Coder 心语，封装的思维：从隐藏、稳定开始理解其本质意义
· .NET Core 中如何实现缓存的预热？
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
阅读排行：
· 周边上新：园子的第一款马克杯温暖上架
· Open-Sora 2.0 重磅开源！
· 分享 3 个 .NET 开源的文件压缩处理库，助力快速实现文件压缩解压功能！
· Ollama——大语言模型本地部署的极速利器
· DeepSeek如何颠覆传统软件测试？测试工程师会被淘汰吗？
点击右上角即可分享
微信分享提示
AI IDE Trae

喜欢请打赏

扫描二维码打赏

支付宝打赏