Java - 快速指南

---

Java - 概述

Java 编程语言最初由 Sun Microsystems 开发，由 James Gosling 发起，并于 1995 年作为 Sun Microsystems Java 平台的核心组件发布（Java 1.0 [J2SE]）。

Java 标准版的最新版本是 Java SE 8。随着 Java 的进步及其广泛流行，构建了多种配置以适应各种类型的平台。例如：用于企业应用程序的 J2EE、用于移动应用程序的 J2ME。

新的 J2 版本分别更名为 Java SE、Java EE 和 Java ME。Java 保证“一次编写，随处运行”。

Java 是 -

• 面向对象- 在 Java 中，一切都是对象。Java 可以很容易地扩展，因为它基于对象模型。

• 平台无关- 与包括 C 和 C++ 在内的许多其他编程语言不同，Java 编译时，它不会编译为平台特定的机器，而是编译为平台无关的字节代码。该字节代码分布在网络上，并由运行它的任何平台上的虚拟机 (JVM) 进行解释。

• 简单- Java 被设计为易于学习。如果你了解Java OOP的基本概念，那么掌握起来就会很容易。

• 安全- 借助 Java 的安全功能，可以开发无病毒、防篡改的系统。身份验证技术基于公钥加密。

• 体系结构中立- Java 编译器生成体系结构中立的目标文件格式，这使得编译后的代码在存在 Java 运行时系统的情况下在许多处理器上可执行。

• 可移植- 架构中立并且规范中没有依赖于实现的方面使得 Java 具有可移植性。Java 中的编译器是用 ANSI C 编写的，具有干净的可移植性边界，它是 POSIX 子集。

• 健壮- Java 通过主要强调编译时错误检查和运行时检查来努力消除容易出错的情况。

• 多线程- 利用 Java 的多线程功能，可以编写可以同时执行多个任务的程序。这种设计功能允许开发人员构建可以流畅运行的交互式应用程序。

• 解释型- Java 字节代码即时翻译为本机机器指令，并且不存储在任何地方。由于链接是一个增量且轻量级的过程，因此开发过程更加快速且更具分析性。

• 高性能- 通过使用即时编译器，Java 可实现高性能。

• 分布式- Java 是为互联网的分布式环境而设计的。

• 动态- Java 被认为比 C 或 C++ 更具动态性，因为它旨在适应不断发展的环境。Java 程序可以携带大量的运行时信息，这些信息可用于验证和解析运行时对对象的访问。

使用 Java 编程的 Hello World。

为了让您对 Java 编程有一点兴奋，我将为您提供一个小型的传统 C 编程 Hello World 程序，您可以使用演示链接尝试一下。

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    */

   public static void main(String []args) {
      System.out.println("Hello World"); // prints Hello World
   }
}

爪哇的历史

James Gosling 于 1991 年 6 月启动了 Java 语言项目，用于他的众多机顶盒项目之一。这种语言最初被称为“Oak”，以高斯林办公室外的一棵橡树命名，后来也被称为“Green”，后来从一个随机单词列表中更名为“Java”。

Sun于1995年发布了第一个公共实现Java 1.0。它承诺一次编写，随处运行（WORA），在流行平台上提供免费的运行时。

2006 年 11 月 13 日，Sun 根据 GNU 通用公共许可证 (GPL) 的条款将大部分 Java 作为免费开源软件发布。

2007年5月8日，Sun完成了这一过程，除了Sun不拥有版权的一小部分代码之外，所有Java核心代码都是免费和开源的。

您需要的工具

为了执行本教程中讨论的示例，您需要一台 Pentium 200 MHz 计算机，至少具有 64 MB RAM（建议使用 128 MB RAM）。

您还需要以下软件 -

• Linux 7.1 或 Windows xp/7/8 操作系统
• Java JDK 8
• Microsoft 记事本或任何其他文本编辑器

本教程将提供使用 Java 创建 GUI、网络和 Web 应用程序所需的技能。

下一步是什么？

下一章将指导您如何获取 Java 及其文档。最后，指导您如何安装Java并准备开发Java应用程序的环境。

Java - 环境设置

在线现场演示选项

我们已经在线设置了Java编程环境，以便您可以在线编译和执行所有可用的示例。它使您对所阅读的内容充满信心，并使您能够使用不同的选项验证程序。请随意修改任何示例并在线执行。

使用以下示例代码框右上角的“实时演示”选项尝试以下示例 -

public class MyFirstJavaProgram {
   public static void main(String []args) {
      System.out.println("Hello World");
   }
}

对于本教程中给出的大多数示例，您将在我们网站右上角的代码部分中找到“试用”选项，该选项将带您进入在线编译器。因此，请充分利用它并享受学习的乐趣。

本地环境设置

如果您想设置自己的 Java 编程语言环境，那么本节将指导您完成整个过程。请按照以下步骤设置您的 Java 环境。

Java SE 可供免费下载。要下载，请单击此处，请下载与您的操作系统兼容的版本。

按照说明下载 Java，然后运行​​.exe以在您的计算机上安装 Java。在计算机上安装 Java 后，您需要设置环境变量以指向正确的安装目录。

设置 Windows 2000/XP 的路径

假设您已将 Java 安装在 c:\Program Files\java\jdk 目录中 -

• 右键单击“我的电脑”并选择“属性”。

• 单击“高级”选项卡下的“环境变量”按钮。

• 现在，编辑“Path”变量并在其末尾添加 Java 可执行文件目录的路径。例如，如果路径当前设置为C:\Windows\System32，则按以下方式编辑它

  C:\Windows\System32;c:\Program Files\java\jdk\bin。

设置Windows 95/98/ME的路径

假设您已将 Java 安装在 c:\Program Files\java\jdk 目录中 -

• 编辑“C:\autoexec.bat”文件并在末尾添加以下行 -

  设置路径=%PATH%;C:\Program Files\java\jdk\bin

设置 Linux、UNIX、Solaris、FreeBSD 的路径

应将环境变量 PATH 设置为指向 Java 二进制文件的安装位置。如果您在执行此操作时遇到问题，请参阅您的 shell 文档。

例如，如果您使用 bash 作为 shell，那么您可以在.bashrc末尾添加以下行-

导出 PATH=/path/to/java:$PATH'

流行的 Java 编辑器

要编写 Java 程序，您需要一个文本编辑器。市场上还有更复杂的 IDE。最流行的简要描述如下 -

• 记事本- 在 Windows 计算机上，您可以使用任何简单的文本编辑器，例如记事本（本教程推荐）或写字板。Notepad++ 也是一个免费的文本编辑器，增强了功能。

• Netbeans - 它是一个开源且免费的 Java IDE，可以从www.netbeans.org/index.html下载。

• Eclipse - 它也是由 Eclipse 开源社区开发的 Java IDE，可以从www.eclipse.org下载。

IDE或集成开发环境，提供所有常见的工具和设施来帮助编程，例如源代码编辑器、构建工具和调试器等。

下一步是什么？

下一章将教您如何编写和运行您的第一个 Java 程序以及开发应用程序所需的一些重要的 Java 基本语法。

Java - 基本语法

当我们考虑 Java 程序时，它可以被定义为通过调用彼此的方法进行通信的对象的集合。现在让我们简单地了解一下类、对象、方法和实例变量的含义。

• 对象- 对象具有状态和Behave。示例：狗有状态 - 颜色、名称、品种以及摇尾巴、吠叫、进食等Behave。对象是类的实例。

• 类- 类可以定义为模板/蓝图，描述其类型的对象支持的Behave/状态。

• 方法- 方法基本上是一种Behave。一个类可以包含许多方法。在方法中编写逻辑、操作数据并执行所有操作。

• 实例变量- 每个对象都有其唯一的实例变量集。对象的状态是由分配给这些实例变量的值创建的。

第一个 Java 程序

让我们看一个简单的代码，它将打印Hello World一词。

例子

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    */

   public static void main(String []args) {
      System.out.println("Hello World"); // prints Hello World
   }
}

让我们看看如何保存文件、编译和运行程序。请按照以下步骤操作 -

• 打开记事本并添加如上代码。

• 将文件另存为：MyFirstJavaProgram.java。

• 打开命令提示符窗口并转到保存类的目录。假设它是 C:\。

• 输入“javac MyFirstJavaProgram.java”并按 Enter 编译代码。如果代码中没有错误，命令提示符将带您进入下一行（假设：路径变量已设置）。

• 现在，输入“java MyFirstJavaProgram”来运行您的程序。

• 您将能够看到窗口上印有“Hello World”。

输出

C:\> javac MyFirstJavaProgram.java
C:\> java MyFirstJavaProgram 
Hello World

基本语法

关于Java程序，记住以下几点非常重要。

• 区分大小写- Java 区分大小写，这意味着标识符Hello和hello在 Java 中具有不同的含义。

• 类名称- 对于所有类名称，第一个字母应为大写。如果使用多个单词来构成类的名称，则每个内部单词的第一个字母应大写。

  示例： MyFirstJavaClass 类

• 方法名称- 所有方法名称均应以小写字母开头。如果使用多个单词来构成方法名称，则每个内部单词的第一个字母应大写。

  示例： public void myMethodName()

• 程序文件名- 程序文件的名称应与类名称完全匹配。

  保存文件时，您应该使用类名保存它（记住Java区分大小写）并在名称末尾附加“.java”（如果文件名和类名不匹配，您的程序将无法编译）。

  但请注意，如果文件中没有公共类，则文件名可能与类名不同。文件中也没有强制包含公共类。

  示例：假设“MyFirstJavaProgram”是类名。然后该文件应保存为“MyFirstJavaProgram.java”

• public static void main(String args[]) - Java 程序处理从 main() 方法开始，这是每个 Java 程序的强制部分。

Java 标识符

所有 Java 组件都需要名称。用于类、变量和方法的名称称为标识符。

在 Java 中，关于标识符有几点需要记住。它们如下 -

• 所有标识符均应以字母（A 到 Z 或 a 到 z）、货币字符 ($) 或下划线 (_) 开头。

• 在第一个字符之后，标识符可以包含任意字符组合。

• 关键字不能用作标识符。

• 最重要的是，标识符区分大小写。

• 合法标识符的示例：age、$salary、_value、__1_value。

• 非法标识符示例：123abc、-salary。

Java修饰符

与其他语言一样，可以使用修饰符来修改类、方法等。有两类修饰符 -

• 访问修饰符- 默认、公共、受保护、私有

• 非访问修饰符- Final、abstract、strictfp

我们将在下一节中研究有关修饰符的更多详细信息。

Java变量

以下是 Java 中变量的类型 -

• 局部变量
• 类变量（静态变量）
• 实例变量（非静态变量）

Java 数组

数组是存储多个相同类型变量的对象。然而，数组本身是堆上的一个对象。我们将在接下来的章节中研究如何声明、构造和初始化。

Java 枚举

枚举是在 Java 5.0 中引入的。枚举将变量限制为仅具有几个预定义值之一。该枚举列表中的值称为枚举。

使用枚举可以减少代码中的错误数量。

例如，如果我们考虑鲜榨果汁店的应用，则可以将玻璃杯尺寸限制为小、中和大。这将确保任何人都不会订购除小号、中号或大号以外的任何尺寸。

例子

class FreshJuice {
   enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
   FreshJuiceSize size;
}

public class FreshJuiceTest {

   public static void main(String args[]) {
      FreshJuice juice = new FreshJuice();
      juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
      System.out.println("Size: " + juice.size);
   }
}

输出

Size: MEDIUM

注意- 枚举可以声明为自己的枚举或在类中声明。方法、变量、构造函数也可以在枚举内部定义。

Java关键字

下面的列表显示了 Java 中的保留字。这些保留字不得用作常量、变量或任何其他标识符名称。

Java 中的注释

Java 支持单行和多行注释，与 C 和 C++ 非常相似。Java 编译器将忽略任何注释中可用的所有字符。

例子

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */

   public static void main(String []args) {
      // This is an example of single line comment
      /* This is also an example of single line comment. */
      System.out.println("Hello World");
   }
}

输出

Hello World

使用空行

仅包含空格（可能带有注释）的行称为空行，Java 完全忽略它。

遗产

在Java中，类可以从类派生。基本上，如果您需要创建一个新类，并且这里已经是一个包含您需要的一些代码的类，那么可以从现有代码派生您的新类。

这个概念允许您重用现有类的字段和方法，而不必在新类中重写代码。在这种情况下，现有类称为超类，派生类称为子类。

接口

在Java语言中，接口可以定义为对象之间关于如何相互通信的契约。当谈到继承的概念时，接口起着至关重要的作用。

接口定义了派生类（子类）应使用的方法。但方法的实现完全取决于子类。

下一步是什么？

下一节将解释 Java 编程中的对象和类。课程结束时，您将能够清楚地了解 Java 中什么是对象、什么是类。

Java - 变量类型

变量为我们提供了程序可以操作的命名存储。Java中的每个变量都有一个特定的类型，它决定了变量内存的大小和布局；该内存中可以存储的值的范围；以及可以应用于变量的操作集。

您必须先声明所有变量，然后才能使用它们。以下是变量声明的基本形式 -

data type variable [ = value][, variable [ = value] ...] ;

这里的数据类型是Java的数据类型之一，变量是变量的名称。要声明多个指定类型的变量，可以使用逗号分隔的列表。

以下是 Java 中变量声明和初始化的有效示例 -

例子

int a, b, c;         // Declares three ints, a, b, and c.
int a = 10, b = 10;  // Example of initialization
byte B = 22;         // initializes a byte type variable B.
double pi = 3.14159; // declares and assigns a value of PI.
char a = 'a';        // the char variable a iis initialized with value 'a'

本章将解释 Java 语言中可用的各种变量类型。Java 中有三种变量 -

• 局部变量
• 实例变量
• 类/静态变量

局部变量

• 局部变量在方法、构造函数或块中声明。

• 局部变量在进入方法、构造函数或块时创建，一旦退出方法、构造函数或块，变量将被销毁。

• 访问修饰符不能用于局部变量。

• 局部变量仅在声明的方法、构造函数或块中可见。

• 局部变量在内部堆栈级别实现。

• 局部变量没有默认值，因此应在首次使用前声明局部变量并为其赋予初始值。

例子

这里，年龄是一个局部变量。这是在pupAge()方法内部定义的，其范围仅限于该方法。

public class Test {
   public void pupAge() {
      int age = 0;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

输出

Puppy age is: 7

例子

下面的例子使用了age，但没有初始化它，所以在编译时会报错。

public class Test {
   public void pupAge() {
      int age;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

输出

Test.java:4:variable number might not have been initialized
age = age + 7;
         ^
1 error

实例变量

• 实例变量在类中声明，但在方法、构造函数或任何块之外。

• 当在堆中为对象分配空间时，将为每个实例变量值创建一个槽。

• 实例变量在使用关键字“new”创建对象时创建，并在对象销毁时销毁。

• 实例变量保存的值必须由多个方法、构造函数或块引用，或者必须存在于整个类中的对象状态的基本部分。

• 实例变量可以在使用之前或之后在类级别声明。

• 可以为实例变量指定访问修饰符。

• 实例变量对于类中的所有方法、构造函数和块都是可见的。通常，建议将这些变量设为私有（访问级别）。但是，可以使用访问修饰符为这些变量提供子类的可见性。

• 实例变量有默认值。对于数字，默认值为 0，对于布尔值，默认值为 false，对于对象引用，默认值为 null。可以在声明期间或构造函数内赋值。

• 实例变量可以通过调用类内部的变量名直接访问。但是，在静态方法中（当实例变量被赋予可访问性时），应使用完全限定名称来调用它们。对象引用.变量名称。

例子

import java.io.*;

public class Employee {

   // this instance variable is visible for any child class.
   public String name;

   // salary  variable is visible in Employee class only.
   private double salary;

   // The name variable is assigned in the constructor.
   public Employee (String empName) {
      name = empName;
   }

   // The salary variable is assigned a value.
   public void setSalary(double empSal) {
      salary = empSal;
   }

   // This method prints the employee details.
   public void printEmp() {
      System.out.println("name  : " + name );
      System.out.println("salary :" + salary);
   }

   public static void main(String args[]) {
      Employee empOne = new Employee("Ransika");
      empOne.setSalary(1000);
      empOne.printEmp();
   }
}

输出

name  : Ransika
salary :1000.0

类/静态变量

• 类变量也称为静态变量，在类中使用 static 关键字声明，但在方法、构造函数或块之外。

• 每个类的每个类变量只有一个副本，无论从它创建了多少个对象。

• 除了声明为常量之外，静态变量很少使用。常量是声明为公共/私有、最终和静态的变量。常量变量永远不会改变其初始值。

• 静态变量存储在静态内存中。除了声明为final 并用作公共或私有常量之外，很少使用静态变量。

• 静态变量在程序启动时创建，在程序停止时销毁。

• 可见性与实例变量类似。然而，大多数静态变量都被声明为公共的，因为它们必须可供类的用户使用。

• 默认值与实例变量相同。对于数字，默认值为 0；对于布尔值来说，它是 false；对于对象引用，它为空。可以在声明期间或构造函数内赋值。此外，可以在特殊的静态初始化块中分配值。

• 可以通过使用类名ClassName.VariableName调用来访问静态变量。

• 当将类变量声明为 public static final 时，变量名（常量）全部为大写。如果静态变量不是public和final，则命名语法与实例变量和局部变量相同。

例子

import java.io.*;

public class Employee {

   // salary  variable is a private static variable
   private static double salary;

   // DEPARTMENT is a constant
   public static final String DEPARTMENT = "Development ";

   public static void main(String args[]) {
      salary = 1000;
      System.out.println(DEPARTMENT + "average salary:" + salary);
   }
}

输出

Development average salary:1000

注意- 如果从外部类访问变量，则应将常量作为 Employee.DEPARTMENT 访问

下一步是什么？

您已经在本章中使用了访问修饰符（公共和私有）。下一章将详细解释访问修饰符和非访问修饰符。

Java - 基本数据类型

变量只不过是用于存储值的保留内存位置。这意味着当您创建变量时，您会在内存中保留一些空间。

根据变量的数据类型，操作系统分配内存并决定保留内存中可以存储的内容。因此，通过为变量分配不同的数据类型，您可以在这些变量中存储整数、小数或字符。

Java 中有两种可用的数据类型 -

• 原始数据类型
• 引用/对象数据类型

原始数据类型

Java 支持八种基本数据类型。原始数据类型由语言预定义并由关键字命名。现在让我们详细研究八种基本数据类型。

字节

• 字节数据类型是一个 8 位有符号二进制补码整数

• 最小值为-128 (-2^7)

• 最大值为 127（含）(2^7 -1)

• 默认值为 0

• 字节数据类型用于节省大型数组中的空间，主要是代替整数，因为字节比整数小四倍。

• 示例 - 字节 a = 100，字节 b = -50

短的

• 短数据类型是 16 位有符号二进制补码整数

• 最小值为 -32,768 (-2^15)

• 最大值为 32,767（含）（2^15 -1）

• 短数据类型也可以用作字节数据类型来节省内存。短整型比整数小 2 倍

• 默认值为 0。

• 示例 - 短 s = 10000，短 r = -20000

整数

• Int 数据类型是 32 位有符号二进制补码整数。

• 最小值为 - 2,147,483,648 (-2^31)

• 最大值为 2,147,483,647（含） (2^31 -1)

• 除非担心内存问题，否则整数通常用作整数值的默认数据类型。

• 默认值为 0

• 示例 - int a = 100000，int b = -200000

长的

• Long 数据类型是 64 位有符号二进制补码整数
• 最小值为-9,223,372,036,854,775,808(-2^63)
• 最大值为 9,223,372,036,854,775,807（含）(2^63 -1)
• 当需要比 int 更宽的范围时使用此类型
• 默认值为 0L
• 示例 - 长 a = 100000L，长 b = -200000L

漂浮

• Float 数据类型是单精度 32 位 IEEE 754 浮点

• Float主要用于在大型浮点数数组中节省内存

• 默认值为 0.0f

• 浮点数据类型从不用于精确值，例如货币

• 示例 - 浮点 f1 = 234.5f

双倍的

• double 数据类型是双精度 64 位 IEEE 754 浮点

• 该数据类型一般作为十进制值的默认数据类型，一般默认选择

• 双精度数据类型切勿用于精确值，例如货币

• 默认值为 0.0d

• 示例 - 双 d1 = 123.4

布尔值

• 布尔数据类型表示一位信息

• 只有两个可能的值：true 和 false

• 此数据类型用于跟踪真/假条件的简单标志

• 默认值为 false

• 示例 - 布尔值 1 = true

字符

• char 数据类型是单个 16 位 Unicode 字符

• 最小值为“\u0000”（或 0）

• 最大值为 '\uffff'（或 65,535（含））

• Char数据类型用于存储任意字符

• 示例 - 字符 letterA = 'A'

例子

以下示例显示了我们上面讨论的各种原始数据类型的用法。我们对数字数据类型使用了添加操作，而布尔和字符变量则按此方式打印。

public class JavaTester {
   public static void main(String args[]) {

      byte byteValue1 = 2;
      byte byteValue2 = 4;
      byte byteResult = (byte)(byteValue1 + byteValue2);

      System.out.println("Byte: " + byteResult);

      short shortValue1 = 2;
      short shortValue2 = 4;
      short shortResult = (short)(shortValue1 + shortValue2);

      System.out.println("Short: " + shortResult);

      int intValue1 = 2;
      int intValue2 = 4;
      int intResult = intValue1 + intValue2;

      System.out.println("Int: " + intResult);

      long longValue1 = 2L;
      long longValue2 = 4L;
      long longResult = longValue1 + longValue2;

      System.out.println("Long: " + longResult);

      float floatValue1 = 2.0f;
      float floatValue2 = 4.0f;
      float floatResult = floatValue1 + floatValue2;

      System.out.println("Float: " + floatResult);

      double doubleValue1 = 2.0;
      double doubleValue2 = 4.0;
      double doubleResult = doubleValue1 + doubleValue2;

      System.out.println("Double: " + doubleResult);

      boolean booleanValue = true;

      System.out.println("Boolean: " + booleanValue);

      char charValue = 'A';

      System.out.println("Char: " + charValue);     
   }
}

输出

Byte: 6
Short: 6
Int: 6
Long: 6
Float: 6.0
Double: 6.0
Boolean: true
Char: A

参考数据类型

• 引用变量是使用类的定义构造函数创建的。它们用于访问对象。这些变量被声明为无法更改的特定类型。例如，员工、小狗等。

• 类对象和各种类型的数组变量属于引用数据类型。

• 任何引用变量的默认值为 null。

• 引用变量可用于引用声明类型或任何兼容类型的任何对象。

• 示例：动物 Animal = new Animal("giraffe");

Java 文字

文字是固定值的源代码表示。它们直接在代码中表示，无需任何计算。

文字可以分配给任何基本类型变量。例如 -

byte a = 68;
char a = 'A';

byte、int、long 和 Short 也可以用十进制（基数 10）、十六进制（基数 16）或八进制（基数 8）数字系统表示。

当使用这些数字系统作为文字时，前缀 0 用于指示八进制，前缀 0x 指示十六进制。例如 -

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

Java 中的字符串文字与大多数其他语言一样，通过将字符序列括在一对双引号之间来指定。字符串文字的示例是 -

例子

"Hello World"
"two\nlines"
"\"This is in quotes\""

String 和 char 类型的文字可以包含任何 Unicode 字符。例如 -

char a = '\u0001';
String a = "\u0001";

例子

以下示例显示了我们上面讨论的各种文字的用法。

public class JavaTester {
   public static void main(String args[]) {

      int decimal = 100;
      int octal = 0144;
      int hexa =  0x64;

      System.out.println(decimal);
      System.out.println(octal);
      System.out.println(hexa);

      String msg1 = "Hello World";
      String msg2 = "two\nlines";
      String msg3 = "\"This is in quotes\"";

      System.out.println(msg1);
      System.out.println(msg2);
      System.out.println(msg3);

      char a = '\u0064';
      String msg4 = "\u0064";

      System.out.println(a);
      System.out.println(msg4);   
   }
}

输出

100
100
100
Hello World
two
lines
"This is in quotes"
d
d

Java 语言还支持 String 和 char 文字的一些特殊转义序列。他们是 -

下一步是什么？

本章解释了各种数据类型。下一个主题解释不同的变量类型及其用法。这将使您更好地理解如何在 Java 类、接口等中使用它们。

Java - 基本运算符

Java 提供了一组丰富的运算符来操作变量。我们可以将所有 Java 运算符分为以下几组 -

• 算术运算符
• 关系运算符
• 按位运算符
• 逻辑运算符
• 赋值运算符
• 杂项运算符

算术运算符

算术运算符在数学表达式中的使用方式与在代数中的使用方式相同。下表列出了算术运算符 -

假设整数变量 A 为 10，变量 B 为 20，则 -

显示示例

关系运算符

Java 语言支持以下关系运算符。

假设变量 A 为 10，变量 B 为 20，则 -

显示示例

按位运算符

Java 定义了几个位运算符，可应用于整数类型：long、int、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，则 -

显示示例

逻辑运算符

下表列出了逻辑运算符 -

假设布尔变量 A 为 true，变量 B 为 false，则 -

显示示例

赋值运算符

以下是 Java 语言支持的赋值运算符 -

显示示例

杂项运算符

Java 语言支持的其他运算符很少。

条件运算符 (?:)

条件运算符也称为三元运算符。该运算符由三个操作数组成，用于计算布尔表达式。运算符的目标是决定应将哪个值分配给变量。运算符写为 -

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

以下是一个例子 -

例子

在此示例中，我们创建两个变量 a 和 b，并使用三元运算符确定 b 的值并将其打印出来。

public class Test {

   public static void main(String args[]) {
      int a, b;
      a = 10;
      b = (a == 1) ? 20: 30;
      System.out.println( "Value of b is : " +  b );

      b = (a == 10) ? 20: 30;
      System.out.println( "Value of b is : " + b );
   }
}

输出

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

实例操作符

该运算符仅用于对象引用变量。该运算符检查对象是否属于特定类型（类类型或接口类型）。instanceof 运算符写为 -

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

如果运算符左侧的变量引用的对象通过了右侧类/接口类型的 IS-A 检查，则结果将为 true。以下是一个例子 -

例子

在此示例中，我们创建一个 String 变量名称，然后使用instanceof 运算符检查该名称是否为 String 。

public class Test {

   public static void main(String args[]) {

      String name = "James";

      // following will return true since name is type of String
      boolean result = name instanceof String;
      System.out.println( result );
   }
}

输出

true

如果正在比较的对象是与右侧类型兼容的赋值，则该运算符仍将返回 true。以下是另一个例子 -

例子

在此示例中，我们创建了Vehicle 类的变量a ，然后使用instanceof 运算符检查名称是否属于 Car 类型。

class Vehicle {}

public class Car extends Vehicle {

   public static void main(String args[]) {

      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result );
   }
}

输出

true

Java 运算符的优先级

运算符优先级决定表达式中术语的分组。这会影响表达式的计算方式。某些运算符的优先级高于其他运算符；例如，乘法运算符的优先级高于加法运算符 -

例如，x = 7 + 3 * 2；这里 x 被分配为 13，而不是 20，因为运算符 * 的优先级高于 +，因此它首先乘以 3 * 2，然后添加到 7。

在这里，优先级最高的运算符出现在表的顶部，优先级最低的运算符出现在底部。在表达式中，将首先计算优先级较高的运算符。