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

时间 2020-07-05

标签 morethanjava day 变量数据类型运算符繁體版

原文原文链接

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

Part 1. 数据类型

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

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

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

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

8 种基本数据类型

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

整型

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

类型	存储需求	取值范围
int	4 字节	-2147483648 ~ 2147483647 (刚超过 `20` 亿，这个数值也就是 2³² 对半分红正负值，`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 为双精度数值)。less

浮点数精度问题

问一个问题：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 (注意这两个是布尔类型的字面常量也是保留字)，用来判断逻辑条件是否成立。

对象类型

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

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

咱们会在以后的内容中更多地讨论对象 (由于 Java 是一种面向对象的编程语言)，如今，您须要了解如下信息：

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

Part 2. 变量

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

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

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

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

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

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

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

声明变量

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

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

能够看到，每一个变量都以分号 (;) 结束。因为声明是一条完整的 Java 语句，而全部的 Java 语句都以分号结束，因此这里的分号是必须的。

变量命名

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

硬性规则

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

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

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

变量初始化

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

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

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

int amount;
amount = 12;

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

int amount = 12;

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

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

变量使用范例

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

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);

Part 3. 运算符

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

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

算术运算符

算术运算符用在数学表达式中，它们的做用和在数学中的做用同样。下表列出了全部的算术运算符。

表格中的实例假设整数变量 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，而后使用那个临时变量进行运算。

关系运算符

下表为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

位运算符

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

逻辑运算符

下表列出了逻辑运算符的基本运算，假设布尔变量 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

赋值运算符

下面是 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 个操做数，而且须要判断布尔表达式的值。该运算符的主要是决定哪一个值应该赋值给变量。

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 类型，因此返回真

要点回顾

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

练习

获取用户输入 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() 用于读取字符串的方法。要阅读其余类型，请查看下表：

引用自：https://www.w3schools.com/jav...

练习 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);
    }
}

练习 2：输入年份判断是否是闰年

提示：

闰年须要知足：

能被 4 整除，而且不能被 100 整除；
或者能被 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);
    }
}

自取资料

扩展阅读推荐

Java 基本数据类型 | 菜鸟教程 - https://www.runoob.com/java/j...
浮点类型精度深度讨论：
1. 为何 0.1 + 0.2 = 0.3？ - https://draveness.me/whys-the...
2. 为何 0.1 + 0.2 = 0.300000004？ - https://draveness.me/whys-the...:2
IEEE754标准: 浮点数在内存中的存储方式 - https://www.jianshu.com/p/8ee...
为何Java中char类型不能完整表示一个字符？ - https://fookwood.com/java-str...

参考资料

Introduction to Computer Science using Java - http://programmedlessons.org/...
Java 运算符 | 菜鸟教程 - https://www.runoob.com/java/j...
《Java 核心技术卷I》(第11版)

本文已收录至个人 Github 程序员成长系列 【More Than Java】，学习，不止 Code，欢迎 star：https://github.com/wmyskxz/MoreThanJava

我的公众号 ：wmyskxz，我的独立域名博客：wmyskxz.com，坚持原创输出，下方扫码关注，2020，与您共同成长！

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

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

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

Part 1. 数据类型

8 种基本数据类型

整型

浮点类型

浮点数精度问题

char 类型

boolean 类型

对象类型

Part 2. 变量

声明变量

变量命名

硬性规则

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

变量初始化

变量使用范例

Part 3. 运算符

算术运算符

实例

i++ 与 ++i 到底有什么不一样？

关系运算符

实例

位运算符

实例

逻辑运算符

实例

短路逻辑运算符

赋值运算符

实例

其余运算符

条件运算符 (?:)

实例

instanceof 运算符

要点回顾

练习

获取用户输入 Scanner

输入类型

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

练习 2：输入年份判断是否是闰年

自取资料

扩展阅读推荐

推荐书籍

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

码出高效：Java开发手册

参考资料