# Java 基础

原文：http://zetcode.com/lang/java/basics/

在 Java 教程的这一部分中，我们涵盖了 Java 语言的一些基本编程概念。 我们从一些简单的程序开始。 我们处理变量，常量和基本数据类型。 我们在控制台上进行读写，还提到了字符串格式。

## Java 简单示例

我们从一个非常简单的代码示例开始。 以下代码放置在`Simple.java`文件中。 这里的命名很重要。 Java 程序的公共类必须与文件名匹配。

`com/zetcode/Simple.java`

```java
package com.zetcode;

public class Simple {

    public static void main(String[] args) {

        System.out.println("This is Java");
    }
}

```

从一开始就严格组织 Java 代码。 Java 代码文件可以具有一个或多个类，其中只有一个可以声明为公共。

```java
package com.zetcode;

```

包用于将 Java 类组织成组，这些组通常共享相似的功能。 包类似于其他编程语言中的名称空间和模块。 对于简单的代码示例，可以省略包声明。 这将创建一个所谓的默认包。 但是，在本教程中，我们将为所有示例使用一个包。 另一个重要的事情是目录结构必须反映软件包名称。 在我们的情况下，带有包`com.zetcode`的源文件`Simple.java`必须放置在名为`com/zetcode/`的目录中。 `package`语句必须在源文件的第一行。

```java
public class Simple {

   ...
}

```

类是 Java 程序的基本构建块。 通过`public`关键字，可以不受限制地访问此类。 上面的代码是一个类定义。 该定义的主体以左大括号`{`开头，以右大括号`}`结尾。 在源文件中只能声明一个类`public`。 另请注意类的名称。 其名称必须与文件名匹配。 源文件称为`Simple.java`，类名为`Simple`。 按照惯例，类名以大写字母开头。

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

```

`main()`是一种方法。 方法是为执行特定工作而创建的一段代码。 我们没有将所有代码放在一个地方，而是将其分为称为方法的部分。 这为我们的应用带来了模块化。 每个方法都有一个放置语句的主体。 方法的主体用大括号括起来。 `main()`方法的特定工作是启动应用。 它是每个控制台 Java 程序的入口点。

该方法声明为`static`。 无需创建 Java 类的实例即可调用此静态方法。 首先，我们需要启动应用，然后我们可以创建类的实例。 `void`关键字指出该方法未返回值。 最后，`public`关键字使`main()`方法不受限制地可用于外部世界。 这些主题将在后面更详细地说明。

```java
System.out.println("This is Java");

```

在`main()`方法中，我们发表了一条声明。 该语句将“ This is Java”（这是字符串文字）打印到控制台。 每个语句必须以分号`;`字符结尾。 该语句是一个方法调用。 我们称为`System`类的`println()`方法。 该类表示控制台应用的标准输入，输出和错误流。 我们指定`println()`方法的标准名称。

```java
$ java Simple.java
This is Java

```

我们使用`java`工具执行该程序。

> **注意**：我们使用`java工具执行（单个）源文件。 Java 11 中添加了此功能。

## Java 控制台读取值

第二个示例将显示如何从控制台读取值。

`com/zetcode/ReadLine.java`

```java
package com.zetcode;

import java.util.Scanner;

public class ReadLine {

    public static void main(String[] args) {

        System.out.print("Write your name:");

        Scanner sc = new Scanner(System.in);
        String name = sc.nextLine();

        System.out.println("Hello " + name);
    }
}

```

终端窗口上会显示一个提示。 用户将其姓名写在终端上，然后读取该值并将其打印回终端。

```java
import java.util.Scanner;

```

Java 标准库具有供程序员使用的大量类。 它们被组织在包中。 `Scanner`类是其中之一。 当我们使用`import`关键字导入一个类时，我们可以稍后在没有完整包名称的情况下引用该类。 否则，我们必须使用标准名称。 `import`允许快捷引用类。 这与某些其他语言不同。 例如在 Python 中，`import`关键字将对象导入脚本的名称空间。 在 Java 中，`import`关键字仅通过允许引用类型而不指定全名来保存类型。

```java
System.out.print("Write your name:");

```

我们向用户打印一条消息。 我们使用`print()`方法不会开始新行。 然后，用户在消息旁边键入他的响应。

```java
Scanner sc = new Scanner(System.in);

```

将创建`Scanner`类的新实例。 使用`new`关键字创建新对象。 对象的构造器使用`new`关键字。 我们将一个参数添加到`Scanner`对象的构造器中。 它是标准输入流。 这样我们就可以从终端上阅读了。 `Scanner`是一个简单的文本扫描器，可以解析原始类型和字符串。

```java
String name = sc.nextLine();

```

对象具有执行某些任务的方法。 `nextLine()`方法从终端读取下一行。 它以`String`数据类型返回结果。 返回的值存储在我们声明为`String`类型的名称变量中。

```java
System.out.println("Hello " + name);

```

我们将消息打印到终端。 该消息由两部分组成。 “ Hello”字符串和名称变量。 我们使用`+`运算符将这两个值连接为一个字符串。 该运算符可以连接两个或多个字符串。

```java
$ java ReadLine.java
Write your name:Jan Bodnar
Hello Jan Bodnar

```

这是第二个程序的示例执行。

## Java 命令行参数

Java 程序可以接收命令行参数。 当我们运行程序时，它们会遵循程序的名称。

`com/zetcode/CommandLineArgs.java`

```java
package com.zetcode;

public class CommandLineArgs {

    public static void main(String[] args) {

        for (String arg : args) {

            System.out.println(arg);
        }
    }
}

```

命令行参数可以传递给`main()`方法。

```java
public static void main(String[] args)

```

`main()`方法接收命令行参数的字符串数组。 数组是数据的集合。 数组由类型声明，后跟一对方括号`[]`。 因此`String[] args`构造声明了一个字符串数组。 `args`是`main()`方法的参数。 然后该方法可以使用传递给它的参数。

```java
for (String arg : args) {

    System.out.println(arg);
}

```

我们使用`for`循环遍历这些参数的数组，并将它们打印到控制台。 `for`循环由循环组成。 在这种情况下，循环数等于数组中的参数数。 在每个循环中，新元素将从`args`数组传递到`arg`变量。 传递数组的所有元素后，循环结束。 `for`语句的主体由大括号`{}`包围。 在此主体中，我们放置了要在每个循环中执行的语句。 在我们的例子中，我们仅将`arg`变量的值打印到终端。 循环和数组将在后面更详细地描述。

```java
$ java CommandLineArgs.java 1 2 3 4 5
1
2
3
4
5

```

我们提供四个数字作为命令行参数，这些数字将打印到控制台。

当从命令行启动程序时，我们在程序名称后立即指定参数。 在诸如 IntelliJ IDEA 的集成开发环境（IDE）中，我们在对话框中指定这些参数。 在 IntelliJ IDEA 中，我们选择“编辑配置”，然后将值添加到“程序参数”选项中。

## Java 变量

变量是存储数据的地方。 变量具有名称和数据类型。 数据类型确定可以为变量分配哪些值。 整数，字符串，布尔值等。在程序运行过程中，变量可以获得相同数据类型的各种值。 在对变量进行任何引用之前，总是将 Java 中的变量初始化为其类型的默认值。

`com/zetcode/Variables.java`

```java
package com.zetcode;

public class Variables {

    public static void main(String[] args) {

        String city = "New York";
        String name = "Paul"; int age = 34;
        String nationality = "American";

        System.out.println(city);
        System.out.println(name);
        System.out.println(age);
        System.out.println(nationality);

        city = "London";
        System.out.println(city);
    }
}

```

在上面的示例中，我们使用四个变量。 其中三个变量是字符串。 `age`变量是整数。 `int`关键字用于声明整数变量。

```java
String city = "New York";

```

我们声明一个字符串类型的`city`变量，并将其初始化为`"New York"`值。

```java
String name = "Paul"; int age = 34;

```

我们声明并初始化两个变量。 我们可以将两个语句放在一行中。 由于每个语句都以分号结尾，因此 Java 编译器知道一行中有两个语句。 但是出于可读性原因，每个语句应放在单独的行上。

```java
System.out.println(city);
System.out.println(name);
System.out.println(age);
System.out.println(nationality);

```

我们将变量的值打印到终端。

```java
city = "London";
System.out.println(city);

```

我们为城市变量分配一个新值，然后打印。

```java
$ java Variables.java
New York
Paul
34
American
London

```

这是示例的输出。

## `var`关键字

由于 Java 10 用于带有初始化程序的局部变量，因此我们可以使用`var`关键字代替数据类型。 数据类型将从声明的右侧推断出来。

`com/zetcode/VarKeyword.java`

```java
package com.zetcode;

public class VarKeyword {

    public static void main(String[] args) {

        var name = "John Doe";
        var age = 34;

        System.out.println(name + " is " + age  + " years old");
    }
}

```

在示例中，我们将`var`关键字用于两个变量。

```java
var name = "John Doe";
var age = 34;

```

我们有一个字符串变量和一个整数变量。 编译器从声明的右侧推断出数据类型。 为了使推断起作用，必须初始化变量。

## Java 常量

与变量不同，常量不能更改其初始值。 一旦初始化，便无法修改。 使用`final`关键字创建常量。

`com/zetcode/Constants.java`

```java
package com.zetcode;

public class Constants {

    public static void main(String[] args) {

        final int WIDTH = 100;
        final int HEIGHT = 150;
        int var = 40;

        var = 50;

        //WIDTH = 110;
    }
}

```

在此示例中，我们声明两个常量和一个变量。

```java
final int WIDTH = 100;
final int HEIGHT = 150;

```

我们使用`final`关键字通知编译器我们声明了一个常量。 按照惯例，用大写字母写常量。

```java
int var = 40;

var = 50;

```

我们声明并初始化一个变量。 稍后，我们为变量分配一个新值。 是合法的

```java
// WIDTH = 110;

```

无法为常数分配新值。 如果我们取消注释此行，则会出现编译错误：“不可编译的源代码-无法将值分配给最终变量 WIDTH”。

## Java 字符串格式

从变量构建字符串是编程中非常常见的任务。 Java 语言具有`String.format()`方法来格式化字符串。

一些动态语言（如 Perl，PHP 或 Ruby）支持变量插值。 变量插值正在用字符串文字中的值替换变量。 Java 语言不允许这样做。 它具有字符串格式。

`com/zetcode/StringFormatting.java`

```java
package com.zetcode;

public class StringFormatting {

    public static void main(String[] args) {

        int age = 34;
        String name = "William";

        String output = String.format("%s is %d years old.", name, age);

        System.out.println(output);
    }
}

```

在 Java 中，字符串是不可变的。 我们无法修改现有字符串。 我们必须从现有字符串和其他类型创建一个新字符串。 在代码示例中，我们创建一个新字符串。 我们还使用来自两个变量的值。

```java
int age = 34;
String name = "William";

```

这里我们有两个变量，一个整数和一个字符串。

```java
String output = String.format("%s is %d years old.", name, age);

```

我们使用内置`String`类的`format()`方法。 `%s`和`%d`是控制字符，稍后进行求值。 `%s`接受字符串值，`%d`整数值。

```java
$ java StringFormatting.java
William is 34 years old.

```

This is the output of the example.

本章介绍了 Java 语言的一些基础知识。