标签：运算符 Java int 基础 System 语法 println out

关键字和保留字

在Java编程语言中，关键字和保留字是语言的基本组成部分。它们有特定的含义并在Java程序中扮演着重要的角色。理解这些关键字和保留字对于编写有效的Java代码至关重要。

1. 关键字（Keywords）

关键字是Java语言中具有特殊含义的词，它们在编译器中被预定义并用于执行特定的操作。Java的关键字是保留的，不能用作变量名、函数名、类名等标识符。Java中共有53个关键字，下面是这些关键字的列表及其用途：

1.1. 数据类型相关

byte: 8位整数类型。
short: 16位整数类型。
int: 32位整数类型。
long: 64位整数类型。
float: 单精度浮点数类型。
double: 双精度浮点数类型.
char: 16位字符类型。
boolean: 布尔类型，表示true或false。

1.2. 控制流相关

if: 条件语句。
else: 与if配合使用的条件语句。
switch: 多分支选择语句。
case: switch语句中的分支。
default: switch语句中的默认分支。
for: 循环语句。
while: 循环语句。
do: 循环语句，配合while使用。

1.3. 类和对象相关

class: 定义类。
interface: 定义接口。
extends: 继承类。
implements: 实现接口。
new: 创建新对象。
this: 当前对象的引用。
super: 父类的引用。

1.4. 访问修饰符

public: 公开访问权限。
protected: 受保护访问权限。
private: 私有访问权限。

1.5. 方法和变量相关

void: 方法没有返回值。
static: 静态成员或方法。
final: 常量或不能被继承的类/方法。
abstract: 抽象类或方法。

1.6. 异常处理

try: 开始一个异常处理块。
catch: 捕获异常。
finally: 执行最终代码块。
throw: 抛出异常。
throws: 方法声明中指明可能抛出的异常。

1.7. 包相关

package: 定义类的包。
import: 导入其他包中的类或接口。

1.8. 其他

return: 从方法返回。
assert: 断言，用于调试。
enum: 定义枚举类型。
synchronized: 同步代码块。
volatile: 指定变量在多线程环境中的可见性。

2. 保留字（Reserved Words）

保留字是那些在未来的Java版本中可能会被用于新的功能或特性的词。保留字目前并没有实际用途，但为了避免将来冲突，它们也不能被用作标识符。Java中保留字包括：

const: 保留字，但在Java中未使用。
goto: 保留字，但在Java中未使用。

这两个词被保留是为了与其他语言兼容，或者为未来的扩展留出空间。

3. 总结

Java中的关键字和保留字为语言的核心功能提供了支持。理解这些关键字及其用途有助于编写清晰、正确的Java代码，并避免因误用关键字而产生编译错误。在编写代码时，应避免将关键字和保留字用作标识符，以确保代码的正确性和可维护性。

Java标识符

在Java编程中，标识符是用来识别程序中不同元素的名称，例如变量、函数、类、接口、包等。理解标识符的规则和使用方法对于编写有效和易读的Java代码至关重要。

1. 标识符的定义

标识符是Java程序中用于标识变量、方法、类、接口、包等名称的词汇。标识符由字母、数字、下划线（_）和美元符号（$）组成，但不能以数字开头。

1.1. 标识符的组成

字母：可以是英文字母（a-z, A-Z）或Unicode字符。
数字：可以用来构成标识符的一部分，但不能作为标识符的开头。
下划线（_）：可以用来分隔标识符中的单词。
美元符号（$）：虽然不常用，但也可以作为标识符的一部分。

1.2. 标识符的命名规则

以字母、下划线或美元符号开头：标识符必须以字母（a-z, A-Z）、下划线（_）或美元符号（$）开头，不能以数字开头。
```
int _variable;
int $variable;
int variable1;
// int 1variable; // 错误：标识符不能以数字开头
```
后续字符：标识符的后续字符可以是字母、数字、下划线或美元符号。
```
int variableName;
int variable_name;
int variable$Name;
int variableName1;
```
大小写敏感：Java中的标识符是区分大小写的。Variable, variable 和 VARIABLE 是不同的标识符。
```
int Variable;
int variable;
Variable = 5;
variable = 10;
```
不可使用关键字：标识符不能与Java的关键字和保留字相同。
```
// int class; // 错误：`class` 是一个关键字
```
可读性：虽然Java允许标识符包含下划线和美元符号，但通常推荐使用有意义的名称和驼峰命名法（camelCase），提高代码的可读性。
```
int employeeAge; // 推荐
int emp_age;     // 不推荐
int emp$age;     // 不推荐
```

2. 标识符的命名规范

为了提高代码的可读性和维护性，通常遵循以下命名规范：

2.1. 类名

使用帕斯卡命名法（PascalCase）：每个单词的首字母大写，无下划线。
```
public class EmployeeManager {
    // 类定义
}
```

2.2. 方法名

使用驼峰命名法（camelCase）：首字母小写，后续每个单词的首字母大写，无下划线。
```
public void calculateSalary() {
    // 方法定义
}
```

2.3. 变量名

使用驼峰命名法（camelCase）：首字母小写，后续每个单词的首字母大写。
```
int employeeAge;
String employeeName;
```

2.4. 常量名

使用全大写字母和下划线分隔：所有字母大写，用下划线分隔单词。
```
public static final int MAX_EMPLOYEES = 100;
```

2.5. 包名

使用小写字母和点号分隔，通常以公司域名的反向形式开头，后跟相关模块名。
```
package com.example.projectname;
```

3. 特殊标识符

3.1. 预定义标识符

Java标准库中包含一些预定义的标识符，如System.out。这些标识符是Java语言的一部分，具有特定的功能和用法。

3.2. 匿名标识符

在某些高级特性中，如匿名内部类或lambda表达式，标识符的使用可能较为灵活或不显式声明。

4. 示例

以下是标识符的使用示例：

public class Student {
    private String studentName; // 变量名
    private int studentAge;     // 变量名

    public void setStudentName(String name) { // 方法名
        this.studentName = name;
    }

    public void setStudentAge(int age) { // 方法名
        this.studentAge = age;
    }

    public static final int MAX_STUDENTS = 50; // 常量名
}

当然可以！以下是关于Java数据类型的详细笔记，涵盖了基本数据类型、引用数据类型及其特点。

Java数据类型

Java中的数据类型分为两大类：基本数据类型（Primitive Data Types）和引用数据类型（Reference Data Types）。理解这些数据类型对于有效地编写和管理Java程序至关重要。

1. 基本数据类型

Java的基本数据类型是最简单的数据类型，用于直接存储数据值。Java定义了八种基本数据类型，每种类型都有固定的大小和范围。

1.1. 基本数据类型列表

byte
short
int
long
float
double
char
boolean

1.2. 基本数据类型详细信息

1.2.1. byte

描述：8位有符号整数。
范围：-128 到 127。
默认值：0。
用途：适用于节省内存的场景，尤其在处理大量小整数时。

byte b = 100;

1.2.2. short

描述：16位有符号整数。
范围：-32,768 到 32,767。
默认值：0。
用途：比int小，但比byte大，适合需要更大范围的场景但又不需要int的情况。

short s = 10000;

1.2.3. int

描述：32位有符号整数。
范围：-2^31 到 2^31 - 1（即 -2,147,483,648 到 2,147,483,647）。
默认值：0。
用途：最常用的整数类型，适用于大多数整数运算。

int i = 100000;

1.2.4. long

描述：64位有符号整数。
范围：-2^63 到 2^63 - 1（即 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807）。
默认值：0L。
用途：用于需要大整数范围的场景。

long l = 10000000000L;

1.2.5. float

描述：单精度32位浮点数。
范围：约 ±3.40282347E+38F（有效位数为7位）。
默认值：0.0f。
用途：适用于需要较小范围的浮点数运算，节省内存。

float f = 3.14f;

1.2.6. double

描述：双精度64位浮点数。
范围：约 ±1.79769313486231570E+308（有效位数为15位）。
默认值：0.0d。
用途：适用于需要高精度的浮点数运算。

double d = 3.14159265358979;

1.2.7. char

描述：16位Unicode字符。
范围：0 到 65,535（即 \u0000 到 \uffff）。
默认值：'\u0000'（空字符）。
用途：用于存储单个字符。

char c = 'A';

1.2.8. boolean

描述：表示布尔值。
范围：true 或 false。
默认值：false。
用途：用于表示逻辑条件。

boolean isTrue = true;

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

引用数据类型用于引用对象或数据结构。与基本数据类型不同，引用数据类型并不直接存储数据值，而是存储对数据的引用（内存地址）。

2.1. 引用数据类型列表

类（Class）
接口（Interface）
数组（Array）
枚举（Enum）

2.2. 引用数据类型详细信息

2.2.1. 类（Class）

描述：用于创建对象的蓝图。类定义了对象的属性（字段）和行为（方法）。
示例：

public class Person {
    String name;
    int age;

    void greet() {
        System.out.println("Hello, my name is " + name);
    }
}

2.2.2. 接口（Interface）

描述：定义了一组方法，没有实现。类通过实现接口来提供方法的实现。
示例：

public interface Animal {
    void makeSound();
}

2.2.3. 数组（Array）

描述：用于存储相同类型的元素集合。数组可以是一维、二维或多维。
示例：

int[] numbers = {1, 2, 3, 4, 5}; // 一维数组
String[][] matrix = {{"A", "B"}, {"C", "D"}}; // 二维数组

2.2.4. 枚举（Enum）

描述：表示一组常量。枚举类型用于定义固定的常量集合。
示例：

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

3. 数据类型的转换

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

较小的数据类型可以自动转换为较大的数据类型，例如：

int i = 100;
long l = i; // int 自动转换为 long

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

较大的数据类型可以通过强制类型转换转换为较小的数据类型：

double d = 9.78;
int i = (int) d; // double 强制转换为 int

3.3. 包装类

Java为每种基本数据类型提供了一个对应的包装类，这些包装类位于 java.lang 包中：

byte -> Byte
short -> Short
int -> Integer
long -> Long
float -> Float
double -> Double
char -> Character
boolean -> Boolean

包装类允许将基本数据类型转换为对象类型，并提供了一些额外的方法。

Integer i = 100; // 使用 Integer 类包装 int 类型

4. 示例

以下是一个包含基本数据类型和引用数据类型的示例：

public class DataTypesExample {
    public static void main(String[] args) {
        // 基本数据类型
        int age = 25;
        double salary = 50000.50;
        char initial = 'J';
        boolean isEmployed = true;

        // 引用数据类型
        Person person = new Person();
        person.name = "John";
        person.age = age;
        person.greet();

        // 数组
        int[] numbers = {1, 2, 3, 4, 5};
        System.out.println("First number: " + numbers[0]);

        // 枚举
        Day today = Day.MONDAY;
        System.out.println("Today is: " + today);
    }
}

当然可以！以下是关于Java数据类型转换的详细笔记：

数据类型转换

在Java编程中，数据类型转换是一个常见的操作。Java支持两种主要类型的转换：隐式转换（自动转换）和显式转换（强制转换）。了解这些转换规则有助于避免数据丢失和类型不匹配的问题。

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

隐式转换，也称为自动类型转换，是指在不需要显式声明的情况下，Java编译器自动将一种数据类型转换为另一种兼容的数据类型。隐式转换通常发生在更小的基本数据类型转换为更大的基本数据类型时。

1.1. 基本数据类型的隐式转换

1.1.1. 整数类型转换

较小的整数类型（如 byte, short, char）可以自动转换为较大的整数类型（如 int, long）。

byte b = 10;
int i = b; // byte 自动转换为 int

short s = 20;
long l = s; // short 自动转换为 long

1.1.2. 浮点数类型转换

float 类型可以自动转换为 double 类型，因为 double 有更高的精度。

float f = 3.14f;
double d = f; // float 自动转换为 double

1.1.3. 字符型转换

char 类型可以自动转换为整数类型（int）和浮点类型（float, double）。

char c = 'A';
int i = c; // char 自动转换为 int
double d = c; // char 自动转换为 double

1.2. 对象类型的隐式转换

在继承关系中，子类对象可以自动转换为父类类型，这称为向上转型。

class Animal {
    void eat() {
        System.out.println("Animal eats");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog barks");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Animal animal = dog; // Dog 自动转换为 Animal
        animal.eat();
    }
}

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

显式转换，也称为强制类型转换，需要在代码中明确声明。它通常用于将较大的数据类型转换为较小的数据类型，或者在对象类型中进行向下转型。

2.1. 基本数据类型的显式转换

2.1.1. 整数类型转换

将较大的整数类型转换为较小的整数类型时需要强制转换，这可能会导致数据丢失。

int i = 300;
byte b = (byte) i; // int 强制转换为 byte
System.out.println(b); // 可能输出 -44，因为超出了 byte 的范围

2.1.2. 浮点数类型转换

将 double 转换为 float，或将 float 转换为 int 时需要显式转换。

double d = 9.78;
float f = (float) d; // double 强制转换为 float

int i = (int) d; // double 强制转换为 int
System.out.println(i); // 输出 9

2.1.3. 字符型转换

将 char 类型转换为整数类型（byte, short）时需要显式转换。

char c = 'A';
byte b = (byte) c; // char 强制转换为 byte
System.out.println(b); // 输出 65

2.2. 对象类型的显式转换

在继承关系中，将父类对象强制转换为子类对象时需要显式转换，这通常需要检查对象的实际类型。

class Animal {
    void eat() {
        System.out.println("Animal eats");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog barks");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        Dog dog = (Dog) animal; // Animal 强制转换为 Dog
        dog.bark();
    }
}

3. 转换注意事项

3.1. 数据丢失

在显式转换过程中，较大类型转换为较小类型时可能会导致数据丢失。例如，将 int 转换为 byte 可能会导致溢出，结果不准确。

3.2. 类型不匹配

在对象转换中，强制转换不匹配的类型可能会导致 ClassCastException。可以使用 instanceof 运算符检查对象的实际类型以避免这种情况。

if (animal instanceof Dog) {
    Dog dog = (Dog) animal;
    dog.bark();
} else {
    System.out.println("animal is not a Dog");
}

3.3. 自动装箱和拆箱

Java还支持自动装箱和拆箱，将基本数据类型与其对应的包装类相互转换。自动装箱是将基本数据类型转换为对应的包装类对象，而自动拆箱是将包装类对象转换为基本数据类型。

int i = 100;
Integer integer = i; // 自动装箱

Integer integer2 = 200;
int i2 = integer2; // 自动拆箱

4. 示例

以下是一个包括隐式和显式转换的示例：

public class ConversionExample {
    public static void main(String[] args) {
        // 隐式转换
        int i = 100;
        long l = i; // int 自动转换为 long

        float f = 3.14f;
        double d = f; // float 自动转换为 double

        // 显式转换
        double d2 = 9.78;
        int i2 = (int) d2; // double 强制转换为 int

        char c = 'B';
        byte b = (byte) c; // char 强制转换为 byte

        System.out.println("long value: " + l);
        System.out.println("double value: " + d);
        System.out.println("int value from double: " + i2);
        System.out.println("byte value from char: " + b);
    }
}

当然可以！以下是关于Java运算符的详细笔记，涵盖了Java中各种运算符及其用法。

Java运算符笔记

在Java编程语言中，运算符是用于执行操作的符号。Java提供了多种运算符，主要包括：算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符、自增自减运算符、条件运算符、实例运算符等。理解这些运算符及其用法有助于编写高效和清晰的代码。

1. 算术运算符

算术运算符用于执行基本的数学运算，包括加、减、乘、除和取余操作。

运算符	描述	示例
`+`	加法	`a + b`
`-`	减法	`a - b`
`*`	乘法	`a * b`
`/`	除法	`a / b`
`%`	取余（模）	`a % b`

示例

int a = 10;
int b = 5;

System.out.println("a + b = " + (a + b)); // 15
System.out.println("a - b = " + (a - b)); // 5
System.out.println("a * b = " + (a * b)); // 50
System.out.println("a / b = " + (a / b)); // 2
System.out.println("a % b = " + (a % b)); // 0

2. 关系运算符

关系运算符用于比较两个值的关系，并返回一个布尔值（true 或 false）。

运算符	描述	示例
`==`	等于	`a == b`
`!=`	不等于	`a != b`
`>`	大于	`a > b`
`<`	小于	`a < b`
`>=`	大于等于	`a >= b`
`<=`	小于等于	`a <= b`

示例

int a = 10;
int b = 5;

System.out.println("a == b: " + (a == b)); // false
System.out.println("a != b: " + (a != b)); // true
System.out.println("a > b: " + (a > b));   // true
System.out.println("a < b: " + (a < b));   // false
System.out.println("a >= b: " + (a >= b)); // true
System.out.println("a <= b: " + (a <= b)); // false

3. 逻辑运算符

逻辑运算符用于进行布尔值的逻辑运算，包括与、或、非等操作。

运算符	描述	示例
`&&`	逻辑与（AND）	`a && b`
`		`
`!`	逻辑非（NOT）	`!a`

示例

boolean a = true;
boolean b = false;

System.out.println("a && b: " + (a && b)); // false
System.out.println("a || b: " + (a || b)); // true
System.out.println("!a: " + !a);           // false

4. 位运算符

位运算符用于对整数值的二进制位进行操作。

运算符	描述	示例
`&`	位与（AND）	`a & b`
`	`	位或（OR）
`^`	位异或（XOR）	`a ^ b`
`~`	位取反（NOT）	`~a`
`<<`	左移	`a << b`
`>>`	右移	`a >> b`
`>>>`	无符号右移	`a >>> b`

示例

int a = 5;    // 0000 0101
int b = 3;    // 0000 0011

System.out.println("a & b: " + (a & b));   // 1 (0000 0001)
System.out.println("a | b: " + (a | b));   // 7 (0000 0111)
System.out.println("a ^ b: " + (a ^ b));   // 6 (0000 0110)
System.out.println("~a: " + (~a));         // -6 (1111 1010)
System.out.println("a << 1: " + (a << 1)); // 10 (0000 1010)
System.out.println("a >> 1: " + (a >> 1)); // 2 (0000 0010)
System.out.println("a >>> 1: " + (a >>> 1)); // 2 (0000 0010)

5. 赋值运算符

赋值运算符用于将值赋给变量。Java还提供了复合赋值运算符。

运算符	描述	示例
`=`	赋值	`a = b`
`+=`	加法赋值	`a += b`
`-=`	减法赋值	`a -= b`
`*=`	乘法赋值	`a *= b`
`/=`	除法赋值	`a /= b`
`%=`	取余赋值	`a %= b`
`&=`	位与赋值	`a &= b`
`	=`	位或赋值
`^=`	位异或赋值	`a ^= b`
`<<=`	左移赋值	`a <<= b`
`>>=`	右移赋值	`a >>= b`
`>>>`	无符号右移赋值	`a >>>= b`

示例

int a = 10;
a += 5; // a = a + 5
System.out.println("a += 5: " + a); // 15

a -= 3; // a = a - 3
System.out.println("a -= 3: " + a); // 12

6. 自增自减运算符

自增自减运算符用于增加或减少变量的值。它们有前缀（++a, --a）和后缀（a++, a--）两种形式。

运算符	描述	示例
`++`	自增（前缀/后缀）	`++a` / `a++`
`--`	自减（前缀/后缀）	`--a` / `a--`

示例

int a = 10;

System.out.println("++a: " + ++a); // 11 (前缀自增)
System.out.println("a++: " + a++); // 11 (后缀自增)
System.out.println("a: " + a);     // 12 (自增后的值)

System.out.println("--a: " + --a); // 11 (前缀自减)
System.out.println("a--: " + a--); // 11 (后缀自减)
System.out.println("a: " + a);     // 10 (自减后的值)

7. 条件运算符（Ternary Operator）

条件运算符用于根据条件表达式的结果选择两个值中的一个。它是一种简写形式的 if-else 语句。

运算符	描述	示例
`? :`	条件运算符	`condition ? expr1 : expr2`

示例

int a = 10;
int b

 = 20;

int max = (a > b) ? a : b;
System.out.println("The maximum value is: " + max); // 20

总结

算术运算符 用于执行数学计算。
关系运算符 用于比较两个值。
逻辑运算符 用于执行布尔逻辑操作。
位运算符 用于对整数的二进制位进行操作。
赋值运算符 用于将值赋给变量，包括复合赋值。
自增自减运算符 用于增加或减少变量的值。
条件运算符 用于简化 if-else 语句。
实例运算符 用于测试对象与类的关系。

这些运算符在编写Java程序时扮演着重要角色，了解它们的用法可以帮助你更有效地进行数据操作和逻辑判断。如果有任何问题或需要进一步的信息，请随时告诉我！

标签：运算符,Java,int,基础,System,语法,println,out
From： https://www.cnblogs.com/jiasuo1/p/18343282

Java基础语法

关键字和保留字

1. 关键字（Keywords）

1.1. 数据类型相关

1.2. 控制流相关

1.3. 类和对象相关

1.4. 访问修饰符

1.5. 方法和变量相关

1.6. 异常处理

1.7. 包相关

1.8. 其他

2. 保留字（Reserved Words）

3. 总结

Java标识符

1. 标识符的定义

1.1. 标识符的组成

1.2. 标识符的命名规则

2. 标识符的命名规范

2.1. 类名

2.2. 方法名

2.3. 变量名

2.4. 常量名

2.5. 包名

3. 特殊标识符

3.1. 预定义标识符

3.2. 匿名标识符

4. 示例

Java数据类型

1. 基本数据类型

1.1. 基本数据类型列表

1.2. 基本数据类型详细信息

1.2.1. byte

1.2.2. short

1.2.3. int

1.2.4. long

1.2.5. float

1.2.6. double

1.2.7. char

1.2.8. boolean

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

2.1. 引用数据类型列表

2.2. 引用数据类型详细信息

2.2.1. 类（Class）

2.2.2. 接口（Interface）

2.2.3. 数组（Array）

2.2.4. 枚举（Enum）

3. 数据类型的转换

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

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

3.3. 包装类

4. 示例

数据类型转换

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

1.1. 基本数据类型的隐式转换

1.1.1. 整数类型转换

1.1.2. 浮点数类型转换

1.1.3. 字符型转换

1.2. 对象类型的隐式转换

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

2.1. 基本数据类型的显式转换

2.1.1. 整数类型转换

2.1.2. 浮点数类型转换

2.1.3. 字符型转换

2.2. 对象类型的显式转换

3. 转换注意事项

3.1. 数据丢失

3.2. 类型不匹配

3.3. 自动装箱和拆箱

4. 示例

Java运算符笔记

1. 算术运算符

示例

2. 关系运算符

示例

3. 逻辑运算符

示例

4. 位运算符

示例

5. 赋值运算符

示例