java模块2

print和println

print 和 println 是两种常用的输出方法，主要用于在控制台上打印信息。它们的行为因编程语言而异，但通常具有以下特点：

Java中的print和println

• **System.out.print()**：此方法用于打印输出内容到控制台，但与println不同的是，它不会在输出后自动换行。这意味着如果连续使用print，所有输出将出现在同一行上。

• **System.out.println()**：此方法除了打印输出内容外，还会在末尾添加一个换行符（newline），使得后续的输出会从新的一行开始。

常量

字符常量字符常量：带单引号的''单引号中必须有有且只能有一个内容'tab键也算'在编程中，常量是指程序运行期间其值不能被改变的标识符。它们有助于提高代码的可读性和维护性，并允许编译器进行优化。根据不同的标准，常量可以有不同的分类方式。下面从几个方面来解释常量及其分类：

1. 根据作用范围分类

• 局部常量：仅在定义它的代码块（如函数、方法内部）内有效。这类常量通常用于限制其使用范围，以避免命名冲突或不必要的全局暴露。

• 全局常量：在整个程序范围内都有效。在Java中，通过将常量声明为public static final，可以使该常量在不实例化类的情况下访问。

2. 根据数据类型分类

• 基本数据类型的常量：包括整型（int, long等）、浮点型（float, double）、字符型（char）和布尔型（boolean）等。例如，在Java中定义一个整数常量final int MAX_SIZE = 100;。

• 字符串常量：虽然在技术上，String在Java中是对象而不是基本数据类型，但因其使用广泛而单独列出。例如，public static final String APP_NAME = "MyApplication";。

• 对象引用常量：指向不可变对象的引用。值得注意的是，尽管引用本身是固定的（即不能再指向其他对象），但如果对象本身是可变的，那么其内容是可以改变的。为了确保完全不可变，应使用不可变对象。

在编程中，常量间的运算与变量间的运算基本相同，允许你执行各种算术运算（如加法、减法、乘法、除法等）和逻辑运算。常量的运算结果可以在编译时确定（对于编译时常量），也可以在程序运行时计算得出（对于运行时常量）。下面以Java为例说明常量间的运算：

基本算术运算

/前后都是整数结果只取整数，前后只要有一个小数，结果就是小数假设我们定义了几个整数类型的常量：

publicclassConstantArithmetic{
publicstaticfinalint WIDTH = 10;
publicstaticfinalint HEIGHT = 20;

publicstaticvoidmain(String[] args){
// 常量间的加法运算
finalint AREA = WIDTH * HEIGHT;
        System.out.println("Area: " + AREA); // 输出：Area: 200

// 常量间的减法运算
finalint DIFFERENCE = HEIGHT - WIDTH;
        System.out.println("Difference: " + DIFFERENCE); // 输出：Difference: 10

// 常量间的除法运算
finalint RATIO = HEIGHT / WIDTH;
        System.out.println("Ratio: " + RATIO); // 输出：Ratio: 2

// 注意：整数除法会丢弃小数部分
finalint REMAINDER = HEIGHT % WIDTH;
        System.out.println("Remainder: " + REMAINDER); // 输出：Remainder: 0
    }
}

布尔运算

对于布尔类型的常量，可以进行逻辑运算如&&（逻辑与）、||（逻辑或）和!（逻辑非）。

publicclassConstantLogic{
publicstaticfinalboolean FLAG_A = true;
publicstaticfinalboolean FLAG_B = false;

publicstaticvoidmain(String[] args){
// 常量间的逻辑与运算
finalboolean resultAnd = FLAG_A && FLAG_B;
        System.out.println("Result AND: " + resultAnd); // 输出：Result AND: false

// 常量间的逻辑或运算
finalboolean resultOr = FLAG_A || FLAG_B;
        System.out.println("Result OR: " + resultOr); // 输出：Result OR: true

// 常量的逻辑非运算
finalboolean resultNot = !FLAG_A;
        System.out.println("Result NOT: " + resultNot); // 输出：Result NOT: false
    }
}

组合使用

常量间还可以进行组合运算，包括不同类型的常量之间的运算，只要这些操作是类型兼容的即可。

publicclassMixedConstants{
publicstaticfinalint VALUE_A = 5;
publicstaticfinaldouble VALUE_B = 3.2;

publicstaticvoidmain(String[] args){
// 整型和浮点型常量的混合运算
finaldouble mixedResult = VALUE_A + VALUE_B;
        System.out.println("Mixed Result: " + mixedResult); // 输出：Mixed Result: 8.2
    }
}

需要注意的是，在进行运算时，要确保参与运算的数据类型是兼容的，并且了解类型转换规则，比如整数和浮点数之间的运算会导致整数被自动提升为浮点数。通过合理地利用常量间的运算，可以使代码更加简洁和易于理解。

3. 根据是否可以在编译期确定分类

• 编译时常量：其值在编译时就可以确定，比如直接赋值的基本类型或字符串。这些常量在编译阶段就会被替换为其实际值，有助于提高性能。

• 运行时常量：其值需要在程序运行过程中才能确定。例如，通过构造函数或初始化块赋值的常量。

4. 常见编程语言中的实现

• Java：使用final关键字定义常量。对于基本类型和字符串，一旦赋值就不能再更改；对于对象引用，则表示引用地址不可变，但对象状态可能改变

变量

在编程中，变量是存储数据的容器，而变量的数据类型则决定了这个容器可以存储什么类型的数据、该数据如何被操作以及它占用多少内存空间。不同的编程语言支持不同类型的数据类型，并且每种数据类型都有其特定的用途和操作规则。下面将介绍一些常见的数据类型及其特性：

基本数据类型（Primitive Data Types）

1. 整型（Integer Types）

• 用于表示没有小数部分的数值。
• 在Java中包括byte, short, int, long等，分别占用不同的字节大小，能够表示不同范围内的整数。

2. 浮点型（Floating-Point Types）

• 用于表示包含小数部分的数值。
• Java中的float和double类型，其中double提供更高的精度和更大的范围。

3. 字符型（Character Type）

• 表示单个字符，如字母或符号。
• 在Java中使用char类型表示，通常占用2个字节，并采用Unicode编码。

4. 布尔型（Boolean Type）

• 用于表示逻辑值，只有两个可能的值：true或false。
• 在Java中通过boolean关键字定义。

引用数据类型（Reference Data Types）

1. 类（Class）

• 是创建对象的模板或蓝图，定义了属性和方法。
• 如String类，虽然String的行为有时类似于基本数据类型，但它实际上是引用类型。

2. 接口（Interface）

• 定义了一组行为规范，但不实现这些行为。具体实现由实现了该接口的类完成。

3. 数组（Array）

• 可以存储固定数量的同类型元素的集合。
• 数组的大小一旦确定，在Java中就不能更改。

4. 枚举（Enum）

• 特殊的数据类型，允许变量成为一组预定义常量。

其他数据类型

• 包装类（Wrapper Classes）：对于每种基本数据类型，Java提供了相应的包装类（如Integer, Double, Character, Boolean等），使得基本数据类型可以像对象一样处理。

• 无类型（Void）：主要用于方法返回类型，表示该方法不返回任何值。

数据类型的选取

选择合适的数据类型对程序的功能性和效率至关重要。例如，如果知道一个变量只会持有小范围内的整数值，可以选择较小的整型（如byte或short），以节省内存。相反，如果需要处理非常大或者非常高精度的数值，则应选择较大的类型（如long或double）。

变量在编程中是非常基础且重要的概念，它用于存储数据值。通过变量，程序可以执行各种操作，如计算、条件判断等。以下是关于如何声明、初始化和使用变量的一些基本指南，以Java为例进行说明：

变量的声明

声明一个变量需要指定它的数据类型和名称。例如：

int age;
String name;
boolean isStudent;

这里分别声明了一个整型变量age、一个字符串变量name和一个布尔型变量isStudent。

变量的初始化

变量声明后通常需要初始化，即赋予初始值。可以同时在声明时初始化：

int age = 20;
String name = "Alice";
boolean isStudent = true;

也可以先声明再赋值：

int age;
age = 20;

使用变量

一旦变量被初始化，就可以在程序中使用它们来进行各种操作，比如数学运算、逻辑判断等。

int x = 10;
int y = 20;
int sum = x + y;
System.out.println("Sum: " + sum); // 输出 Sum: 30

String firstName = "John";
String lastName = "Doe";
String fullName = firstName + " " + lastName;
System.out.println("Full Name: " + fullName); // 输出 Full Name: John Doe

int temperature = 30;
if (temperature > 25) {
    System.out.println("It's warm outside.");
} else {
    System.out.println("It's cool outside.");
}

变量的作用域

变量的作用域决定了它可以在哪里被访问。作用域分为局部变量（在方法或代码块内定义）、成员变量（类内部但不在任何方法内定义）和静态变量（使用static关键字定义）。

• 局部变量：只能在其声明的方法或代码块中访问。

• 成员变量：可以在整个类的所有方法中访问。

• 静态变量：属于类本身，所有实例共享同一份拷贝。

最佳实践

• 命名规范：采用有意义的名字，并遵循语言的命名约定。例如，在Java中，变量名应以小写字母开头，多个单词间用驼峰命名法区分。

• 初始化检查：确保在使用变量之前已经正确初始化，避免未初始化的变量导致运行时错误。

• 作用域最小化：将变量的作用域限制到尽可能小的范围，有助于减少潜在的错误并提高代码的可读性。

在Java中，尽管String的行为有时类似于基本数据类型，例如可以使用+运算符进行连接操作，但实际上String是一个类，属于引用数据类型。 Java提供了自动装箱（Autoboxing）和拆箱（Unboxing）机制来简化基本数据类型和它们对应的包装类之间的转换过程，但没有为String提供类似的基本类型形式。

整数类型

• byte：在 Java 中占用8位（1字节），因此它的取值范围是从 -128 到 127。这是最小的整数类型，适合用于节省空间的情况。

• short：这种类型的大小是16位（2字节），允许的数值范围从 -32,768 到 32,767。当需要比 byte 更大的数值范围但又不想使用更大的存储空间时，可以使用 short 类型。

• int：作为最常用的整数类型，int 占用32位（4字节），支持的数值范围从 -2,147,483,648 到 2,147,483,647。它适用于大多数整数运算场景。

• long：这是一种64位（8字节）的数据类型，提供了极大的数值范围，从 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807。当你需要处理超出 int 范围的数值时，可以选择 long。

浮点类型

• float：这是一种单精度浮点数类型，占用32位（4字节）。它可以表示大约7位有效数字的数值范围，适用于需要小数点数值且对精度要求不是特别高的情况。

• double：双精度浮点数占用64位（8字节），能够提供大约15位的有效数字。对于需要高精度的小数运算，通常推荐使用 double 类型。

字符类型

• char：字符类型占用16位（2字节），基于Unicode编码，意味着它可以表示一个广泛的字符集中的任何一个字符。其取值范围是0到65,535，对应于Unicode字符集中的字符。

布尔类型

• boolean：布尔类型用于表示逻辑值，仅有两个可能的值：true 和 false。尽管它的实际内存大小没有明确规定，但它仅限于这两个值之一，用于条件判断和控制流程。

变量的运算

算术运算是最常见的运算类型，用于执行数学计算。常见的算术运算符包括：

• +：加法
• -：减法
• *：乘法
• /：除法
• %：取模（求余数）
• ++：自增（增加1）
• --：自减（减少1）

示例：

int a = 10;
int b = 3;
int sum = a + b; // 加法，sum = 13
int diff = a - b; // 减法，diff = 7
int product = a * b; // 乘法，product = 30
int quotient = a / b; // 整数除法，quotient = 3（只保留整数部分）
int remainder = a % b; // 取模，remainder = 1
a++; // 自增，a = 11
b--; // 自减，b = 2

注意：

• 如果两个整数相除，结果会是整数（小数部分会被截断）。如果需要浮点数结果，至少一个操作数应该是浮点数。
• 取模运算的结果符号与被除数相同。

关系运算用来比较两个变量或值，返回布尔值（true 或 false）。常见关系运算符包括：

• ==：等于
• !=：不等于
• >：大于
• <：小于
• >=：大于等于
• <=：小于等于

示例：

int x = 5;
int y = 10;
boolean isEqual = (x == y); // false
boolean isNotEqual = (x != y); // true
boolean isGreater = (x > y); // false
boolean isLessOrEqual = (x <= y); // true

逻辑运算用于对布尔值进行组合或操作，返回布尔值。常见逻辑运算符包括：

• &&：逻辑与（AND），当且仅当两个操作数都为 true 时返回 true
• ||：逻辑或（OR），当任意一个操作数为 true 时返回 true
• !：逻辑非（NOT），反转布尔值

示例：

boolean a = true;
boolean b = false;
boolean result1 = a && b; // false
boolean result2 = a || b; // true
boolean result3 = !a; // false

短路特性：

• && 和 || 具有短路特性。例如，在 a && b 中，如果 a 为 false，则不会计算 b 的值，因为整个表达式已经确定为 false。

位运算直接对变量的二进制位进行操作。常见位运算符包括：

• &：按位与
• |：按位或
• ^：按位异或
• ~：按位取反
• <<：左移
• >>：右移（带符号）
• >>>：无符号右移

示例：

int a = 6; // 二进制：0110
int b = 3; // 二进制：0011
int andResult = a & b; // 按位与：0010（十进制：2）
int orResult = a | b; // 按位或：0111（十进制：7）
int xorResult = a ^ b; // 按位异或：0101（十进制：5）
int notResult = ~a; // 按位取反：11111111111111111111111111111001（十进制：-7）
int shiftLeft = a << 1; // 左移一位：1100（十进制：12）
int shiftRight = a >> 1; // 右移一位：0011（十进制：3）

赋值运算将右侧的值赋给左侧的变量。常见的赋值运算符包括：

• =：简单赋值
• +=：加后赋值
• -=：减后赋值
• *=：乘后赋值
• /=：除后赋值
• %=：取模后赋值
• <<=、>>=、>>>=：位移后赋值

示例：

int x = 10;
x += 5; // 等价于 x = x + 5，x = 15
x -= 3; // 等价于 x = x - 3，x = 12
x *= 2; // 等价于 x = x * 2，x = 24
x /= 4; // 等价于 x = x / 4，x = 6
x %= 5; // 等价于 x = x % 5，x = 1

2. 运算注意事项

• 数据类型转换：

  示例：

  int a = 5;
  double b = 2.5;
  double result = a + b; // 自动提升为 double，result = 7.5
  int truncated = (int) result; // 强制转换为 int，truncated = 7
  

• 当不同数据类型参与运算时，Java 会自动进行类型提升（隐式转换）。例如，int 和 double 运算时，int 会被提升为 double。
• 如果需要显式转换，可以使用强制类型转换（如 (int)）。

• 溢出问题：

  示例：

  byte b = 127;
  b++; // 溢出，b = -128
  

• 如果变量的值超出了其数据类型的取值范围，会导致溢出。例如，byte 类型的最大值是 127，如果对其加 1，则会溢出为 -128。

• 运算符优先级：

  示例：

  int result = 10 + 5 * 2; // 先乘后加，result = 20
  int resultWithParentheses = (10 + 5) * 2; // 先加后乘，resultWithParentheses = 30
  

• 不同运算符有不同的优先级。例如，* 和 / 的优先级高于 + 和 -。
• 使用括号可以改变优先级。

3. 总结

变量的运算是编程中的核心内容，涵盖了算术、关系、逻辑、位运算以及赋值等多种操作。掌握这些运算规则及其注意事项，可以帮助你编写高效、安全的代码。不同类型的数据在运算时需要注意类型转换和溢出等问题，以避免潜在的错误。

转义字符

1. 常见转义字符

• 表示换行。

• 将光标移动到下一行的开头。

• 示例：

  System.out.println("HellonWorld");
  // 输出：
  // Hello
  // World
  

• 插入一个水平制表位，通常相当于 4 或 8 个空格。
• 示例：

  System.out.println("Name:tAlice");
  // 输出：
  // Name:    Alice
  

• 用于表示一个反斜杠字符本身。

• 示例：

  System.out.println("C:\Program Files\Java");
  // 输出：
  // C:Program FilesJava
  

• 用于表示字符串中的双引号字符。

• 示例：

  System.out.println("He said, "Hello!"");
  // 输出：
  // He said, "Hello!"
  

• 用于表示字符字面量中的单引号字符。

• 示例：

  char singleQuote = ''';
  System.out.println(singleQuote);
  // 输出：
  // '
  

• 表示退格操作，将光标回退一格。

• 示例：

  System.out.println("HellobWorld");
  // 输出：
  // HellWorld
  

• 表示回车操作，将光标移动到当前行的开头。
• 示例：

  System.out.println("HellorWorld");
  // 输出：
  // World
  

• 表示换页操作，主要用于打印机等设备。
• 示例：

  System.out.println("Page1fPage2");
  // 输出：
  // Page1
  // （分页效果）
  

• 用于表示 Unicode 字符，其中 XXXX 是四位十六进制数。

• 示例：

  System.out.println("u0041"); // 输出字符 'A'
  

2. 转义字符的应用场景

在 Windows 系统中，文件路径中使用反斜杠（），但在 Java 字符串中需要对反斜杠进行转义。

String filePath = "C:\Users\Alice\Documents\file.txt";
System.out.println(filePath);
// 输出：
// C:UsersAliceDocumentsfile.txt

使用 n 和 t 可以轻松实现换行和对齐。

System.out.println("Name:tAlicenAge:t25");
// 输出：
// Name:   Alice
// Age:    25

如果需要在字符串中包含双引号或单引号，可以使用转义字符。

System.out.println("She said, "It's a beautiful day!"");
// 输出：
// She said, "It's a beautiful day!"

使用 uXXXX 可以插入任何 Unicode 字符。

System.out.println("Smile: u263A"); // 输出笑脸符号 ☺

3. 注意事项

• 转义字符仅适用于字符串和字符字面量

• 转义字符只能出现在字符串（"..."）或字符（'...'）中。
• 如果在其他地方使用（如注释中），则不会被解析为转义字符。

• 非法转义字符会导致编译错误

• 如果使用了未定义的转义字符（如 z），编译器会报错。

• 示例：

  System.out.println("Invalid escape sequence: z");
  // 编译错误：Illegal escape character in string literal
  

• 转义字符的长度

• 转义字符被视为单个字符。例如，'n' 的长度为 1。

float和double的区别

在 Java 中，float 和 double 都是用于表示浮点数的数据类型，但它们之间存在一些重要的区别。这些差异主要体现在精度、取值范围以及内存占用等方面。

1. 精度 float：单精度浮点数，提供大约7位有效数字的精度。 double：双精度浮点数，提供大约15位有效数字的精度。 由于 double 提供更高的精度，所以在需要高精度计算时通常推荐使用 double 类型。

2. 取值范围 float： 取值范围大约是从 ±3.4E-38 到 ±3.4E+38。 占用32位（4字节）存储空间。 double： 取值范围大约是从 ±1.7E-308 到 ±1.7E+308。 占用64位（8字节）存储空间。 因此，double 不仅提供了更高的精度，还拥有更广的数值范围。

3. 内存占用 float：因为是单精度浮点数，所以占用较少的内存（32位/4字节），适用于对内存使用有严格要求的情况。 double：作为双精度浮点数，它占用更多的内存（64位/8字节），但在大多数现代计算机上，这点额外的开销通常是可接受的，尤其是考虑到其提供的更高精度和更广的数值范围。

4. 默认类型 在 Java 中，如果一个浮点数没有特别指定为 float 类型，默认它是 double 类型。例如，直接写出 3.14 是一个 double 值，而要将其定义为 float 类型，则需要在其后加上 f 或 F，如 3.14f。

5. 应用场景 float：当程序对内存使用非常敏感，且不需要非常高精度的浮点数运算时（比如图形处理、游戏开发等），可以考虑使用 float。 double：对于科学计算、工程应用或其他需要高精度浮点数运算的应用场景，建议使用 double。 示例代码

float floatVar = 3.14f; // 使用 'f' 后缀来声明 float 变量
double doubleVar = 3.14; // 默认为 double 类型

System.out.println("Float value: " + floatVar);
System.out.println("Double value: " + doubleVar);