Hello World

Appearance

On This Page

Java快速入门 ​

1. 前言 ​

为什么要学Java？

因为Java是全球排名第一的编程语言，Java工程师也是市场需求最大的软件工程师，选择Java，就是选择了高薪。

1.1 为什么Java应用最广泛？ ​

从互联网到企业平台，Java是应用最广泛的编程语言，原因在于：

  • Java是基于JVM虚拟机的跨平台语言，一次编写，到处运行；
  • Java程序易于编写，而且有内置垃圾收集，不必考虑内存管理；
  • Java虚拟机拥有工业级的稳定性和高度优化的性能，且经过了长时期的考验；
  • Java拥有最广泛的开源社区支持，各种高质量组件随时可用。

Java语言常年霸占着三大市场：

  • 互联网和企业应用，这是Java EE的长期优势和市场地位；
  • 大数据平台，主要有Hadoop、Spark、Flink等，他们都是Java或Scala（一种运行于JVM的编程语言）开发的；
  • Android移动平台。

这意味着Java拥有最广泛的就业市场。

1.2 教程特色 ​

虽然是零基础Java教程，但是覆盖了从基础到高级的Java核心编程，从小白成长到架构师，实现硬实力高薪就业！

并且，时刻更新至最新版Java！目前教程版本是：Java 21!

1.3 主要内容 ​

本章的主要内容是快速掌握Java程序的基础知识，了解并使用变量和各种数据类型，介绍基本的程序流程控制语句。

2. Java历史 ​

Java最早是由SUN公司（已被Oracle收购）的詹姆斯·高斯林（高司令，人称Java之父）在上个世纪90年代初开发的一种编程语言，最初被命名为Oak，目标是针对小型家电设备的嵌入式应用，结果市场没啥反响。谁料到互联网的崛起，让Oak重新焕发了生机，于是SUN公司改造了Oak，在1995年以Java的名称正式发布，原因是Oak已经被人注册了，因此SUN注册了Java这个商标。随着互联网的高速发展，Java逐渐成为最重要的网络编程语言。

Java介于编译型语言和解释型语言之间。编译型语言如C、C++，代码是直接编译成机器码执行，但是不同的平台（x86、ARM等）CPU的指令集不同，因此，需要编译出每一种平台的对应机器码。解释型语言如Python、Ruby没有这个问题，可以由解释器直接加载源码然后运行，代价是运行效率太低。而Java是将代码编译成一种“字节码”，它类似于抽象的CPU指令，然后，针对不同平台编写虚拟机，不同平台的虚拟机负责加载字节码并执行，这样就实现了“一次编写，到处运行”的效果。当然，这是针对Java开发者而言。对于虚拟机，需要为每个平台分别开发。为了保证不同平台、不同公司开发的虚拟机都能正确执行Java字节码，SUN公司制定了一系列的Java虚拟机规范。从实践的角度看，JVM的兼容性做得非常好，低版本的Java字节码完全可以正常运行在高版本的JVM上。

随着Java的发展，SUN给Java又分出了三个不同版本：

  • Java SE：Standard Edition
  • Java EE：Enterprise Edition
  • Java ME：Micro Edition

这三者之间有啥关系呢？

txt
┌───────────────────────────┐
│Java EE                    │
│    ┌────────────────────┐ │
│    │Java SE             │ │
│    │    ┌─────────────┐ │ │
│    │    │   Java ME   │ │ │
│    │    └─────────────┘ │ │
│    └────────────────────┘ │
└───────────────────────────┘

简单来说，Java SE就是标准版，包含标准的JVM和标准库，而Java EE是企业版，它只是在Java SE的基础上加上了大量的API和库，以便方便开发Web应用、数据库、消息服务等，Java EE的应用使用的虚拟机和Java SE完全相同。

Java ME就和Java SE不同，它是一个针对嵌入式设备的“瘦身版”，Java SE的标准库无法在Java ME上使用，Java ME的虚拟机也是“瘦身版”。

毫无疑问，Java SE是整个Java平台的核心，而Java EE是进一步学习Web应用所必须的。我们熟悉的Spring等框架都是Java EE开源生态系统的一部分。不幸的是，Java ME从来没有真正流行起来，反而是Android开发成为了移动平台的标准之一，因此，没有特殊需求，不建议学习Java ME。

因此我们推荐的Java学习路线图如下：

  1. 首先要学习Java SE，掌握Java语言本身、Java核心开发技术以及Java标准库的使用；
  2. 如果继续学习Java EE，那么Spring框架、数据库开发、分布式架构就是需要学习的；
  3. 如果要学习大数据开发，那么Hadoop、Spark、Flink这些大数据平台就是需要学习的，他们都基于Java或Scala开发；
  4. 如果想要学习移动开发，那么就深入Android平台，掌握Android App开发。

无论怎么选择，Java SE的核心技术是基础。

2.1 Java版本 ​

从1995年发布1.0版本开始，到目前为止，最新的Java版本是Java 21：

时间版本
19951.0
19981.2
20001.3
20021.4
20041.5 / 5.0
20051.6 / 6.0
20111.7 / 7.0
20141.8 / 8.0
2017/91.9 / 9.0
2018/310
2018/911
2019/312
2019/913
2020/314
2020/915
2021/316
2021/917
2022/318
2022/919
2023/320
2023/921

2.2 名词解释 ​

初学者学Java，经常听到JDK、JRE......这些名词，它们到底是啥？

JDK、JRE ​

  • JDK：Java Development Kit
  • JRE：Java Runtime Environment

简单地说，JRE就是运行Java字节码的虚拟机。但是，如果只有Java源码，要编译成Java字节码，就需要JDK，因为JDK除了包含JRE，还提供了编译器、调试器等开发工具。

txt
二者关系如下：
  ┌─────┌──────────────────────────────────┐
  │     │     Compiler, debugger, etc.     │
  │     └──────────────────────────────────┘
 JDK ┌─ ┌──────────────────────────────────┐
  │  │  │                                  │
  │ JRE │      JVM + Runtime Library       │
  │  │  │                                  │
  └─ └─ └──────────────────────────────────┘
        ┌───────┐┌───────┐┌───────┐┌───────┐
        │Windows││ Linux ││ macOS ││others │
        └───────┘└───────┘└───────┘└───────┘

JSR、JCP ​

  • JSR规范：Java Specification Request
  • JCP组织：Java Community Process

为了保证Java语言的规范性，SUN公司搞了一个JSR规范，凡是想给Java平台加一个功能，比如说访问数据库的功能，大家要先创建一个JSR规范，定义好接口，这样，各个数据库厂商都按照规范写出Java驱动程序，开发者就不用担心自己写的数据库代码在MySQL上能跑，却不能跑在PostgreSQL上。

所以JSR是一系列的规范，从JVM的内存模型到Web程序接口，全部都标准化了。而负责审核JSR的组织就是JCP。

RI、TCK ​

一个JSR规范发布时，为了让大家有个参考，还要同时发布一个“参考实现”，以及一个“兼容性测试套件”：

  • RI：Reference Implementation
  • TCK：Technology Compatibility Kit

比如有人提议要搞一个基于Java开发的消息服务器，这个提议很好啊，但是光有提议还不行，得贴出真正能跑的代码，这就是RI。如果有其他人也想开发这样一个消息服务器，如何保证这些消息服务器对开发者来说接口、功能都是相同的？所以还得提供TCK。

通常来说，RI只是一个“能跑”的正确的代码，它不追求速度，所以，如果真正要选择一个Java的消息服务器，一般是没人用RI的，大家都会选择一个有竞争力的商用或开源产品。

2.3 安装JDK ​

因为Java程序必须运行在JVM之上，所以，我们第一件事情就是安装JDK。

搜索JDK 21，确保从Oracle的官网下载最新的稳定版JDK：

txt
Linux  macOS  Windows
              -------

x64 Compressed Archive      Download
x64 Installer               Download
x64 MSI Installer           Download

选择合适的操作系统与安装包，找到Java SE 21的下载链接Download，下载安装即可。Windows优先选x64 MSI Installer，Linux和macOS要根据自己电脑的CPU是ARM还是x86选择合适的安装包。

设置环境变量 ​

  • 安装完JDK后，需要设置一个JAVA_HOME的环境变量，它指向JDK的安装目录。
  • 然后，把JAVA_HOME的bin目录附加到系统环境变量PATH上。
  • 把JAVA_HOME的bin目录添加到PATH中是为了在任意文件夹下都可以运行java。打开命令提示符窗口，输入命令java -version，如果一切正常，你会看到所安装的java的一些版本信息。如果你看到的版本号不是21，而是15、1.8之类，说明系统存在多个JDK，且默认JDK不是JDK 21，需要把JDK 21提到PATH前面。

JDK ​

细心的童鞋还可以在JAVA_HOME的bin目录下找到很多可执行文件：

  • java：这个可执行程序其实就是JVM，运行Java程序，就是启动JVM，然后让JVM执行指定的编译后的代码；
  • javac：这是Java的编译器，它用于把Java源码文件（以.java后缀结尾）编译为Java字节码文件（以.class后缀结尾）；
  • jar：用于把一组.class文件打包成一个.jar文件，便于发布；
  • javadoc：用于从Java源码中自动提取注释并生成文档；
  • jdb：Java调试器，用于开发阶段的运行调试。

2.4 第一个Java程序 ​

java
// Hello.java
public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

在一个Java程序中，你总能找到一个类似：

java
public class Hello {
    ...
}

的定义，这个定义被称为class（类），这里的类名是Hello，大小写敏感，class用来定义一个类，public表示这个类是公开的，public、class都是Java的关键字，必须小写，Hello是类的名字，按照习惯，首字母H要大写。而花括号{}中间则是类的定义。

注意到类的定义中，我们定义了一个名为main的方法：

java
public static void main(String[] args) {
	...
}

方法是可执行的代码块，一个方法除了方法名main，还有用()括起来的方法参数，这里的main方法有一个参数，参数类型是String[]，参数名是args，public、static用来修饰方法，这里表示它是一个公开的静态方法，void是方法的返回类型，而花括号{}中间的就是方法的代码。

方法的代码每一行用;结束，这里只有一行代码，就是：

java
System.out.println("Hello, world!");

它用来打印一个字符串到屏幕上。

Java规定，某个类定义的public static void main(String[] args)是Java程序的固定入口方法，因此，Java程序总是从main方法开始执行。

注意到Java源码的缩进不是必须的，但是用缩进后，格式好看，很容易看出代码块的开始和结束，缩进一般是4个空格或者一个tab。

最后，当我们把代码保存为文件时，文件名必须是Hello.java，而且文件名也要注意大小写，因为要和我们定义的类名Hello完全保持一致。

如何运行Java程序 ​

Java源码本质上是一个文本文件，我们需要先用javac把Hello.java编译成字节码文件Hello.class，然后，用java命令执行这个字节码文件Hello。因此，可执行文件javac是编译器，而可执行文件java就是虚拟机。

bash
javac Hello.java
java Hello

小结 ​

  • 一个Java源码只能定义一个public类型的class，并且class名称和文件名要完全一致；
  • 使用javac可以将.java源码编译成.class字节码；
  • 使用java可以运行一个已编译的Java程序，参数是类名。

2.5 Java代码助手 ​

Java代码运行助手可以让你在线输入Java代码，然后远程运行后，在网页显示代码执行结果。（自行查找）

2.6 使用IDE ​

IDE是集成开发环境：Integrated Development Environment的缩写。

使用IDE的好处在于，可以把编写代码、组织项目、编译、运行、调试等放到一个环境中运行，能极大地提高开发效率。

IDE提升开发效率主要靠以下几点：

  • 编辑器的自动提示，可以大大提高敲代码的速度；
  • 代码修改后可以自动重新编译，并直接运行；
  • 可以方便地进行断点调试。

目前，流行的用于Java开发的IDE有：

  • Eclipse
  • IntelliJ IDEA（推荐）

3. Java程序基础 ​

3.1 Java程序基本结构 ​

我们先剖析一个完整的Java程序，它的基本结构是什么：

java
public class Hello {
    public static void main(String[] args) {
        // 向屏幕输出文本:
        System.out.println("Hello, world!");
        /* 多行注释开始
        注释内容
        注释结束 */
    }
} // class定义结束

类、方法 ​

因为Java是面向对象的语言，一个程序的基本单位就是class，class是关键字，这里定义的class名字就是Hello。

类名要求：

  • 类名必须以英文字母开头，后接字母，数字和下划线的组合。
  • 习惯以大写字母开头。

注意到public是访问修饰符，表示该class是公开的。不写public，也能正确编译，但是这个类将无法从命令行执行。

在class内部，可以定义若干方法（method）。方法定义了一组执行语句，方法内部的代码将会被依次顺序执行。这里的方法名是main，返回值是void，表示没有任何返回值。

我们注意到public除了可以修饰class外，也可以修饰方法。而关键字static是另一个修饰符，它表示静态方法，后面我们会讲解方法的类型，目前，我们只需要知道，Java入口程序规定的方法必须是静态方法，方法名必须为main，括号内的参数必须是String数组。

方法名也有命名规则，命名和class一样，但是首字母小写。在方法内部，语句才是真正的执行代码。Java的每一行语句必须以分号结束。

注释 ​

在Java程序中，注释是一种给人阅读的文本，不是程序的一部分，所以编译器会自动忽略注释。

Java有3种注释，第一种是单行注释，以双斜线开头，直到这一行的结尾结束；第二种多行注释以/*星号开头，以*/结束，可以有多行；还有一种特殊的多行注释，以/**开头，以*/结束，如果有多行，每行通常以星号开头。

java
// 这是注释...

/*
这是注释
这也是注释
*/

/**
 * 可以用来自动创建文档的注释
 * @auther wen
 */

3.2 变量和数据类型 ​

什么是变量？变量就是初中数学的代数的概念，例如一个简单的方程，x，y都是变量：y=2x+1。

在Java中，变量分为两种：基本类型的变量和引用类型的变量。

在Java中，变量必须先定义后使用，在定义变量的时候，可以给它一个初始值。例如：

java
int x = 1;

上述语句定义了一个整型int类型的变量，名称为x，初始值为1。不写初始值，就相当于给它指定了默认值。默认值总是0。

java
public class Main {
    public static void main(String[] args) {
        int x = 100; // 定义int类型变量x，并赋予初始值100
        System.out.println(x); // 打印该变量的值，观察是否为100
        x = 200; // 重新赋值为200
        System.out.println(x); // 打印该变量的值，观察是否为200
    }
}

变量的一个重要特点是可以重新赋值。例如，对变量x，先赋值100，再赋值200。第二次重新赋值的时候，变量x已经存在了，不能再重复定义，因此不能指定变量类型int，必须使用语句x = 200;。

变量不但可以重新赋值，还可以赋值给其他变量。注意，等号=是赋值语句，不是数学意义上的相等。

基本数据类型 ​

基本数据类型是CPU可以直接进行运算的类型。Java定义了以下几种基本数据类型：

  • 整数类型：byte，short，int，long
  • 浮点数类型：float，double
  • 字符类型：char
  • 布尔类型：boolean

Java定义的这些基本数据类型有什么区别呢？要了解这些区别，我们就必须简单了解一下计算机内存的基本结构。计算机内存的最小存储单元是字节（byte），一个字节就是一个8位二进制数，即8个bit。它的二进制表示范围从00000000~11111111，换算成十进制是0~255，换算成十六进制是00~ff。

内存单元从0开始编号，称为内存地址。每个内存单元可以看作一间房间，内存地址就是门牌号。

txt
如下：
  0   1   2   3   4   5   6  ...
┌───┬───┬───┬───┬───┬───┬───┐
│   │   │   │   │   │   │   │...
└───┴───┴───┴───┴───┴───┴───┘

一个字节是1byte，1024字节是1K，1024K是1M，1024M是1G，1024G是1T。一个拥有4T内存的计算机的字节数量就是：

4T = 4 x 1024G
   = 4 x 1024 x 1024M
   = 4 x 1024 x 1024 x 1024K
   = 4 x 1024 x 1024 x 1024 x 1024
   = 4398046511104

不同的数据类型占用的字节数不一样。我们看一下Java基本数据类型占用的字节数：

txt
byte恰好就是一个字节，而long和double需要8个字节。  
       ┌───┐
  byte │   │
       └───┘
       ┌───┬───┐
 short │   │   │
       └───┴───┘
       ┌───┬───┬───┬───┐
   int │   │   │   │   │
       └───┴───┴───┴───┘
       ┌───┬───┬───┬───┬───┬───┬───┬───┐
  long │   │   │   │   │   │   │   │   │
       └───┴───┴───┴───┴───┴───┴───┴───┘
       ┌───┬───┬───┬───┐
 float │   │   │   │   │
       └───┴───┴───┴───┘
       ┌───┬───┬───┬───┬───┬───┬───┬───┐
double │   │   │   │   │   │   │   │   │
       └───┴───┴───┴───┴───┴───┴───┴───┘
       ┌───┬───┐
  char │   │   │
       └───┴───┘

整型 ​

对于整数类型，Java只定义了带符号的整型，因此，最高位的bit表示符号位（0表示正数，1表示负数）。各种整型能表示的最大范围如下：

  • byte：-128 ~ 127
  • short: -32768 ~ 32767
  • int: -2147483648 ~ 2147483647
  • long: -9223372036854775808 ~ 9223372036854775807

特别注意：1、long型的结尾需要加L。2、int类型可以赋值给long，但不能把long型赋值给int。3、同一个数的不同进制的表示是完全相同的，例如15=0xf＝0b1111。

浮点型 ​

浮点类型的数就是小数，因为小数用科学计数法表示的时候，小数点是可以“浮动”的，如1234.5可以表示成12.345x10^2，也可以表示成1.2345x10^3，所以称为浮点数。

java
float f1 = 3.14f;
float f2 = 3.14e38f; // 科学计数法表示的3.14x10^38
float f3 = 1.0; // 错误：不带f结尾的是double类型，不能赋值给float

double d = 1.79e308;
double d2 = -1.79e308;
double d3 = 4.9e-324; // 科学计数法表示的4.9x10^-324

特别注意：1、对于float类型，需要加上f后缀。2、浮点数可表示的范围非常大，float类型可最大表示3.4x10^38，而double类型可最大表示1.79x10^308。

布尔类型 ​

布尔类型boolean只有true和false两个值，布尔类型总是关系运算的计算结果：

java
boolean b1 = true;
boolean b2 = false;
boolean isGreater = 5 > 3; // 计算结果为true
int age = 12;
boolean isAdult = age >= 18; // 计算结果为false

特别注意：Java语言对布尔类型的存储并没有做规定，因为理论上存储布尔类型只需要1 bit，但是通常JVM内部会把boolean表示为4字节整数。（在不同的虚拟机实现中可能会有所不同，具体实现可以根据虚拟机的需求进行优化）

字符类型 ​

字符类型char表示一个字符。Java的char类型除了可表示标准的ASCII外，还可以表示一个Unicode字符：

java
char a = 'A';
char zh = '中';

特别注意：char类型使用单引号'，且仅有一个字符，要和双引号"的字符串类型区分开。

引用类型 ​

除了上述基本类型的变量，剩下的都是引用类型。例如，引用类型最常用的就是String字符串：

java
String s = "hello";

特别注意：引用类型的变量类似于C语言的指针，它内部存储一个“地址”，指向某个对象在内存的位置。

常量 ​

定义变量的时候，如果加上final修饰符，这个变量就变成了常量：

java
final double PI = 3.14; // PI是一个常量
double r = 5.0;
double area = PI * r * r;
PI = 300; // compile error!

常量在定义时进行初始化后就不可再次赋值，再次赋值会导致编译错误。

常量的作用是用有意义的变量名来避免魔术数字（Magic number），例如，不要在代码中到处写3.14，而是定义一个常量。如果将来需要提高计算精度，我们只需要在常量的定义处修改，例如，改成3.1416，而不必在所有地方替换3.14。

根据习惯，常量名通常全部大写。

var关键字 ​

java
// 有些时候，类型的名字太长，写起来比较麻烦。例如：
StringBuilder sb = new StringBuilder();

// 这个时候，如果想省略变量类型，可以使用var关键字：
var sb = new StringBuilder();

// 编译器会根据赋值语句自动推断出变量sb的类型是StringBuilder。对编译器来说，语句：
// var sb = new StringBuilder();
// 实际上会自动变成：
// StringBuilder sb = new StringBuilder();

因此，使用var定义变量，仅仅是少写了变量类型而已。

变量的作用范围 ​

在Java中，多行语句用{ }括起来。很多控制语句，例如条件判断和循环，都以{ }作为它们自身的范围，例如：

java
if (...) { // if开始
    ...
    while (...) { // while 开始
        ...
        if (...) { // if开始
            ...
        } // if结束
        ...
    } // while结束
    ...
} // if结束

只要正确地嵌套这些{ }，编译器就能识别出语句块的开始和结束。而在语句块中定义的变量，它有一个作用域，就是从定义处开始，到语句块结束。超出了作用域引用这些变量，编译器会报错。举个例子：

java
{
    ...
    int i = 0; // 变量i从这里开始定义
    ...
    {
        ...
        int x = 1; // 变量x从这里开始定义
        ...
        {
            ...
            String s = "hello"; // 变量s从这里开始定义
            ...
        } // 变量s作用域到此结束
        ...
        // 注意，这是一个新的变量s，它和上面的变量同名，
        // 但是因为作用域不同，它们是两个不同的变量:
        String s = "hi";
        ...
    } // 变量x和s作用域到此结束
    ...
} // 变量i作用域到此结束

特别注意：定义变量时，要遵循作用域最小化原则，尽量将变量定义在尽可能小的作用域，并且，不要重复使用变量名。

3.3 整数运算 ​

Java的整数运算遵循四则运算规则，可以使用任意嵌套的小括号。四则运算规则和初等数学一致。例如：

java
int i = (100 + 200) * (99 - 88); // 3300
int n = 7 * (5 + (i - 9)); // 23072

整数的数值表示不但是精确的，而且整数运算永远是精确的，即使是除法也是精确的，因为两个整数相除只能得到结果的整数部分：

java
int x = 12345 / 67; // 184

求余运算使用%：

java
int y = 12345 % 67; // 12345÷67的余数是17

特别注意：整数的除法对于除数为0时运行时将报错，但编译不会报错。

溢出 ​

要特别注意，整数由于存在范围限制，如果计算结果超出了范围，就会产生溢出，而溢出不会出错，却会得到一个奇怪的结果。

java
public class Main {
    public static void main(String[] args) {
        int x = 2147483640;
        int y = 15;
        int sum = x + y;
        System.out.println(sum); // -2147483641
    }
}

主要原因就是把整数2147483640和15换成二进制做加法，最高位表示符号位，所以最后显示成了一个负数。要解决上面的问题，可以把int换成long类型，由于long可表示的整型范围更大，所以结果就不会溢出。

简写运算符 ​

即+=，-=，*=，/=，它们的使用方法如下：

java
int n = 100;
n += 100; // 200, 相当于 n = n + 100;
n -= 100; // 100, 相当于 n = n - 100;

自增/自减 ​

Java还提供了++运算和--运算，它们可以对一个整数进行加1和减1的操作：

java
public class Main {
    public static void main(String[] args) {
        int n = 3300;
        n++; // 3301, 相当于 n = n + 1;
        n--; // 3300, 相当于 n = n - 1;
        int y = 100 + (++n); // 不要这么写
        System.out.println(y);
    }
}

特别注意：++写在前面和后面计算结果是不同的，++n表示先加1再引用n，n++表示先引用n再加1。不建议把++运算混入到常规运算中，容易自己把自己搞懵了。

移位运算 ​

在计算机中，整数总是以二进制的形式表示。例如，int类型的整数7使用4字节表示的二进制如下：

txt
00000000 0000000 0000000 00000111

可以对整数进行移位运算。对整数7左移1位将得到整数14，左移两位将得到整数28：

java
int n = 7;       // 00000000 00000000 00000000 00000111 = 7
int a = n << 1;  // 00000000 00000000 00000000 00001110 = 14
int b = n << 2;  // 00000000 00000000 00000000 00011100 = 28
int c = n << 28; // 01110000 00000000 00000000 00000000 = 1879048192
int d = n << 29; // 11100000 00000000 00000000 00000000 = -536870912

int n = 7;       // 00000000 00000000 00000000 00000111 = 7
int a = n >> 1;  // 00000000 00000000 00000000 00000011 = 3
int b = n >> 2;  // 00000000 00000000 00000000 00000001 = 1
int c = n >> 3;  // 00000000 00000000 00000000 00000000 = 0

如果对一个负数进行右移，最高位的1不动，结果仍然是一个负数：

java
int n = -536870912;
int a = n >> 1;  // 11110000 00000000 00000000 00000000 = -268435456
int b = n >> 2;  // 11111000 00000000 00000000 00000000 = -134217728
int c = n >> 28; // 11111111 11111111 11111111 11111110 = -2
int d = n >> 29; // 11111111 11111111 11111111 11111111 = -1

还有一种无符号的右移运算，使用>>>，它的特点是不管符号位，右移后高位总是补0，因此，对一个负数进行>>>右移，它会变成正数，原因是最高位的1变成了0：

java
int n = -536870912;
int a = n >>> 1;  // 01110000 00000000 00000000 00000000 = 1879048192
int b = n >>> 2;  // 00111000 00000000 00000000 00000000 = 939524096
int c = n >>> 29; // 00000000 00000000 00000000 00000111 = 7
int d = n >>> 31; // 00000000 00000000 00000000 00000001 = 1

特别注意：对byte和short类型进行移位时，会首先转换为int再进行位移。

位运算 ​

位运算是按位进行与、或、非和异或的运算。

java
// 与运算的规则是，必须两个数同时为1，结果才为1：
n = 0 & 0; // 0
n = 0 & 1; // 0
n = 1 & 0; // 0
n = 1 & 1; // 1

// 或运算的规则是，只要任意一个为1，结果就为1：
n = 0 | 0; // 0
n = 0 | 1; // 1
n = 1 | 0; // 1
n = 1 | 1; // 1

// 非运算的规则是，0和1互换：
n = ~0; // 1
n = ~1; // 0

// 异或运算的规则是，如果两个数相同，结果为0，否则为1：
n = 0 ^ 0; // 0
n = 0 ^ 1; // 1
n = 1 ^ 0; // 1
n = 1 ^ 1; // 0

运算优先级 ​

在Java的计算表达式中，运算优先级从高到低依次是：

  • ()
  • ! ~ ++ --
  • * / %
  • + -
  • << >> >>>
  • &
  • |
  • += -= *= /=

类型自动提升与强制转型 ​

在运算过程中，如果参与运算的两个数类型不一致，那么计算结果为较大类型的整型。例如，short和int计算，结果总是int，原因是short首先自动被转型为int。

java
short s = 1234;
int i = 123456;
int x = s + i; // s自动转型为int
short y = s + i; // 编译错误!

也可以将结果强制转型，即将大范围的整数转型为小范围的整数。强制转型使用(类型)，例如，将int强制转型为short：

java
int i = 12345;
short s = (short) i; // 12345

特别注意：超出范围的强制转型会得到错误的结果，原因是转型时，int的两个高位字节直接被扔掉，仅保留了低位的两个字节。因此，强制转型的结果很可能是错的。

3.4 浮点数运算 ​

浮点数运算和整数运算相比，只能进行加减乘除这些数值计算，不能做位运算和移位运算。

在计算机中，浮点数虽然表示的范围大，但是，浮点数有个非常重要的特点，就是浮点数常常无法精确表示。

举个栗子：浮点数0.1在计算机中就无法精确表示，因为十进制的0.1换算成二进制是一个无限循环小数，很显然，无论使用float还是double，都只能存储一个0.1的近似值。但是，0.5这个浮点数又可以精确地表示。

java
double x = 1.0 / 10;     // 0.1
double y = 1 - 9.0 / 10; // 0.09999999999999998

由于浮点数存在运算误差，所以比较两个浮点数是否相等常常会出现错误的结果。正确的比较方法是判断两个浮点数之差的绝对值是否小于一个很小的数：

java
// 比较x和y是否相等，先计算其差的绝对值:
double r = Math.abs(x - y);
// 再判断绝对值是否足够小:
if (r < 0.00001) {
    // 可以认为相等
} else {
    // 不相等
}

浮点数在内存的表示方法和整数比更加复杂。Java的浮点数完全遵循IEEE-754标准，这也是绝大多数计算机平台都支持的浮点数标准表示方法。

溢出 ​

整数运算在除数为0时会报错，而浮点数运算在除数为0时，不会报错，但会返回几个特殊值：

  • NaN表示Not a Number
  • Infinity表示无穷大
  • -Infinity表示负无穷大
java
// 这三种特殊值在实际运算中很少碰到，我们只需要了解即可
double d1 = 0.0 / 0; // NaN
double d2 = 1.0 / 0; // Infinity
double d3 = -1.0 / 0; // -Infinity

类型提升 ​

如果参与运算的两个数其中一个是整型，那么整型可以自动提升到浮点型。

特别注意：在一个复杂的四则运算中，两个整数的运算不会出现自动提升的情况。例如：

java
double d = 1.2 + 24 / 5; // 5.2

编译器计算24 / 5这个子表达式时，按两个整数进行运算，结果仍为整数4。

强制转型 ​

可以将浮点数强制转型为整数。在转型时，浮点数的小数部分会被丢掉。如果转型后超过了整型能表示的最大范围，将返回整型的最大值。例如：

java
int n1 = (int) 12.3; // 12
int n2 = (int) 12.7; // 12
int n2 = (int) -12.7; // -12
int n3 = (int) (12.7 + 0.5); // 13
int n4 = (int) 1.2e20; // 2147483647

3.5 布尔运算 ​

对于布尔类型boolean，永远只有true和false两个值。

布尔运算是一种关系运算，包括以下几类：

  • 比较运算符：>，>=，<，<=，==，!=
  • 与运算 &&
  • 或运算 ||
  • 非运算 !
java
boolean isGreater = 5 > 3; // true
int age = 12;
boolean isZero = age == 0; // false
boolean isNonZero = !isZero; // true
boolean isAdult = age >= 18; // false
boolean isTeenager = age >6 && age <18; // true

关系运算符的优先级从高到低依次是：

  • !
  • >，>=，<，<=
  • ==，!=
  • &&
  • ||

短路运算 ​

布尔运算的一个重要特点是短路运算。如果一个布尔运算的表达式能提前确定结果，则后续的计算不再执行，直接返回结果。因为false && x的结果总是false，因此，与运算在确定第一个值为false后，不再继续计算，而是直接返回false。

java
boolean b = 5 < 3;
boolean result = b && (5 / 0 > 0);

如果没有短路运算，&&后面的表达式会由于除数为0而报错，但实际上该语句并未报错，原因在于与运算是短路运算符，提前计算出了结果false。

类似的，对于||运算，只要能确定第一个值为true，后续计算也不再进行，而是直接返回true。

三元运算符 ​

Java还提供一个三元运算符b ? x : y，它根据第一个布尔表达式的结果，分别返回后续两个表达式之一的计算结果。

特别注意：三元运算b ? x : y会首先计算b，如果b为true，则只计算x，否则，只计算y。此外，x和y的类型必须相同，因为返回值不是boolean，而是x和y之一。

3.6 字符和字符串 ​

在Java中，字符和字符串是两个不同的类型。

字符类型 ​

字符类型char是基本数据类型，它是character的缩写。一个char保存一个Unicode字符：

java
char c1 = 'A';
char c2 = '中';

因为Java在内存中总是使用Unicode表示字符，所以，一个英文字符和一个中文字符都用一个char类型表示，它们都占用两个字节。要显示一个字符的Unicode编码，只需将char类型直接赋值给int类型即可：

java
int n1 = 'A'; // 字母“A”的Unicodde编码是65
int n2 = '中'; // 汉字“中”的Unicode编码是20013

还可以直接用转义字符\u+Unicode编码来表示一个字符：

java
// 注意是十六进制:
char c3 = '\u0041'; // 'A'，因为十六进制0041 = 十进制65
char c4 = '\u4e2d'; // '中'，因为十六进制4e2d = 十进制20013

字符串类型 ​

和char类型不同，字符串类型String是引用类型，我们用双引号"..."表示字符串。一个字符串可以存储0个到任意个字符：

java
String s = ""; // 空字符串，包含0个字符
String s1 = "A"; // 包含一个字符
String s2 = "ABC"; // 包含3个字符
String s3 = "中文 ABC"; // 包含6个字符，其中有一个空格

因为字符串使用双引号"..."表示开始和结束，那如果字符串本身恰好包含一个"字符怎么表示？例如，"abc"xyz"，编译器就无法判断中间的引号究竟是字符串的一部分还是表示字符串结束。这个时候，我们需要借助转义字符\：

java
String s = "abc\"xyz"; // 包含7个字符: a, b, c, ", x, y, z

因为\是转义字符，所以，两个\\表示一个\字符：

java
String s = "abc\\xyz"; // 包含7个字符: a, b, c, \, x, y, z

常见的转义字符包括：

  • \" 表示字符"
  • \' 表示字符'
  • \\ 表示字符\
  • \n 表示换行符
  • \r 表示回车符
  • \t 表示Tab
  • \u#### 表示一个Unicode编码的字符

字符串连接 ​

Java的编译器对字符串做了特殊照顾，可以使用+连接任意字符串和其他数据类型，这样极大地方便了字符串的处理。如果用+连接字符串和其他数据类型，会将其他数据类型先自动转型为字符串，再连接：

java
int age = 25;
String s = "age is " + age; // age is 25

不可变特性 ​

Java的字符串除了是一个引用类型外，还有个重要特点，就是字符串不可变。

java
String s = "hello";
System.out.println(s); // 显示 hello
s = "world";
System.out.println(s); // 显示 world

观察执行结果，难道字符串s变了吗？其实变的不是字符串，而是变量s的“指向”。

空值null ​

引用类型的变量可以指向一个空值null，它表示不存在，即该变量不指向任何对象。例如：

java
String s1 = null; // s1是null
String s2 = s1; // s2也是null
String s3 = ""; // s3指向空字符串，不是null

特别注意：要区分空值null和空字符串""，空字符串是一个有效的字符串对象，它不等于null。

3.7 数组类型 ​

可以使用数组来表示 “一组” 类型相同的变量。

java
// before
int n1 = 68;
int n2 = 79;
int n3 = 91;

// after
int[] ns = new int[3];
ns[0] = 68;
ns[1] = 79;
ns[2] = 91;

// 在定义数组时直接指定初始化的元素，这样就不必写出数组大小，而是由编译器自动推算数组大小
int[] ns = new int[] { 68, 79, 91 };
// 简写
int[] ns = { 68, 79, 91 };

定义一个数组类型的变量，使用数组类型 “类型[]”，例如，int[]。和单个基本类型变量不同，数组变量初始化必须使用new int[5]表示创建一个可容纳5个int元素的数组。

Java的数组有几个特点：

  • 数组所有元素初始化为默认值，整型都是0，浮点型是0.0，布尔型是false；
  • 数组一旦创建后，大小就不可改变。
  • 数组是引用类型，具有不可变特性，改变的是 “指向”。

要访问数组中的某一个元素，需要使用索引。数组索引从0开始，例如，5个元素的数组，索引范围是0~4。数组是引用类型，在使用索引访问数组元素时，如果索引超出范围，运行时将报错。

可以修改数组中的某一个元素，使用赋值语句，例如，ns[1] = 79;。

可以用数组变量.length获取数组大小。

字符串数组 ​

如果数组元素不是基本类型，而是一个引用类型，那么，修改数组元素会有哪些不同？（修改的是 “指向”）

字符串是引用类型，因此我们定义一个字符串数组：

java
String[] names = { "ABC", "XYZ", "zoo" };

4. 流程控制 ​

在Java程序中，JVM默认总是顺序执行以分号;结束的语句。但是，在实际的代码中，程序经常需要做条件判断、循环，因此，需要有多种流程控制语句，来实现程序的跳转和循环等功能。

4.1 输入和输出 ​

输出、格式化输出、输入。

输出 ​

在前面的代码中，我们总是使用System.out.println()来向屏幕输出一些内容。

println是print line的缩写，表示输出并换行。因此，如果输出后不想换行，可以用print()。

格式化输出 ​

Java还提供了格式化输出的功能。为什么要格式化输出？因为计算机表示的数据不一定适合人来阅读：

java
double d = 12900000;
System.out.println(d); // 1.29E7

如果要把数据显示成我们期望的格式，就需要使用格式化输出的功能。格式化输出使用System.out.printf()，通过使用占位符%?，printf()可以把后面的参数格式化成指定格式：

java
double d = 3.1415926;
System.out.printf("%.2f\n", d); // 显示两位小数3.14
System.out.printf("%.4f\n", d); // 显示4位小数3.1416

Java的格式化功能提供了多种占位符，可以把各种数据类型“格式化”成指定的字符串：

占位符说明
%d格式化输出整数
%x格式化输出十六进制整数
%f格式化输出浮点数
%e格式化输出科学计数法表示的浮点数
%s格式化字符串

特别注意：由于%表示占位符，因此，连续两个%%表示一个%字符本身。

详细的格式化参数请参考JDK文档java.util.Formatter。

输入 ​

和输出相比，Java的输入就要复杂得多。

我们先看一个从控制台读取一个字符串和一个整数的例子：

java
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // 创建Scanner对象
        System.out.print("Input your name: "); // 打印提示
        String name = scanner.nextLine(); // 读取一行输入并获取字符串
        System.out.print("Input your age: "); // 打印提示
        int age = scanner.nextInt(); // 读取一行输入并获取整数
        System.out.printf("Hi, %s, you are %d\n", name, age); // 格式化输出
    }
}

4.2 if判断 ​

在Java程序中，如果要根据条件来决定是否执行某一段代码，就需要if语句。

if语句的基本语法是：

java
if (条件) {
    // 条件满足时执行
}

根据if条件的计算结果（true还是false），JVM决定是否执行if语句块（即花括号{}包含的所有语句）。

当if语句块只有一行语句时，可以省略花括号{}。但是，省略花括号并不总是一个好主意。

else ​

if语句还可以编写一个else { ... }，当条件判断为false时，将执行else的语句块。

特别注意：else不是必须的。

else if ​

还可以用多个if ... else if ...串联。在串联使用多个if时，要特别注意判断顺序。

原因是if语句从上到下执行时，前面某个条件判断成功后，后续else不再执行

判断引用类型相等 ​

在Java中，判断值类型的变量是否相等，可以使用==运算符。但是，判断引用类型的变量是否相等，==表示“引用是否相等”，或者说，是否指向同一个对象。例如，下面的两个String类型，它们的内容是相同的，但是，分别指向不同的对象，用==判断，结果为false：

java
String s1 = "hello";
String s2 = "HELLO".toLowerCase();
System.out.println(s1);
System.out.println(s2);
if (s1 == s2) {
	System.out.println("s1 == s2");
} else {
	System.out.println("s1 != s2"); // 输出结果为这条
}

要判断引用类型的变量内容是否相等，必须使用equals()方法。

特别注意：执行语句s1.equals(s2)时，如果变量s1为null，会报NullPointerException。

要避免NullPointerException错误，可以利用短路运算符&&。还可以把一定不是null的对象"hello"放到前面：例如：if ("hello".equals(s)) { ... }。

java
String s1 = null;
if (s1 != null && s1.equals("hello")) {
    System.out.println("hello");
}

4.3 switch多重选择 ​

除了if语句外，还有一种条件判断，是根据某个表达式的结果，分别去执行不同的分支。

switch语句根据switch (表达式)计算的结果，跳转到匹配的case结果，然后继续执行后续语句，直到遇到break结束执行。可以给switch语句加一个default，当没有匹配到任何case时，执行default。

java
int option = 1;
switch (option) {
case 1:
    System.out.println("Selected 1");
    break;
case 2:
    System.out.println("Selected 2");
    break;
case 3:
    System.out.println("Selected 3");
    break;
default:
    System.out.println("Not selected");
}

特别注意：case语句具有 “穿透性”，漏写break将导致意想不到的结果。

编译检查 ​

使用IDE时，可以自动检查是否漏写了break语句和default语句，方法是打开IDE的编译检查。当switch语句存在问题时，即可在IDE中获得警告提示。

switch表达式 ​

使用switch时，如果遗漏了break，就会造成严重的逻辑错误，而且不易在源代码中发现错误。从Java 12开始，switch语句升级为更简洁的表达式语法，使用类似模式匹配（Pattern Matching）的方法，保证只有一种路径会被执行，并且不需要break语句：

java
String fruit = "apple";
switch (fruit) {
    case "apple" -> System.out.println("Selected apple");
    case "pear" -> System.out.println("Selected pear");
    case "mango" -> {
        System.out.println("Selected mango");
        System.out.println("Good choice!");
    }
    default -> System.out.println("No fruit selected");
}

特别注意：新语法使用->，如果有多条语句，需要用{}括起来。不要写break语句，因为新语法只会执行匹配的语句，没有穿透效应。

yield ​

大多数时候，在switch表达式内部，我们会返回简单的值。

但是，如果需要复杂的语句，我们也可以写很多语句，放到{...}里，然后，用yield返回一个值作为switch语句的返回值：

java
String fruit = "orange";
int opt = switch (fruit) {
    case "apple" -> 1;
    case "pear", "mango" -> 2;
    default -> {
        int code = fruit.hashCode();
        yield code; // switch语句返回值
    }
};
System.out.println("opt = " + opt);

4.4 while循环 ​

循环语句就是让计算机根据条件做循环计算，在条件满足时继续循环，条件不满足时退出循环。

java
while (条件表达式) {
    循环语句
}
// 继续执行后续代码

while循环在每次循环开始前，首先判断条件是否成立。如果计算结果为true，就把循环体内的语句执行一遍，如果计算结果为false，那就直接跳到while循环的末尾，继续往下执行。

特别注意：while循环是先判断循环条件，再循环，因此，有可能一次循环都不做。

4.5 do while循环 ​

在Java中，while循环是先判断循环条件，再执行循环。而另一种do while循环则是先执行循环，再判断条件，条件满足时继续循环，条件不满足时退出。

java
do {
    执行循环语句
} while (条件表达式);

特别注意：do while循环会至少循环一次。

4.6 for循环 ​

除了while和do while循环，Java使用最广泛的是for循环。

for循环的功能非常强大，它使用计数器实现循环。for循环会先初始化计数器，然后，在每次循环前检测循环条件，在每次循环后更新计数器。计数器变量通常命名为i。

java
for (初始条件; 循环检测条件; 循环后更新计数器) {
    // 执行语句
}

for循环是可以缺少初始化语句、循环条件和每次循环更新语句，通常不推荐这样写。

for each循环 ​

for循环经常用来遍历数组，因为通过计数器可以根据索引来访问数组的每个元素。但是，很多时候，我们实际上真正想要访问的是数组每个元素的值。

java
int[] ns = { 1, 4, 9, 16, 25 };
for (int n : ns) {
	System.out.println(n);
}

特别注意：for each循环无法指定遍历顺序，也无法获取数组的索引。

除了数组外，for each循环能够遍历所有“可迭代”的数据类型，包括后面会介绍的List、Map等。

4.7 break和continue ​

无论是while循环还是for循环，有两个特别的语句可以使用，就是break语句和continue语句。

break ​

在循环过程中，可以使用break语句跳出当前循环。

java
int sum = 0;
for (int i=1; ; i++) {
    sum = sum + i;
    if (i == 100) {
    	break;
    }
}
System.out.println(sum);

break语句通常都是配合if语句使用。

特别注意：break语句总是跳出自己所在的那一层循环。

continue ​

break会跳出当前循环，也就是整个循环都不会执行了。而continue则是提前结束本次循环，直接继续执行下次循环。

java
int sum = 0;
for (int i=1; i<=10; i++) {
    System.out.println("begin i = " + i);
    if (i % 2 == 0) {
    	continue; // continue语句会结束本次循环
    }
    sum = sum + i;
    System.out.println("end i = " + i);
}
System.out.println(sum); // 25

特别注意：在多层嵌套的循环中，continue语句同样是结束本次自己所在的循环。

5. 数组操作 ​

5.1 遍历数组 ​

我们在Java程序基础里介绍了数组这种数据类型。有了数组，我们还需要来操作它。而数组最常见的一个操作就是遍历。

第一种方式是通过for循环就可以遍历数组。因为数组的每个元素都可以通过索引来访问，因此，使用标准的for循环可以完成一个数组的遍历。第二种方式是使用for each循环，直接迭代数组的每个元素。

打印数组内容 ​

直接打印数组变量，得到的是数组在JVM中的引用地址：

java
int[] ns = { 1, 1, 2, 3, 5, 8 };
System.out.println(ns); // 类似 [I@7852e922

我们希望打印的是数组元素内容。因此，使用for each循环来打印它：

java
int[] ns = { 1, 1, 2, 3, 5, 8 };
for (int n : ns) {
    System.out.print(n + ", ");
}

使用for each循环打印也很麻烦。幸好Java标准库提供了Arrays.toString()，可以快速打印数组内容：

java
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 1, 2, 3, 5, 8 };
        System.out.println(Arrays.toString(ns)); // [1, 1, 2, 3, 5, 8]
    }
}

5.2 数组排序 ​

对数组进行排序是程序中非常基本的需求。常用的排序算法有冒泡排序、插入排序和快速排序等。

我们来看一下如何使用冒泡排序算法对一个整型数组从小到大进行排序：

java
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
        // 排序前:
        System.out.println(Arrays.toString(ns));
        for (int i = 0; i < ns.length - 1; i++) {
            for (int j = 0; j < ns.length - i - 1; j++) {
                if (ns[j] > ns[j+1]) {
                    // 交换ns[j]和ns[j+1]:
                    int tmp = ns[j];
                    ns[j] = ns[j+1];
                    ns[j+1] = tmp;
                }
            }
        }
        // 排序后:
        System.out.println(Arrays.toString(ns));
    }
}

冒泡排序的特点是，每一轮循环后，最大的一个数被交换到末尾，因此，下一轮循环就可以“刨除”最后的数，每一轮循环都比上一轮循环的结束位置靠前一位。

实际上，Java的标准库已经内置了排序功能，我们只需要调用JDK提供的Arrays.sort()就可以排序：

java
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
        Arrays.sort(ns);
        System.out.println(Arrays.toString(ns));
    }
}

5.3 多维数组 ​

二维数组、三位数组。

二维数组 ​

二维数组就是数组的数组。定义一个二维数组如下：

java
int[][] ns = {
    { 1, 2, 3, 4 },
    { 5, 6, 7, 8 },
    { 9, 10, 11, 12 }
};

访问二维数组的某个元素需要使用array[row][col]。

要打印一个二维数组，可以使用两层嵌套的for循环：

java
for (int[] arr : ns) {
    for (int n : arr) {
        System.out.print(n);
        System.out.print(', ');
    }
    System.out.println();
}

或者使用Java标准库的Arrays.deepToString()：

Arrays.deepToString(ns);

三维数组 ​

三维数组就是二维数组的数组。可以这么定义一个三维数组：

java
int[][][] ns = {
    {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    },
    {
        {10, 11},
        {12, 13}
    },
    {
        {14, 15, 16},
        {17, 18}
    }
};

理论上，我们可以定义任意的N维数组。但在实际应用中，除了二维数组在某些时候还能用得上，更高维度的数组很少使用。

5.4 命令行参数 ​

Java程序的入口是main方法，而main方法可以接受一个命令行参数，它是一个String[]数组。

这个命令行参数由JVM接收用户输入并传给main方法：

java
public class Main {
    public static void main(String[] args) {
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}

我们可以利用接收到的命令行参数，根据不同的参数执行不同的代码（如何解析命令行参数需要由程序自己实现）。例如，实现一个-version参数，打印程序版本号：

java
public class Main {
    public static void main(String[] args) {
        for (String arg : args) {
            if ("-version".equals(arg)) {
                System.out.println("v 1.0");
                break;
            }
        }
    }
}
bash
$ javac Main.java
$ java Main -version
v 1.0