类与字段
一个类可以定义多个字段，这些字段用于存储对象的状态信息。例如，我们可以为Person类定义两个字段：name和age。
class Person {
public String name;
public int age;
}然而，将字段设置为public会使它们对外公开，这可能会破坏类的封装性。为了保护字段不被外部代码直接访问和修改，我们通常会将字段声明为private。
class Person {
private String name;
private int age;
}这样做的好处是，我们可以控制对这些字段的访问，确保对象的状态不会被外部代码随意改变，从而维护了对象的完整性和一致性。
方法的定义和参数
方法的定义遵循以下语法：
修饰符 返回类型 方法名(参数列表) {
// 方法体
return 返回值;
}方法可以有返回值，也可以没有。如果没有返回值，则返回类型为void。
方法的参数允许我们传递值给方法。调用方法时，必须按照参数的定义顺序传递相应的值。
this变量
当我们在方法中访问一个与实例字段同名的局部变量时，Java会优先考虑局部变量。为了访问实际的实例字段，我们需要使用this关键字。例如：
class Person {
private String name;
public String getName() {
// 这里不需要使用this，因为name没有同名的局部变量
return name; // 访问实例字段name
}
public void setName(String name) {
// 这里的name是方法参数，与实例字段name同名
// 为了区分它们，我们需要使用this来指代实例字段
this.name = name; // 设置实例字段name的值
}
}在上面的setName方法中，我们通过this.name明确地告诉编译器我们想要操作的是实例字段name，而不是方法参数name。在没有命名冲突的情况下，this是可以省略的。例如，在getName方法中，由于没有局部变量与实例字段name同名，我们可以直接使用name而不需要this.name。
方法的使用
当我们将字段设置为private后，外部代码将无法直接访问这些字段。为了能够对这些字段进行赋值和读取，我们需要定义公共的方法（public methods）。
public class Main {
public static void main(String[] args) {
Person ming = new Person();
ming.setName("Xiao Ming"); // 使用方法设置name
ming.setAge(12); // 使用方法设置age
System.out.println(ming.getName() + ", " + ming.getAge()); // 使用方法获取并打印name和age
}
}
class Person {
private String name;
private int age;
// 获取name的方法（访问器）
public String getName() {
return this.name;
}
// 设置name的方法（修改器）
public void setName(String name) {
if (name == null || name.isBlank()) {
throw new IllegalArgumentException("invalid name");
}
this.name = name.strip(); // 去除首尾空格
}
// 获取age的方法（访问器）
public int getAge() {
return this.age;
}
// 设置age的方法（修改器）
public void setAge(int age) {
if (age < 0 || age > 100) {
throw new IllegalArgumentException("Age must be between 0 and 100.");
}
this.age = age;
}
}在这个例子中，setName和setAge是修改器方法，它们允许外部代码设置name和age字段的值。同时，getName和getAge是访问器方法，它们允许外部代码获取这些字段的值。通过这些方法，我们可以在内部进行逻辑检查，确保传入的参数是有效的，从而避免了不合理的值被赋给字段。
方法参数
当定义一个方法时，我们可以指定每个参数的类型和顺序。例如，setNameAndAge方法接受两个参数，第一个是String类型，第二个是int类型。
class Person {
...
public void setNameAndAge(String name, int age) {
...
}
}在调用这个方法时，必须提供两个参数，类型也要匹配：
Person ming = new Person();
ming.setNameAndAge("Xiao Ming", 30); // 正确调用，提供了两个参数可变参数
Java允许使用可变参数，这是一种特殊的参数，可以接受任意数量的参数。可变参数使用省略号（...）来定义，实际上是一个数组。
class Group {
private String[] names;
public void setNames(String... names) {
this.names = names; // 将可变参数names赋值给数组names
}
}使用可变参数，可以简化方法调用，不需要手动创建数组：
Group g = new Group();
g.setNames("Xiao Ming"); // 传入1个String
g.setNames("Xiao Ming", "Xiao Hong"); // 传入2个String
g.setNames(); // 传入0个String，names数组将被设置为空数组参数绑定
基本类型的参数传递是通过值的复制来实现的。这意味着方法接收的是参数值的一个副本，而不是参数本身。因此，方法内部对参数的任何修改都不会影响到原始变量。
public class Main {
public static void main(String[] args) {
Person p = new Person();
int n = 15;
p.setAge(n);
System.out.println(p.getAge()); // 输出 15
n = 20;
System.out.println(p.getAge()); // 输出仍然是 15，因为n的修改不影响p的age字段
}
}在这个例子中，n的值被复制给了setAge方法的参数。即使n的值之后被改变，p对象的age字段保持不变，因为它们是独立的副本。
与基本类型不同，引用类型的参数传递实际上是对引用的传递。这意味着方法接收的是对象引用的副本，而不是对象本身的副本。
public class Main {
public static void main(String[] args) {
Person p = new Person();
String[] fullname = new String[] { "Homer", "Simpson" };
p.setName(fullname);
System.out.println(p.getName()); // 输出 "Homer Simpson"
fullname[0] = "Bart";
System.out.println(p.getName()); // 输出 "Bart Simpson"，因为fullname和p.name指向同一个数组
}
}在这个例子中，fullname数组的引用被传递给了setName方法。因此，当fullname数组的内容被修改后，p对象的name字段也会受到影响，因为它们指向同一个数组。
字符串（String类型）在Java中是不可变的（immutable）。这意味着一旦字符串被创建，它的内容就不能被改变。
public class Main {
public static void main(String[] args) {
Person p = new Person();
String bob = "Bob";
p.setName(bob);
System.out.println(p.getName()); // 输出 "Bob"
bob = "Alice";
System.out.println(p.getName()); // 输出仍然是 "Bob"，因为字符串内容不可变
}
}在这个例子中，尽管bob变量的引用被改变了，指向了一个新的字符串，但这不影响p对象的name字段，因为setName方法保存的是字符串的引用，而不是字符串本身。由于字符串内容不可变，p.getName()方法返回的仍然是原始的字符串内容”Bob”。
