变量（Variables）

在Java中，变量是用于存储数据值的容器。你可以把变量看作是一个命名的存储位置。在Java中，每个变量都有一个数据类型，它决定了变量可以存储的数据的类型。在使用变量之前，你需要先声明它，然后给它赋值。

// 声明一个整数类型的变量
int myNumber;// 给变量赋值
myNumber = 10;// 也可以在声明的同时进行赋值
int anotherNumber = 20;
char asc = 97; // 这里使用ascii码赋值单个字符// 使用变量
int result = myNumber + anotherNumber;
System.out.println(result); // 输出：30

在Java中，变量可以分为局部变量（Local Variables）和成员变量（Instance Variables）。这两种变量在其作用域和生命周期上有一些不同。

局部变量和成员变量

局部变量（Local Variables）

局部变量是在方法、代码块或构造方法内部声明的变量。它们只在声明它们的方法、代码块或构造方法中可见，超出这个范围就无法访问。局部变量在使用之前必须进行初始化，即给它们赋初值。

public class Example {public void exampleMethod() {// 局部变量 numint num = 10;System.out.println(num);// 其他代码...}public void anotherMethod() {// 编译错误！无法访问 exampleMethod 中的局部变量 num// System.out.println(num);}
}

成员变量（Instance Variables）

成员变量是声明在类中但在方法之外的变量。它们通常被称为实例变量，因为它们属于类的实例（对象），每个对象都有自己的一组成员变量。与局部变量不同，成员变量在整个类中都是可见的，可以被类的任何方法访问。

public class Example {// 成员变量int memberVariable;public void setMemberVariable(int value) {// 可以访问成员变量memberVariable = value;}public void printMemberVariable() {// 可以访问成员变量System.out.println(memberVariable);}
}

需要注意的是，成员变量在对象创建时分配内存，而局部变量在方法执行时分配内存。成员变量有默认值，可以不进行显式初始化；而局部变量必须在使用前显式初始化。

总结一下：

• 局部变量是在方法内部声明的，只在方法内部可见，需要显式初始化。
• 成员变量是在类中声明的，属于对象，可以被类的任何方法访问，有默认值。

标识符（Identifiers）

标识符是用来标识程序中的各种元素，如变量、方法、类等的名称。在Java中，标识符必须遵循一些规则：

• 只能包含字母（大写或小写）、数字、下划线(_)和美元符号($)。
• 必须以字母、下划线(_)或美元符号($)开头。
• 不能是Java关键字（例如，class、int、if等）。
• 区分大小写。

以下是一些例子：

// 合法的标识符
int myVariable;
char studentName;
double _salary;
int numberOfStudents;// 不合法的标识符
// int 2students; // 不能以数字开头
// float my-variable; // 不能包含破折号
// boolean class; // 不能使用关键字作为标识符// char 中文； //中文标识符，合法但是不建议使用

要求见名知意，遵守规范。

八种基本数据类型

Java的基本数据类型分为两类：原始数据类型（Primitive Data Types）和引用数据类型（Reference Data Types）。

原始数据类型（Primitive Data Types）

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 = 100;
short myShort = 1000;
int myInt = 100000;
long myLong = 1000000000L; // 注意：long类型需要在数值后面加上 "L" 或 "l"。

注意：long类型需要在数值后面加上 “L” 或 “l”。其中小写l和1不好区分建议大写。

2. 浮点数类型：
   • float: 32位，范围约为 ±3.4e-38 到 ±3.4e+38，精度为6-7位小数。
   • double: 64位，范围约为 ±1.7e-308 到 ±1.7e+308，精度为15位小数。

float myFloat = 3.14f; // 注意：float类型需要在数值后面加上 "f" 或 "F"。
double myDouble = 3.14;

注意：float类型需要在数值后面加上 “f” 或 “F”。

3. 字符类型：
   • char: 16位 Unicode 字符，范围为 ‘\u0000’（0）到 ‘\uffff’（65535）。

char myChar = 'A';

4. 布尔类型：
   • boolean: 表示真（true）或假（false）。

boolean myBoolean = true;

字节占用

引用数据类型（Reference Data Types）

5. 类类型：
   • class: 定义对象的模板。

class MyClass {// 类的定义
}MyClass myObject = new MyClass(); // 创建类的实例

6. 接口类型：
   • interface: 定义一组方法的集合，类实现接口来提供具体实现。

interface MyInterface {// 接口的定义
}class MyImplementation implements MyInterface {// 实现接口的类
}

7. 数组类型：
   • array: 存储相同类型数据的容器。

int[] intArray = {1, 2, 3, 4, 5};

8. 枚举类型：
   • enum: 一种特殊的数据类型，用于定义一组常量。

enum Days {SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}Days today = Days.MONDAY;

这八种基本数据类型是Java编程中常用的数据类型，了解它们的特性和用法对于编写有效的Java代码至关重要。

进制与转换

在Java中，通常使用的进制是二进制（base-2）、八进制（base-8）、十进制（base-10）和十六进制（base-16）。

进制

1. 二进制（Binary，base-2）： 由0和1组成，是计算机中最基本的进制。

   int binaryNumber = 0b1010; // 前缀0b表示二进制
   

2. 八进制（Octal，base-8）： 由0到7的数字组成。

   int octalNumber = 012; // 前缀0表示八进制
   

3. 十进制（Decimal，base-10）： 我们通常使用的进制，由0到9的数字组成。

   int decimalNumber = 10;
   

4. 十六进制（Hexadecimal，base-16）： 由0到9以及A到F（或a到f）的字母组成。

   int hexNumber = 0xA; // 前缀0x表示十六进制
   

进制转换

在Java中，你可以使用不同的方法将数字在不同进制之间进行转换。

1. 十进制转其他进制：

int decimalNumber = 15;
String binaryStr = Integer.toBinaryString(decimalNumber); // 十进制转二进制
String octalStr = Integer.toOctalString(decimalNumber); // 十进制转八进制
String hexStr = Integer.toHexString(decimalNumber); // 十进制转十六进制

1111
17
f

2. 其他进制转十进制：

String binaryStr = "1010";
int decimalNumber = Integer.parseInt(binaryStr, 2); // 二进制转十进制String octalStr = "12";
int decimalNumberOctal = Integer.parseInt(octalStr, 8); // 八进制转十进制String hexStr = "A";
int decimalNumberHex = Integer.parseInt(hexStr, 16); // 十六进制转十进制

1010
10
10

八进制转化成二进制只需将每个八进制数字替换为相对应的三个二进制位即可。

基本数据类型转换

在Java中，基本数据类型之间存在自动类型转换和强制类型转换两种方式。这是由于Java是一种强类型语言，要求在不同类型之间进行转换时要明确规定。

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

自动类型转换是指将容量小的数据类型自动提升为容量大的数据类型，不需要人工干预。这种转换是安全的，因为它不会导致数据丢失。

// 示例
int intValue = 10;
double doubleValue = intValue; // 自动将int转换为double

在上面的例子中，int类型的值被自动转换为double类型的值。

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

强制类型转换是指将容量大的数据类型转换为容量小的数据类型，需要使用强制转换操作符，并且可能会导致数据溢出或失真。在进行强制类型转换时，应该确保转换是安全的，否则可能会导致数据丢失。

// 示例
double doubleValue = 10.5;
int intValue = (int) doubleValue; // 强制将double转换为int

在上面的例子中，double类型的值被强制转换为int类型的值。请注意，小数部分被截断，导致数据丢失。

3. 注意事项

• 自动类型转换方向： 转换从容量小的类型到容量大的类型是自动的，而反向则需要显式的强制类型转换。

• 兼容性检查： 在进行强制类型转换时，需要注意数据范围的兼容性，以避免溢出或失真。

以上是关于Java基本数据类型转换的基本概念。记住，在进行类型转换时要确保不会发生数据丢失，并在需要时使用强制类型转换。

关键字

在Java中，关键字是一些被编程语言保留的标识符，它们具有特殊的含义，不能被用作标识符（变量名、类名等）。关键字用于定义语法结构、数据类型、访问权限等，并在程序中具有特殊的用途。以下是Java中一些常用的关键字：

1. 基本数据类型关键字：

   • int: 定义整数类型。
   • double: 定义双精度浮点数类型。
   • char: 定义字符类型。
   • boolean: 定义布尔类型。

2. 控制流关键字：

   • if: 条件语句的开始。
   • else: 条件语句的分支，与if一起使用。
   • switch: 多重条件语句。
   • case: switch语句中的分支。
   • default: switch语句中的默认分支。
   • while: 循环语句。
   • do: 循环语句，与while一起使用。
   • for: 循环语句。
   • break: 跳出循环。
   • continue: 跳过循环中的其余部分。

3. 访问控制关键字：

   • public: 公共访问权限。
   • private: 私有访问权限。
   • protected: 受保护的访问权限。
   • default (package-private): 包内访问权限。

4. 类、方法和变量关键字：

   • class: 定义类。
   • extends: 类的继承。
   • implements: 实现接口。
   • interface: 定义接口。
   • new: 创建对象。
   • static: 静态成员。
   • final: 不可修改的变量、方法或类。
   • abstract: 抽象类、抽象方法。
   • void: 无返回值。
   • this: 当前对象的引用。
   • super: 父类的引用。

5. 异常处理关键字：

   • try: 包含可能引发异常的代码块。
   • catch: 处理异常的代码块。
   • finally: 无论是否发生异常，都会执行的代码块。
   • throw: 手动抛出异常。
   • throws: 在方法声明中指定可能抛出的异常。

6. 其他关键字：

   • import: 导入包或类。
   • package: 定义包。
   • return: 返回值。
   • true, false: 布尔值。
   • null: 空值。
   • instanceof: 判断对象是否是某个类的实例。

转义字符

在Java中，转义字符用于表示一些特殊字符，这些字符在普通字符串中可能无法直接表示或者有特殊含义。转义字符以反斜杠 \ 开始，后面跟着一个字符，用来表示相应的特殊含义。以下是Java中一些常用的转义字符：

1. 换行符：

   • \n: 表示换行符。

2. 回车符：

   • \r: 表示回车符。

3. 制表符：

   • \t: 表示制表符。

4. 退格符：

   • \b: 表示退格符。

5. 反斜杠自身：

   • \\: 表示一个反斜杠字符。

6. 单引号自身：

   • \': 表示一个单引号字符。

7. 双引号自身：

   • \": 表示一个双引号字符。

8. Unicode 字符：

   • \uXXXX: 表示一个 Unicode 字符，其中 XXXX 是该字符的 Unicode 编码，例如 \u0041 表示大写字母 ‘A’。

在字符串中使用转义字符的示例：

public class EscapeCharacters {public static void main(String[] args) {// 换行符System.out.println("Hello,\nWorld!");// 制表符System.out.println("Name\tAge\tCity");// 反斜杠自身System.out.println("This is a backslash: \\");// 单引号自身System.out.println("She said, \'Hello!\'");// 双引号自身System.out.println("He exclaimed, \"Wow!\"");// Unicode 字符System.out.println("Unicode for A is: \u0041");}
}

Hello,
World!
Name	Age	City
This is a backslash: \
She said, 'Hello!'
He exclaimed, "Wow!"
Unicode for A is: A

在上述示例中，转义字符使得字符串能够包含换行符、制表符等特殊字符，而不会被解释成普通字符。

运算符与优先级

在Java中，运算符用于执行各种操作，如算术运算、逻辑运算、比较运算等。这些运算符有不同的优先级，决定了它们在表达式中的执行顺序。以下是一些常见的运算符及它们的优先级：

1. 算术运算符：

• + （加法）
• - （减法）
• * （乘法）
• / （除法）
• % （取模）

2. 关系运算符：

• == （等于）
• != （不等于）
• < （小于）
• > （大于）
• <= （小于等于）
• >= （大于等于）

3. 逻辑运算符：

• && （逻辑与）
• || （逻辑或）
• ! （逻辑非）

4. 位运算符：

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

与 >>（有符号右移）不同，>>> 不考虑符号位，因此在右移时不管符号位是0还是1，都用0填充。

public class Main {public static void main(String[] args) {int value = -8; // 二进制表示为 11111111111111111111111111111000int result = value >>> 1; // 无符号右移一位int result2 = value >> 1; // 右移一位System.out.println("Original value: " + value);System.out.println("Result after >> 1: " + result2);System.out.println("Result after >>> 1: " + result);}
}

Original value: -8
Result after >> 1: -4
Result after >>> 1: 2147483644

请注意，由于 >>> 是无符号右移，因此结果是正数。这与有符号右移 >> 的结果有所不同，后者会用符号位的值填充。

5. 赋值运算符：

• = （赋值）
• += （加法赋值）
• -= （减法赋值）
• *= （乘法赋值）
• /= （除法赋值）
• %= （取模赋值）
• &= （按位与赋值）
• |= （按位或赋值）
• ^= （按位异或赋值）
• <<= （左移赋值）
• >>= （右移赋值）
• >>>= （无符号右移赋值）

6. 条件运算符（三元运算符）：

• ? : （条件表达式）

在Java中，? : 是条件运算符，也称为三元运算符。它是一种简洁的表示条件语句的方式，允许在一个表达式中根据条件选择两个不同的值。
语法格式如下：

result = (condition) ? expression1 : expression2; 

其中：

• condition 是一个布尔表达式，如果为真（true），则选择 expression1，否则选择 expression2。
• expression1 是在条件为真时要返回的值。
• expression2 是在条件为假时要返回的值。

public class TernaryOperatorExample {public static void main(String[] args) {int number = 10;String result = (number % 2 == 0) ? "Even" : "Odd";System.out.println("The number is " + result);}
}

The number is Even

条件运算符可以用于更简洁地表示简单的条件判断，但在使用时要注意保持代码的可读性，不要滥用。复杂的逻辑判断建议使用传统的 if-else 语句。

7. instanceof 运算符

• instanceof （用于测试对象是否为某个类的实例）

9. 其他运算符：

• ++ （自增）
• -- （自减）
• + （正号，用于表示正数）
• - （负号，用于表示负数）
• ~ （按位取反）

运算符优先级：
运算符的优先级决定了表达式中运算符的执行顺序，具有较高优先级的运算符会在具有较低优先级的运算符之前执行。以下是一些常见运算符的优先级（从高到低）：

1. 括号：

   • ( )

2. 一元运算符：

   • ++, --, +, -, !, ~

3. 乘性运算符：

   • *, /, %

4. 加性运算符：

   • +, -

5. 移位运算符：

   • <<, >>, >>>

6. 关系运算符：

   • <, <=, >, >=, instanceof

7. 相等性运算符：

   • ==, !=

8. 按位与运算符：

   • &

9. 按位异或运算符：

   • ^

10. 按位或运算符：

    • |

11. 逻辑与运算符：

    • &&

12. 逻辑或运算符：

    • ||

13. 条件运算符：

    • ? :

14. 赋值运算符：

    • =, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=, >>>=

请注意，具有较高优先级的运算符会在具有较低优先级的运算符之前执行。如果不确定表达式的执行顺序，可以使用括号来明确指定优先级。

分支语当

在Java中，主要有两种类型的分支语句：if语句和switch语句。在Java中，主要有两种类型的分支语句：if语句和switch语句。

1. if 语句

if语句用于根据条件执行不同的代码块。基本的if语句结构如下：

if (条件) {// 如果条件为真，则执行这里的代码
} else {// 如果条件为假，则执行这里的代码
}

例如：

int x = 10;if (x > 5) {System.out.println("x 大于 5");
} else {System.out.println("x 不大于 5");
}

2. switch 语句

switch语句用于根据表达式的值选择执行不同的代码块。它通常用于处理多个可能的情况。基本的switch语句结构如下：

switch (表达式) {case 值1:// 如果表达式的值等于值1，则执行这里的代码break;case 值2:// 如果表达式的值等于值2，则执行这里的代码break;// 可以有更多的 case 语句default:// 如果表达式的值不匹配任何一个 case，则执行这里的代码
}

例如：

int day = 3;switch (day) {case 1:System.out.println("星期一");break;case 2:System.out.println("星期二");break;// 可以有更多的 case 语句default:System.out.println("其他星期");
}

分支语句的使用原则

在学习Java基础时，编写分支语句时确实应该考虑一些优化和规范的原则。以下是一些建议：

• 出现概率大的可能性放在前面进行判断

这个原则是为了提高程序的执行效率。如果你有多个条件判断，将出现概率大的情况放在前面可以减少不必要的比较，提高程序执行速度。

• 尽可能使用确定的值和不确定的值进行对比

这个原则是为了防止出现空指针异常或其他错误。将常量或确定的值放在等号左边，可以避免将null赋给变量的情况。

例如：

// 不好的写法
if (num == null) {// ...
}// 好的写法
if (null == num) {// ...
}

这样写是为了避免在不小心将==写成=时，导致将null赋值给num，从而避免潜在的空指针异常。

循环语句

在Java中，循环语句用于多次执行一段代码。Java提供了多种类型的循环语句，包括for、while、和do-while。这些循环结构允许你根据条件多次执行相同的代码块。

1. for 循环

for循环是一种常用的循环结构，它通过初始化、条件判断和迭代步骤来控制循环。基本结构如下：

for (初始化; 条件判断; 迭代步骤) {// 循环体
}

例如，输出0到4的数字：

for (int i = 0; i < 5; i++) {System.out.println(i);
}

六种常见的for循环写法

1. 基本形式

for (int i = 0; i < 5; i++) {// 循环体
}

2. 省略初始化

int i = 0;
for (; i < 5; i++) {// 循环体
}

3. 省略迭代步骤

for (int i = 0; i < 5;) {// 循环体i++;
}

4. 省略初始化和迭代步骤

int i = 0;
for (; i < 5;) {// 循环体i++;
}

5. 使用多个变量

for (int i = 0, j = 10; i < 5; i++, j--) {// 循环体
}

6. 无限循环

for (;;) {// 无限循环体// 注意: 需要在循环体内使用 break 来跳出循环，否则会一直执行下去break; // 示例中的跳出条件
}

2. while 循环

while循环在执行循环体之前先检查条件是否为真，只有在条件为真时才执行循环体。基本结构如下：

while (条件判断) {// 循环体
}

例如，输出0到4的数字：

int i = 0;
while (i < 5) {System.out.println(i);i++;
}

3. do-while 循环

do-while循环先执行一次循环体，然后检查条件是否为真，如果为真，则继续执行。基本结构如下：

do {// 循环体
} while (条件判断);

例如，输出0到4的数字：

int i = 0;
do {System.out.println(i);i++;
} while (i < 5);

这三种循环结构在不同的情况下有各自的适用性，选择使用哪一种循环取决于问题的性质和需求。