7.java基础知识

注释

概况

当我们谈论代码注释时，我们指的是在源代码中添加的文本，目的是提供关于代码功能、实现细节或其他相关信息的解释。代码注释对于团队协作、代码维护和理解代码逻辑都非常重要。以下是一些关于代码注释的一般性建议：

1. 清晰而简洁： 注释应该清晰而简洁地解释代码的目的。避免过多冗长的注释，而应注重传达关键信息。

2. 解释复杂逻辑： 如果代码包含复杂或难以理解的逻辑，使用注释来解释这些部分。这对于帮助其他人理解你的代码是很有帮助的。

3. 标识重要信息： 注释可以用于标识重要的决策、设计选择或可能的问题。这有助于在以后的维护中快速了解代码的上下文。

4. 不要过度注释： 避免在每一行代码上都添加注释，除非有必要。简洁的代码通常比过度注释更容易理解。

5. 及时更新： 如果代码发生变化，确保及时更新相关的注释，以保持注释的准确性。

6. 文档注释： 对于函数、类和模块，使用文档注释（docstrings）来提供关于其作用、参数和返回值的信息。这在自动生成文档时非常有用。

7. 避免废弃的注释： 删除不再需要的注释，以保持代码的整洁和可维护性。

以上只是一些建议，实际上，注释的使用方式可能因语言、项目和团队的不同而有所不同。在写注释时，最重要的是考虑到代码的可读性和可维护性。

Java中的注释

在Java中，有几种常见的注释类型，用于在源代码中添加解释和文档。以下是主要的几种Java注释：

1. 单行注释（//）： 单行注释以双斜杠开头，用于在代码行的末尾添加注释。

   int x = 10; // 定义变量x并赋值为10
   

2. 多行注释（/* … */）： 多行注释用于注释一块代码或多行文字。

   /*
    * 这是一个多行注释
    * 用于注释多行文字或一整块代码
    */
   int y = 20;
   

3. 文档注释（/** … */）： 文档注释也是多行注释的一种形式，通常用于注释类、方法和字段，以便自动生成文档。

   /**
    * 这是一个文档注释
    * 用于描述类、方法或字段的作用
    */
   public class MyClass {
       // 类的成员和方法
   }
   

   对于方法，文档注释可以包含对方法的描述、参数、返回值等信息。

   /**
    * 计算两个整数的和
    *
    * @param a 第一个整数
    * @param b 第二个整数
    * @return 两个整数的和
    */
   public int add(int a, int b) {
       return a + b;
   }
   

在Java中，文档注释对于生成API文档是很有用的，可以使用工具如Javadoc来自动生成代码文档。
总体而言，良好的注释可以提高代码的可读性和可维护性，因此在编写Java代码时，建议适度使用注释，特别是在涉及到复杂逻辑或需要解释的地方。

关键字

概述

在编程语言中，关键字是具有特殊含义的标识符，它们用于表示语言的基本构造和控制结构。不同的编程语言具有不同的关键字。

Java中关键字

Java语言具有一组关键字，这些关键字在语法中有特殊的用途，不能用作标识符（例如变量名、方法名）。以下是Java的一些关键字：

abstract    assert      boolean     break       byte
case        catch       char        class       const
continue    default     do          double      else
enum        extends     final       finally     float
for         goto        if          implements  import
instanceof  int         interface   long        native
new         package     private     protected   public
return      short       static      strictfp    super
switch      synchronized this        throw       throws
transient   try         void        volatile    while

这些关键字涵盖了Java的基本语法结构、控制流、面向对象特性等方面。在编写Java代码时，需要注意不要将这些关键字用作标识符，否则会导致编译错误。同时，关键字的大小写是固定的，因此class和Class是不同的标识符。

需要注意的是，一些关键字在早期版本中可能有特定的保留作用，但在后来的版本中未被使用。例如，goto和const在Java中没有特殊作用，但仍然是合法的关键字，不建议在实际代码中使用它们。

在Java中，还有一些受限标识符，如true、false和null，它们虽然不是关键字，但有特殊含义。例如，true和false是布尔类型的字面值，而null表示一个不引用任何对象的特殊值。

标识符

概述

在编程中，标识符是用来标识程序实体（如变量、函数、类等）的名称。标识符需要遵循一些规则，以确保它们在编程语言中被正确识别。以下是通用的标识符规则：

1. 字符集合： 标识符通常由字母、数字和下划线组成。它们可以以字母或下划线开头。

2. 大小写敏感： 大多数编程语言是区分大小写的，因此大小写不同的标识符被视为不同的。

3. 长度： 标识符的长度通常有限制，不同编程语言有不同的限制。

4. 保留字： 标识符不能是语言中的保留字（关键字），这是为了避免与编程语言的关键字发生冲突。

5. 规范命名： 为了提高可读性，标识符通常应该具有描述性的名称，符合命名规范。例如，使用驼峰命名法（camelCase）或下划线分隔符。

标识符的命名规则（必须遵守）

在Java中，标识符（Identifiers）是用于命名变量、方法、类等程序实体的名称。Java标识符需要遵循一些命名规则，以确保代码的可读性和一致性。以下是Java标识符的命名规则：

1. 字符集合： 标识符可以包含字母、数字、下划线（_）和美元符号（$）。

2. 首字符： 标识符的首字符必须是字母、下划线（_）或美元符号（$）。

3. 大小写敏感： Java是大小写敏感的，因此大写字母和小写字母被视为不同的字符。

4. 保留字： 标识符不能是Java的保留字（关键字）。例如，不能将变量命名为class或int。

5. 规范命名： 为了提高可读性，标识符应该具有描述性的名称，并且遵循一定的命名规范。通常使用驼峰命名法（camelCase）是一种常见的规范。

   • 类名： 使用大写字母开头，采用驼峰命名法。

     public class MyClass {
         // 类体
     }
     

   • 方法名、变量名： 使用小写字母开头，采用驼峰命名法。

     int myVariable = 42;
     
     void myMethod() {
         // 方法体
     }
     

   • 常量名： 使用全大写字母，用下划线分隔。

     final int MAX_VALUE = 100;
     

这些命名规则有助于使Java代码具有一致性和可读性。遵循良好的命名规范是编写清晰、易于理解的代码的重要方面。

标识符的命名规范

Java的标识符命名规范是一套约定俗成的规则，旨在提高代码的可读性和可维护性。以下是Java标识符的命名规范：

1. 类名：

   • 使用名词形式。
   • 首字母大写，采用驼峰命名法。
   • 示例：Person, StudentInfo

2. 接口名：

   • 使用形容词或名词。
   • 首字母大写，采用驼峰命名法。
   • 示例：Serializable, Runnable

3. 方法名：

   • 使用动词或动词短语。
   • 首字母小写，采用驼峰命名法。
   • 示例：calculateTotal(), getUserInfo()

4. 变量名：

   • 使用有意义的名词。
   • 首字母小写，采用驼峰命名法。
   • 示例：totalCount, userName

5. 常量名：

   • 使用全大写字母，用下划线分隔单词。
   • 示例：MAX_VALUE, PI

6. 包名：

   • 使用小写字母，通常采用反转的域名（域名倒写）。
   • 示例：com.example.project

7. 枚举类型名：

   • 使用名词形式，首字母大写，采用驼峰命名法。
   • 示例：DayOfWeek, Color

8. 参数名：

   • 通常采用简短、有意义的名字。
   • 首字母小写，采用驼峰命名法。
   • 示例：count, username

这些规范帮助程序员编写一致、易读的代码，并促使良好的编码风格。使用清晰、有意义的标识符有助于他人理解代码的含义，提高代码的可维护性。同时，保持一致性有助于整个项目的统一性。

数据类型

数据类型分类

在Java中，数据类型用于定义变量的类型，以指定变量可以存储的数据的种类和范围。Java的数据类型可以分为两大类：基本数据类型（Primitive Data Types）和引用数据类型（Reference Data Types）。

1. 基本数据类型（Primitive Data Types)：

Java的基本数据类型是不可改变的，它们直接存储数据值。以下是Java的基本数据类型：

• 整数类型：

  • byte: 8 位有符号整数
  • short: 16 位有符号整数
  • int: 32 位有符号整数
  • long: 64 位有符号整数

• 浮点数类型：

  • float: 32 位单精度浮点数
  • double: 64 位双精度浮点数

• 字符类型：

  • char: 16 位无符号Unicode字符

• 布尔类型：

  • boolean: 表示真或假的值

基本数据类型是存储在栈内存中，它们直接包含实际的数据值。

2. 引用数据类型（Reference Data Types）：

引用数据类型是指存储对象引用的变量，而不是直接存储实际数据值。以下是Java的引用数据类型：

• 类：

  • 通过定义类来创建对象，类的实例是引用数据类型。

• 接口：

  • 引用实现接口的对象。

• 数组：

  • 用于存储同一类型的多个元素的引用数据类型。

• 枚举：

  • 一种特殊的引用类型，用于定义一组命名的常量。

• 其他引用类型：

  • 包括指针类型、自定义引用类型等。

引用数据类型的变量存储的是对象的引用地址，而不是实际的数据。对象本身存储在堆内存中。

在Java中，变量的数据类型必须在声明时指定，这有助于编译器进行类型检查，提高代码的稳定性和安全性。

基本数据类型

Java的基本数据类型用于定义变量，它们是不可改变的，直接存储数据值。以下是Java的基本数据类型：

1. 整数类型：

   • byte：8位有符号整数，取值范围为 -128 到 127。
   • short：16位有符号整数，取值范围为 -32,768 到 32,767。
   • int：32位有符号整数，取值范围为 -2^31 到 2^31-1。
   • long：64位有符号整数，取值范围为 -2^63 到 2^63-1。

   byte myByte = 10;
   short myShort = 1000;
   int myInt = 100000;
   long myLong = 10000000000L; // 注意：long类型的值后面需要加上"L"
   

2. 浮点数类型：

   • float：32位单精度浮点数，取值范围较大，但精度较低。
   • double：64位双精度浮点数，取值范围更大，精度更高。

   float myFloat = 3.14f; // 注意：float类型的值后面需要加上"f"
   double myDouble = 3.141592653589793;
   

3. 字符类型：

   • char：16位无符号Unicode字符，表示单个字符。

   char myChar = 'A';
   

4. 布尔类型：

   • boolean：表示逻辑值，只有两个取值：true 或 false。

   boolean myBoolean = true;
   

这些基本数据类型分别用于存储整数、浮点数、字符和布尔值。它们是在栈内存中直接存储数据值的，而不是存储对象引用。基本数据类型在Java中是原始的数据类型，而不是对象。在声明变量时，可以使用这些基本数据类型来定义变量的类型。

常量

概述

在编程中，常量是指在程序运行期间其值不能被修改的变量。常量通常用于表示固定的值，如数值、字符串、枚举值等。在不同的编程语言中，定义和使用常量的方式可能有所不同。以下是对代码常量的概述：

特征和性质：

• 不可变性： 常量的值一经定义就不能被修改，确保在程序执行过程中保持不变。

• 命名规范： 常量通常采用全大写字母，用下划线分隔单词，以提高可读性。例如：MAX_VALUE, PI, APP_NAME。

• 关键字或修饰符： 在某些编程语言中，使用关键字（如final）或特殊的修饰符来标识常量。

优点和用途：

• 可读性和维护性： 常量提高了代码的可读性，因为它们使用有意义的名称代替了硬编码的值，使得代码更易维护。

• 避免硬编码： 常量的使用避免了在代码中直接硬编码数值或字符串，提高了代码的灵活性和可维护性。

• 共享和重用： 类常量可以在整个类中共享和重用，确保在多处使用相同值的地方始终保持一致。

总体而言，常量是编写清晰、可读、可维护代码的重要组成部分。在不同的编程语境中，常量可能会有一些差异，但它们的基本原则和作用通常是一致的。

常量的分类

在Java中，常量可以分为字面常量（Literal Constants）、final 常量和枚举常量。以下是它们的分类：

1. 字面常量（Literal Constants）：

字面常量是直接使用字面值表示的常量，它们包括：

• 整数常量： 例如 10, -5, 0.

  int x = 10;
  

• 浮点数常量： 例如 3.14, 2.0f.

  double pi = 3.14;
  

• 字符常量： 用单引号括起来的单个字符，例如 'A', '5'.

  char grade = 'A';
  

• 字符串常量： 用双引号括起来的一串字符。

  String message = "Hello, World!";
  

• 布尔常量： true 或 false.

  boolean isValid = true;
  

• null 常量： 表示没有引用对象。

  Object obj = null;
  

2. final 常量：

使用 final 关键字定义的常量，一经赋值后不可修改。常见的使用方式包括：

• 类常量： 在类中使用 static final 修饰的变量。

  public class Constants {
      public static final int MAX_VALUE = 100;
  }
  

• 局部常量： 在方法或块中使用 final 修饰的变量。

  public void printMessage() {
      final String greeting = "Hello";
      System.out.println(greeting);
  }
  

3. 枚举常量：

使用枚举类型定义的常量。枚举类型是一种特殊的数据类型，它包含一组预定义的常量。

public enum Weekday {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

枚举常量通过枚举类型名和常量名来访问，例如 Weekday.MONDAY。

这些常量分类在Java中用于表示不同类型的常量值，有助于提高代码的可读性和可维护性。选择合适的常量类型取决于具体的使用场景和需求。

变量

在编程中，变量是用于存储和表示数据值的内存位置或存储空间。变量有一个名称（标识符），通过这个名称可以在程序中引用和操作存储在其中的数据。变量在程序执行过程中可以被赋予不同的值，因此其内容是可变的。

以下是关于变量的一些重要概念：

变量的声明：

在使用变量之前，需要先声明它。变量的声明包括指定变量的名称和类型。

int age; // 声明一个整数类型的变量，名称为age

变量的赋值：

变量的赋值是将一个具体的值存储到变量中。赋值使用赋值运算符（=）。

age = 25; // 将值25赋给变量age

也可以在声明变量的同时进行赋值：

int age = 25; // 声明并初始化一个整数类型的变量age

变量的类型：

变量的类型决定了它可以存储的数据的种类和范围。在Java中，有整数类型、浮点数类型、字符类型、布尔类型等。

int count = 10;           // 整数类型
double price = 19.99;     // 浮点数类型
char grade = 'A';         // 字符类型
boolean isValid = true;   // 布尔类型

变量的命名规则：

变量的命名需要遵循一定的规则，通常包括：

• 变量名可以包含字母、数字、下划线和美元符号。
• 变量名不能以数字开头。
• 变量名区分大小写。
• 避免使用Java关键字作为变量名。
• 使用具有描述性的名称，提高代码可读性。

int myNumber = 42;   // 有效的变量名
double totalAmount$; // 有效的变量名
int 3years;          // 无效，不能以数字开头

变量的作用域：

变量的作用域指的是变量在代码中有效的范围。在Java中，变量的作用域通常包括方法、代码块等。

public void exampleMethod() {
    int localVar = 10;  // 局部变量，在方法内有效
    // 其他代码
}

变量的生命周期：

变量的生命周期是指变量在程序执行期间存在的时间段。局部变量的生命周期通常在其所在的代码块内，而成员变量（类变量）的生命周期与对象的生命周期相关。

变量是编程中非常基础和重要的概念，它们用于存储和处理程序中的数据，是实现算法和逻辑的基础。

输出

输出语句

在Java中，常用的进行输出的方式是使用 System.out.println() 方法。这方法用于在控制台输出数据，并自动换行。以下是一些示例：

输出文本：

System.out.println("Hello, World!");

输出变量的值：

int age = 25;
System.out.println("Age: " + age);

输出多个变量的值：

String name = "John";
int score = 90;
System.out.println("Name: " + name + ", Score: " + score);

格式化输出：

String name = "Alice";
int marks = 85;
System.out.printf("Student Name: %s, Marks: %d\n", name, marks);

在上述示例中，System.out.println() 用于输出一行文本，+ 用于连接字符串，printf 方法用于格式化输出。

除了 System.out.println()，还有其他输出方法，例如 System.out.print() 用于不换行输出，以及 System.out.printf() 用于格式化输出。

System.out.print("This is ");
System.out.println("on the same line.");

这些输出语句可以帮助开发者在控制台上查看程序的执行结果，进行调试和验证。在实际开发中，也可以使用日志系统或其他输出方式，取决于具体的需求和场景。

计算机是如何储存数据的

概述

计算机储存数据的方式主要依赖于计算机内存和存储设备。计算机内存通常分为主存储器（主内存）和辅助存储器（辅助内存），而这两者使用不同的技术来储存数据。

主存储器（主内存）：

主存储器是计算机中用于临时存储数据和程序的地方，它直接与CPU进行交互。主存储器通常采用随机存取存储器（Random Access Memory，RAM）的形式。RAM的特点包括：

• 易失性： 当计算机断电时，RAM中的数据将丢失。
• 可读写： 数据可以被读取和写入，是读写速度较快的存储器。
• 直接访问： 可以随机访问存储器中的任意位置，而不需要按顺序访问。

主存储器用于存储正在运行的程序和操作系统，以及临时的数据。

辅助存储器（辅助内存）：

辅助存储器用于长期存储数据，包括硬盘驱动器、固态硬盘（SSD）、光盘等。与RAM相比，辅助存储器有以下特点：

• 非易失性： 数据在断电时不丢失，可以长期保存。
• 相对较慢： 读写速度通常较慢，但容量较大。
• 顺序访问： 通常按顺序访问，而不是随机访问。

辅助存储器用于存储操作系统、应用程序、用户文件等。计算机启动时，操作系统和一部分常用程序会被加载到主存储器中，而不是直接从辅助存储器中执行。

数据的表示和存储：

计算机中的数据以二进制形式表示，使用比特（bit）作为最小的存储单元。多个比特组合形成字节（byte）。数据的类型（整数、浮点数、字符等）和编码方式（ASCII、Unicode等）决定了数据在存储器中的表示方式。

总体而言，计算机通过将数据存储在主存储器和辅助存储器中，以及通过二进制编码的方式，实现了对程序和数据的高效管理和存储。

进制

计算机中常用的进制有二进制（Binary）、八进制（Octal）、十进制（Decimal）和十六进制（Hexadecimal）。这些进制用于表示和处理数据，而计算机在内部通常以二进制形式存储和处理信息。

二进制（Binary）：

• 基数： 2
• 包含的数字： 0 和 1
• 表示方式： 以数字 0 和 1 的组合表示，每一位称为一个比特（bit）。

示例：二进制数 1011 表示十进制数 11。

八进制（Octal）：

• 基数： 8
• 包含的数字： 0、1、2、3、4、5、6、7
• 表示方式： 以数字 0 到 7 的组合表示。

示例：八进制数 17 表示十进制数 15。

十进制（Decimal）：

• 基数： 10
• 包含的数字： 0、1、2、3、4、5、6、7、8、9
• 表示方式： 以数字 0 到 9 的组合表示。

示例：十进制数 123 表示自身。

十六进制（Hexadecimal）：

• 基数： 16
• 包含的数字： 0、1、2、3、4、5、6、7、8、9、A、B、C、D、E、F（A 表示10，B 表示11，以此类推）
• 表示方式： 以数字 0 到 9 和字母 A 到 F 的组合表示。

示例：十六进制数 1A 表示十进制数 26。

转换关系：

• 二进制和八进制、十进制、十六进制之间可以通过相应的规则进行转换。
• 二进制转八进制：每 3 位二进制对应 1 位八进制。
• 二进制转十进制：按权展开，权从右往左递增，每一位与2的相应次方相乘。
• 二进制转十六进制：每 4 位二进制对应 1 位十六进制。

这些进制在计算机科学和数字电子技术中都有广泛的应用，不同进制的选择取决于具体的需求和场景。

储存单位
计算机的储存单位用于表示数据的大小，常见的储存单位包括比特（Bit）、字节（Byte）、千字节（Kilobyte，KB）、兆字节（Megabyte，MB）、吉字节（Gigabyte，GB）、太字节（Terabyte，TB）、拍字节（Petabyte，PB）等。这些单位用于衡量计算机存储容量的大小。

基本数据类型转换

在Java中，基本数据类型之间的转换主要分为两种：隐式转换（自动类型转换）和显式转换（强制类型转换）。

1. 隐式转换（自动类型转换）：

   • 当把一个数据类型的值赋给另一种数据类型的变量时，如果目标数据类型的范围大于源数据类型，Java 会自动进行类型转换。
   • 例如，将一个整数赋值给浮点数变量，或将小范围整数类型赋值给大范围整数类型，都会发生隐式转换。

   int intValue = 10;
   double doubleValue = intValue; // 隐式转换，int 到 double
   

2. 显式转换（强制类型转换）：

   • 当把一个数据类型的值赋给另一种数据类型的变量时，如果目标数据类型的范围小于源数据类型，需要使用强制类型转换。
   • 在强制类型转换中，需要在目标数据类型的变量前面加上括号，并且可能会发生数据丢失或溢出。

   double doubleValue = 10.5;
   int intValue = (int) doubleValue; // 强制转换，double 到 int
   

需要注意的是，当从整数类型向浮点数类型转换时，没有数据丢失。但是，当从浮点数类型向整数类型转换时，可能会发生精度损失，小数部分会被截断。

下面是一些基本数据类型之间的转换规则：

• byte → short → int → long → float → double
• char → int → long → float → double