我的个人博客主页：如果’'真能转义1️⃣说1️⃣的博客主页
关于Java基本语法学习---->可以参考我的这篇博客：《我在VScode学Java》
关于我在VScode学Java（Java方法method）

类是描述了一组有相同特性（属性）和相同行为（方法）的一组对象的集合。
对象或实体所拥有的特征在类中表示时称为类的属性。对象执行的操作称为类的方法。

零._. 面向对象编程---->重要性在于它提供了一种更加模块化、可重用和易于维护的编程方式,通过将代码分解为对象，可以更轻松地组织和管理代码。

面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将数据和操作数据的方法组合在一起，以便将数据和行为视为一个整体。这种编程范式的历程可以追溯到20世纪60年代，但直到80年代才开始流行。

在面向对象编程中，数据和方法被组织成类（Class），类是一种抽象数据类型，它定义了一组属性和方法。对象（Object）是类的一个实例¹，它包含了类的属性和方法。通过创建对象，我们可以使用类中定义的方法来操作对象的属性。

（1）封装（Encapsulation）：将数据和行为组合在一起，并将其视为一个单独的实体。这样可以防止外部代码直接访问对象的数据，从而提高了代码的安全性和可维护性。

`什么是封装对象代表什么，就得封装对应的数据，并提供数据对应的行为[如何正确设计对象的属性和方法]	

封装(encapsulation，有时称为信息隐藏)是处理对象的一个重要概念。从形式上看，封装就是将数据和行为组合在一个包中，并对对象的使用者隐藏具体的实现细节。对象中的数据称为实例字段(instance field)，操作数据的过程称为方法 (method)。作为一个类的实例一个特定对象有一组特定的实例字段值。这些值的集合就是这个对象的当前状态( state)。只要在对象上调用一个方法，它的状态就有可能发生改变。

实现封装的关键在于：
绝对不能让其他类中的方法直接访问这个类的实例字段。
程序只能通过对象的方法与对象数据进行交互。封装为对象赋予了“黑盒”特征，这是提高重用性和可靠性的关键。这意味着一个类可以完全改变存储数据的方式，只要仍旧使用同样的方法操作数据，其他对象就不会知道也不用关心这个类所发生的变化。

代码举例

定义了一个学生类

public class Student {
    // 定义了一个私有的字符串类型数据成员name，只能在当前类中被访问。
    private String name;
    // 定义了一个私有的整型数据成员age，只能在当前类中被访问。
    private int age;

    // 定义了一个公共的方法setName，用于设置name的值，这里的void表示此方法没有返回值，String
    // name表示在调用此方法时需要传入一个字符串类型的参数。
    public void setName(String name) {
        // 在setName方法中将传入的参数值name赋值给Student类中的name数据成员。
        this.name = name;
    }

    // 定义了一个公共的方法setAge，用于设置age的值，这里的void表示此方法没有返回值，int age表示在调用此方法时需要传入一个整型参数。
    public void setAge(int age) {
        // 在setAge方法中将传入的参数值age赋值给Student类中的age数据成员。
        this.age = age;
    }

    // 定义了一个公共的方法getName，用于获取name的值，这里的String表示此方法的返回值为字符串类型。
    public String getName() {
        // 在getName方法中返回Student类中的name数据成员的值。
        return name;
    }

    // 定义了一个公共的方法getAge，用于获取age的值，这里的int表示此方法的返回值为整型。
    public int getAge() {
        // 在getAge方法中返回Student类中的age数据成员的值。
        return age;
    }

写一个学生类的测试代码

public class Student_test {
    public static void main(String[] args) {
        // 创建一个Student类的对象，这里使用了默认的构造方法来初始化对象。
        Student student = new Student();
        // 调用Student类中的setName方法设置学生的姓名为Tom。
        student.setName("Tom");
        // 调用Student类中的setAge方法设置学生的年龄为20。
        student.setAge(20);
        // 使用System.out.println方法输出学生的姓名，这里使用了+来连接字符串和方法返回值。
        System.out.println("Student name: " + student.getName());
        // 使用System.out.println方法输出学生的年龄，这里使用了+来连接字符串和方法返回值。
        System.out.println("Student age: " + student.getAge());
    }

结果
Student name: Tom
Student age: 20

赋值并输出DEMO2

private 后用set和get。在main主函数中，用对象名 名称 =new 对象的类（）

【1】用 名称.set成员变量（==写 想要赋的值==）进行赋值,
再用 数据类型 数据名称 = 名称.get成员变量（）
在输出sy.o.p(数据名称）

【2】或者用 名称.set成员变量（==写 想要赋的值==）进行赋值。
，直接输出sy.o.p(名称.get成员变量（））

总结如下：

（1）private关键字是一个权限修饰符，可以修饰成员(成员变量和成员方法)。被private修饰的成员只能在本类中才能访问
（2）针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作²

提供“setXxx(参数)”方法，用于给成员变量赋值，方法用public修饰
提供“getXxx()”方法，用于获取成员变量的值，方法用public修饰

（2）继承（Inheritance）：允许创建一个新类，该类从现有类继承属性和方法。这样可以减少代码的重复性，并使代码更易于维护。

继承(inheritance)是面向对象编程中的另一个重要概念。继承允许我们定义一个新的类，这个新类继承了原有类的属性和方法。在继承关系中，原有的类称为父类、基类或超类(super class)，新创建的类称为子类或派生类(derived class)。

子类可以继承父类的所有公共属性和方法，同时还可以自己定义新的属性和方法。继承允许我们通过重用代码来减少重复编写相似代码的工作量。此外，通过继承，我们可以更好地组织和设计程序结构，使代码更易于维护和扩展。

在Java中，使用extends关键字来声明一个类继承自另一个类。子类可以重写父类的方法，以实现自己的特定需求。此外，Java还支持多重继承，即一个子类可以同时继承多个父类(接口)的属性和方法。

继承与封装结合使用可以更好地实现面向对象编程的基本原则，即“开闭原则”和“单一职责原则”。开闭原则指的是一个软件实体(类、模块等)应该对扩展开放，对修改关闭。通过继承，我们可以通过扩展父类来实现新的功能，而不需要修改原有代码。单一职责原则指的是一个类应该只有一个责任。通过继承，我们可以组织代码结构，使每个类只负责自己的特定功能。

代码

这是一个Java类，名为Animal。

它有一个受保护的属性name，以及一个构造函数，用于初始化name属性。类中还有一个名为speak的方法，用于输出动物的发声。

package PLAYYYYY;

public class Animal {
    // 受保护的属性name
    protected String name;

    // 构造函数，用于初始化name属性
    public Animal(String name) {
        this.name = name;
    }

    // 动物发声的方法
    public void speak() {
        System.out.println("The animal speaks.");
    }
}

这是一个继承自Animal类的Cat类。

Cat类有一个构造函数，用于初始化它的name属性，它还有一个speak方法，用于输出猫的发声。在speak方法中，使用了name属性，输出猫的名字和它的叫声。

代码如下：

package PLAYYYYY;

// 继承自Animal类
class Cat extends Animal {
    public Cat(String name) {
        // 调用父类的构造函数，初始化name属性
        super(name);
    }

    // 猫的发声方法
    public void speak() {
        System.out.println(name + " says meow!");
    }
}

这是一个继承自Animal类的Dog类。

Dog类有一个构造函数，用于初始化它的name属性，它还有一个speak方法，用于输出狗的发声。在speak方法中，使用了name属性，输出狗的名字和它的叫声。

代码如下：

package PLAYYYYY;

// 继承自Animal类
class Dog extends Animal {
    public Dog(String name) {
        // 调用父类的构造函数，初始化name属性
        super(name);
    }

    // 狗的发声方法
    public void speak() {
        System.out.println(name + " says woof!");
    }
}

这是一个包含main方法的类，用于创建Animal、Dog和Cat对象，并调用它们的speak方法。

首先创建了一个名为"Generic Animal"的Animal对象，输出了"The animal speaks.“。然后创建了一个名为"Rufus"的Dog对象，输出了"Rufus says woof!”。最后创建了一个名为"Whiskers"的Cat对象，输出了"Whiskers says meow!"。

代码如下：

package PLAYYYYY;

public class Main {
    public static void main(String[] args) {
        // 创建Animal对象并调用它的speak方法
        Animal animal = new Animal("Generic Animal");
        animal.speak();

        // 创建Dog对象并调用它的speak方法
        Dog dog = new Dog("Rufus");
        dog.speak();

        // 创建Cat对象并调用它的speak方法
        Cat cat = new Cat("Whiskers");
        cat.speak();
    }
}

（3）多态（Polymorphism）：允许使用相同的方法来处理不同类型的对象。这样可以提高代码的可扩展性和可重用性。

多态(polymorphism)是面向对象编程中的另一个重要概念。它可以让不同的对象对同一消息做出不同的响应。这意味着，程序可以根据不同的对象来调用不同的方法，而不需要知道对象的具体类型。

在Java中，多态可以通过方法重载和方法覆盖来实现。方法重载是指在一个类中定义多个方法，方法名相同但参数列表不同。当程序调用这个方法时，Java会根据参数列表来确定具体调用哪个方法。方法覆盖是指子类重写父类的方法，以实现自己的特定需求。当程序调用这个方法时，Java会根据对象的实际类型来确定具体调用哪个方法。

多态的优势在于它可以提高代码的灵活性和可扩展性。通过多态，我们可以编写更加通用的代码，使程序更具有可重用性和可维护性。此外，多态还可以让程序员更好地面向抽象编程，从而更好地理解和设计复杂的程序系统。

总之，封装、继承和多态是面向对象编程中的三个基本概念。它们可以使程序更加易于理解、易于维护和易于扩展。在实际设计中，程序员应该根据具体需求灵活运用这些概念，以实现更好的代码质量和软件开发效率。

以下是关于C++、Python和Java的面向对象编程的介绍：

【1】优缺点

（1）C++：

== 优点：==

C++的运行速度非常快，适合需要高性能的应用程序。
C++提供了丰富的类库和数据结构，可以方便地处理底层的计算和操作。
可以直接操作内存，提供了更细致的控制。
缺点：

C++语法较为繁琐，需要更多的学习和经验积累。
由于可以直接操作内存，容易导致内存泄漏等问题。

（2）Python：

优点：

Python代码简洁易懂，易于学习和使用。
Python提供了丰富的类库和框架，可以快速创建各种应用程序。
Python支持高级编程概念，如装饰器和闭包，可以提高代码的灵活性和可重用性。
== 缺点：==

Python的运行速度相对较慢，不适合处理大量数据和高性能的计算。
Python的内存管理方式较为复杂，容易出现内存泄漏等问题。

（3）Java：

优点：

Java的运行速度相对较快，适合创建大型应用程序。
Java提供了强大的面向对象编程功能，支持多态、继承和封装等特性。
Java具有较好的跨平台性，可以在不同的操作系统上运行。
== 缺点：==

Java语法相对较为繁琐，需要更多的学习和经验积累。
Java应用程序需要依赖虚拟机来运行，可能会影响其运行效率。

【2】异同点：

C++和Java需要显式地进行内存管理，Python则支持自动内存管理。
Python和Java都支持动态类型，而C++需要在编译时确定类型。
C++和Java支持多线程编程，Python则支持协程（coroutine）编程。
C++和Java可以直接编写机器码，而Python需要先将代码解释成字节码再执行。

C++类的例子：

在C++中，我们可以通过定义类来创建自己的对象，并使用类中定义的方法来操作对象的属性。

#include <iostream>
using namespace std;

class Person {
private:
    string name;
    int age;

public:
    Person(string name, int age) {
        this->name = name;
        this->age = age;
    }

    void sayHello() {
        cout << "Hello, my name is " << this->name << " and I am " << this->age << " years old." << endl;
    }
};

int main() {
    Person person("Alice", 25);
    person.sayHello();
    return 0;
}

Python类的例子：

Python中的一切都是对象，包括数字、字符串、函数等等。我们可以通过定义类来创建自己的对象，并使用类中定义的方法来操作对象的属性。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sayHello(self):
        print("Hello, my name is " + self.name + " and I am " + str(self.age) + " years old.")

person = Person("Alice", 25)
person.sayHello()

Java类的例子：

在Java中，所有的数据类型都是对象，包括基本数据类型（如int、float等）和引用数据类型（如数组、字符串等）。Java中的类和对象的定义方式与Python类似

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void sayHello() {
        System.out.println("Hello, my name is " + this.name + " and I am " + this.age + " years old.");
    }
}

Person person = new Person("Alice", 25);
person.sayHello();

总之，C++、Python和Java都是一种强大的面向对象编程语言，它们同样支持封装、继承和多态这三个基本特征。
面向对象编程是一种强大的编程范式，它提供了一种更加模块化、可重用和易于维护的编程方式。面向对象编程是一种自然而然的编程方式，我们可以通过定义类来创建自己的对象，并使用类中定义的方法来操作对象的属性。

壹._. 类—>==类是描述了一组有相同特性（属性）和相同行为（方法）的一组对象的集合。==类是一种用户定义的数据类型，包含数据成员【类的属性】和方法成员【类的行为】。类定义了对象的属性和行为，而对象则表示了类的实例。

类是一种用户定义的数据类型，它包含数据成员和方法成员。

类是描述了一组有相同特性（属性）和相同行为（方法）的一组对象的集合。

Java的类是一种数据结构，对象是类的实例。【必须先设计类，才能获得对象。】它描述了一组具有相同特征和行为的对象。类定义了对象的属性和方法，对象是类的实例。
在Java中，类是一种封装机制，它提供了一种将数据和行为组合在一起的方式，以便将代码组织成逻辑单元。类在面向对象编程中起着至关重要的作用，它使得程序员能够将代码数据封装起来，从而更好地控制和管理应用程序的行为。

//public是访问修饰符，表示该类可以被其他类访问。ClassName是类的名称，遵循驼峰命名法。
public class ClassName {
//在类的主体中，可以定义字段、构造函数和方法。
   // Fields
   // Constructors
   // Methods
}

字段是类的属性，用于存储数据。在Java中，字段可以是任何数据类型，包括原始类型（如int和double）和引用类型（如String和Object）。以下是一个示例：

//Person类有两个字段：name和age。
public class Person {
   String name;
   int age;
}

构造函数是用于创建对象的特殊方法。在Java中，构造函数的名称必须与类的名称相同，并且没有返回类型。构造函数可以接受任意数量和类型的参数，并且可以执行任何必要的初始化操作。	

//Person类有一个构造函数，它接受两个参数：name和age。this关键字用于引用当前对象。
public class Person {
   String name;
   int age;

   public Person(String name, int age) {
      this.name = name;
      this.age = age;
   }
}

方法是类的行为，用于执行操作。在Java中，方法可以接受任意数量和类型的参数，并且可以返回任何类型的值。以下是一个示例：

//Person类有一个方法sayHello()，它打印出一个问候语，包括对象的名称和年龄。
public class Person {
   String name;
   int age;

   public Person(String name, int age) {
      this.name = name;
      this.age = age;
   }

   public void sayHello() {
      System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
   }
}

类是面向对象编程中的一个重要概念，它是一种用户自定义的数据类型，可以包含属性和方法。类可以看作是一种模板或蓝图，用于创建对象。

OOP的另一个原则会让用户自定义 Java 类变得更为容易，这就是: 可以通过扩展其他类来构建新类。事实上，Java 提供了一个“神通广大的超类”，名为 object。所有其他类都扩展自这个 object 类。

在Java中，定义一个类需要包含以下内容：类应始终以大写首字母开头，并且 java 文件的名称应与类名匹配。

类的访问修饰符（public、private、protected或默认）
类名，使用大驼峰命名法（例如，MyClass）
类的主体，用一对大括号括起来
类的成员，包括字段、方法、构造函数、嵌套类等

下面是一个简单的Java类的示例，其中包含了上述所有内容：

public class MyClass {
    // 字段
    private int myField;

    // 构造函数
    public MyClass(int myField) {
        this.myField = myField;
    }

    // 方法
    public int getMyField() {
        return myField;
    }

    // 嵌套类
    private static class MyNestedClass {
        // ...
    }
}

定义类的说明：类应始终以大写首字母开头，并且 java 文件的名称应与类名匹配。

（1）编写main方法的类，叫做测试类我们可以在测试类中创建javabean类的对象并进行赋值调用。
（2）用来描述一类事物的类，专业的Javabean类在Javabean类³中，是不写main方法的。

定义类的注意事项

public class 类名{
1、成员变量 (代表属性)
2、成员方法(代表行为)
}

（1）类名首字母建议大写，需要见名知意，驼峰模式
（2）一个Java文件中可以定义多个class类，且只能一个类是public修饰，而且public修饰的类名必须成为代码文件名。实际开发中建议还是一个文件定义一个class类
（3）成员变量的完整定义格式是: 修饰符 数据类型 变量名称 = 初始化值;【一般无需指定初始化值，存在默认值。】

在Java中，类的定义通常包括以下几个部分：

类的修饰符：类的修饰符可以是public、private、protected或默认（即没有修饰符）。这些修饰符控制了类的可见性和访问级别。
类的名称：类的名称应该以大写字母开头，遵循驼峰命名法。
父类：Java中的类可以继承另一个类，这个被继承的类称为父类或超类。继承可以使代码更加简洁和可重用。
实现的接口：Java中的类可以实现一个或多个接口，接口定义了一组方法，类必须实现这些方法。接口可以用于实现多态性和代码重用。
类的属性：类的属性是描述对象状态的变量。它们可以是基本类型（如int、double等）或对象类型（如String、Date等）。
类的方法：类的方法是描述对象行为的函数。它们可以是静态的或非静态的，可以有参数和返回值。

创建类 关键字new创建对象,调用对象的构造函数进行初始化。使用对象的方法和属性进行操作。

在Java中，定义一个类需要使用关键字class，并且需要指定类的名称。类的属性和方法都定义在类的大括号内部。由一个类构造(construct)对象的过程称为创建这个类的一个实例 (instance)。

一个完整的Java类的模板，其中包括属性和方法的定义。请注意，您可以根据需要更改类的修饰符（public，abstract或final），以及是否扩展另一个类或实现一个接口。

public abstract|final class <class_name> extends <class_name> implements <interface_name> {
    // 定义属性部分
    <property_type> <property1>;
    <property_type> <property2>;
    <property_type> <property3>;
    ...

    // 定义方法部分
    public void function1() {
        // 方法体
    }

    <access_modifier> <return_type> function2(<parameter_list>) {
        // 方法体
    }

    private <return_type> function3(<parameter_list>) {
        // 方法体
    }

    ...
}

下面是对代码模板的详细解释：

<class_name>：类的名称，您可以根据需要更改。
abstract|final：类的修饰符，可以是抽象类或者是最终类，您可以根据需要更改。
extends <class_name>：类的继承，如果需要继承另一个类，则可以使用此选项，并将<class_name>替换为要继承的类的名称。
implements <interface_name>：类的实现，如果需要实现一个或多个接口，则可以使用此选项，并将<interface_name>替换 要实现的接口的名称。
<property_type>：属性的类型，可以是任何Java数据类型，例如int，double，String等。
property，property2，property3：属性的名称，您可以根据需要更改。
function1()，function2()，function3()：方法的名称，您可以根据需要更改。
<access_modifier>：方法的访问修饰符，可以是public，private，protected或者不写，您可以根据需要更改。
<return_type>：方法的返回类型，可以是任何Java数据类型，例如int，double，String等。
<parameter_list>：方法的参数列表，如果方法需要参数，则可以在此处列出参数的类型和名称。

创建类的步骤

定义一个类的步骤如下：

1. 首先，确定类的名称和目的，通常是描述一个对象或一组相关的对象。
2. 然后，确定类的属性，即类的数据成员，这些属性通常反映了对象的状态。
3. 确定类的方法，即类的成员函数，这些方法通常反映了对象的行为。
4. 将属性和方法分组到类中，并使用访问修饰符设置它们的可见性和保护级别。
5. 编写类的构造函数和析构函数（如果需要的话），以及其他必要的函数。
6. 在程序中实例化该类的对象，并使用它们调用类的方法。
7. 在需要时，通过继承或实现接口来扩展类的功能。

[1]使用关键字“class”声明类的名称。

//类名应该以大写字母开头，遵循驼峰命名法
public class MyClass {
  // class body
}

[2]在类的花括号中编写类的属性和方法。

类的属性是指类的变量，而类的方法是指类的函数。属性和方法都可以是公共的，私有的或受保护的。
公共属性和方法可以从类的任何地方访问，而私有属性和方法只能从类内部访问。
受保护的属性和方法可以从类内部和子类中访问。

例如，为“Person”类添加一个名为“name”的属性和一个名为“sayHello”的方法，您可以这样写：

public class Person {
    String name;

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

【1】一个类包含的类型变量：

（1）实例变量（也称作成员变量）：作用域是整个类，可以被类中的任何方法或构造函数访问。

Java中实例变量是指属于类的实例（对象）的变量，也称为成员变量。它们在类中声明，但在方法以外。每个类的实例都有自己的一组实例变量，它们的值可以不同。
实例变量可以是任何基本数据类型（如int、float、double等）和任何引用类型（如字符串、数组等）。它们的值可以通过访问类的实例对象来设置或获取。

代码

假设我们有一个名为Person的类，它具有实例变量name和age，可以这样声明：

public class Person {
    String name; // 实例变量：姓名
    int age; // 实例变量：年龄
}

在这个例子中，name和age都是Person类的实例变量。它们被声明为String和int类型，因此每个Person对象都有自己的name和age值。
我们可以通过创建Person对象并设置其属性来使用这些实例变量：

Person person1 = new Person();
person1.name = "张三";
person1.age = 25;
Person person2 = new Person();
person2.name = "李四";
person2.age = 30;

在这个例子中，我们创建了两个Person对象person1和person2，并分别设置它们的name和age属性。这些属性是每个对象的实例变量，因此每个对象都有自己的name和age值。

（2）静态变量（也称作类变量）：作用域是整个类，可以通过类名来访问，也可以通过类的实例对象来访问。

Java中静态变量是指属于类而不是实例的变量，也称为类变量。它们在类中声明，但在方法以外，用static关键字修饰。每个类只有一组静态变量，无论创建多少实例，它们的值都是相同的。静态变量可以是任何基本数据类型（如int、float、double等）和任何引用类型（如字符串、数组等）。它们的值可以通过访问类本身来设置或获取。
静态变量的作用域是整个类，可以通过类名来访问，也可以通过类的实例对象来访问。它们通常用于表示类的共享状态，例如常量、计数器等，也可以用于缓存数据和单例模式的实现。

代码

我们可以在Person类中添加一个静态变量count，用于记录创建的Person对象数量：

public class Person {
    String name; // 实例变量：姓名
    int age; // 实例变量：年龄
    static int count; // 静态变量：对象数量
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        count++; // 每次创建对象时增加count的值
    }
}

在这个例子中，我们声明了一个静态变量count来记录Person对象数量。在构造函数中，每次创建对象时都会将count的值加1。这个静态变量可以通过类名来访问：

System.out.println(Person.count); // 输出对象数量

无论创建多少个Person对象，它们都共享同一个count变量，因此输出的结果是所有对象的数量之和。

注意事项

实例变量和静态变量是不同的，实例变量是属于每个实例的，它们的修改只会影响到当前实例，不会影响到其他实例。

静态变量和实例变量是Java中常用的两种变量类型，它们的区别如下：

1. 存储位置
   静态变量存储在方法区，实例变量存储在堆内存中。
2. 生命周期
   静态变量的生命周期与类相同，当类被加载时被初始化，当类被卸载时被销毁；实例变量的生命周期与对象相同，当对象创建时被初始化，当对象被垃圾回收时被销毁。
3. 访问方式
   静态变量可以通过类名直接访问，也可以通过对象进行访问；实例变量只能通过对象进行访问。
4. 初始值
   静态变量会被默认初始化为0或null，而实例变量不会被默认初始化，需要在对象创建时显式初始化。
5. 共享性
   静态变量是所有对象共享的，即多个对象访问同一个静态变量时，它们访问的是同一个变量；实例变量是每个对象独立的，即每个对象都有自己的实例变量副本。

（3）局部变量：

Java中局部变量是在方法、代码块或构造函数中声明的变量，只在声明它们的代码块中可见。局部变量的作用域只限于它们所在的代码块，超出该代码块的范围就不能访问它们了。局部变量必须在使用之前声明，并且必须初始化才能使用。
局部变量可以是任何基本数据类型（如int、float、double等）和任何引用类型（如字符串、数组等）。它们的值只在声明它们的代码块中有效，一旦超出该代码块的范围，它们的值就会被销毁。因此，局部变量通常用于临时存储数据，例如循环计数器、方法参数等。

代码

我们可以在一个方法中声明一个局部变量message，用于存储一条消息：

public void printMessage() {
    String message = "Hello, world!";
    System.out.println(message);
}

在这个例子中，我们声明了一个局部变量message来存储一条消息，并在方法中打印它。这个局部变量只在printMessage方法中可见，超出该方法的范围就不能访问它了。在方法中，我们可以随时修改局部变量的值，但在方法外部，它的值就不存在了。

总结三者

是的，Java中的变量可以分为三种类型：类变量、实例变量和局部变量。它们都可以在类中实现，但它们的作用域和生命周期不同，应该根据具体情况选择使用哪种类型的变量。

1. 类变量：也称为静态变量，是在类中声明的、被所有实例共享的变量。类变量可以通过类名直接访问，也可以通过对象访问。类变量的作用域是整个类，可以被类中的任何方法访问。类变量在类加载时被初始化，并在整个程序运行期间保留它们的值。类变量通常用于表示类的共享状态，例如常量、计数器等。
2. 实例变量：也称为成员变量，是在类中声明的、属于对象的变量。实例变量的作用域是整个对象，在对象创建时被初始化，并在对象被销毁时被销毁。实例变量可以被任何方法访问，但只能通过对象访问。实例变量通常用于表示对象的属性，例如姓名、年龄等。
3. 局部变量：是在方法、代码块或构造函数中声明的、只在声明它们的代码块中可见的变量。局部变量的作用域只限于它们所在的代码块，超出该代码块的范围就不能访问它们了。局部变量必须在使用之前声明，并且必须初始化才能使用。局部变量可以是任何基本数据类型和任何引用类型，通常用于临时存储数据。
   一般来说，应该尽量减少类变量的使用，因为它们会影响程序的可维护性和可测试性。实例变量和局部变量则应该根据具体情况来选择。如果一个变量只需要在一个方法中使用，那么应该使用局部变量；如果一个变量需要在整个类中使用，那么应该使用实例变量。

异同点是什么

三者的区别和相同点如下：
区别：

1. 作用域不同：类变量的作用域是整个类，实例变量的作用域是整个对象，而局部变量的作用域只限于它们所在的代码块。
2. 生命周期不同：类变量在类加载时被初始化，并在整个程序运行期间保留它们的值；实例变量在对象创建时被初始化，并在对象被销毁时被销毁；局部变量在声明时被初始化，并在所在的代码块执行完毕后被销毁。
3. 访问方式不同：类变量可以通过类名直接访问，也可以通过对象访问；实例变量只能通过对象访问；局部变量只能在声明它们的代码块中访问。
4. 使用场景不同：类变量通常用于表示类的共享状态，例如常量、计数器等；实例变量通常用于表示对象的属性，例如姓名、年龄等；局部变量通常用于临时存储数据，例如循环计数器、方法参数等。
   相同点：
5. 都是用于存储数据的变量。
6. 都可以在类中实现。
7. 都可以是任何基本数据类型和任何引用类型。
8. 都需要在使用之前声明，并且必须初始化才能使用。
   需要注意的是，类变量和实例变量都属于成员变量，而局部变量不属于成员变量。成员变量是属于类或对象的变量，它们的值可以被多个方法访问和修改，而局部变量只存在于方法中，不能被其他方法访问和修改。

在类中声明字段，可以使用访问修饰符（public、private、protected）和其他修饰符（static、final等），

类的属性和声明字段可以使用访问修饰符（public、private、protected）和其他修饰符（static、final等）来控制其可见性和可变性。

public：公共的，可以被任何类访问。
protected：受保护的，可以被同一包内的类和所有子类访问。
default：默认的，可以被同一包内的类访问。
private：私有的，只能被该类内部的方法访问。

访问修饰符用于控制类的成员的可见性。public修饰符表示该成员可以被任何类访问，private修饰符表示该成员只能被同一类中的其他成员访问，protected修饰符表示该成员可以被同一包中的其他类或子类访问。

其他修饰符用于控制类的成员的可变性。static修饰符表示该成员属于类本身而不是类的实例，final修饰符表示该成员的值不能被更改。
以下是一个示例类，其中包含使用不同访问修饰符和其他修饰符声明的属性和字段：

public class ExampleClass {
    public int publicInt;
    private String privateString;
    protected boolean protectedBoolean;
    static double staticDouble;
    final char finalChar = 'c';
}

在上面的示例中，publicInt属性可以从任何类中访问，privateString字段只能从ExampleClass类中的其他成员访问，protectedBoolean字段可以从同一包中的其他类或ExampleClass的子类中访问，staticDouble属性属于ExampleClass类本身而不是类的实例，finalChar字段的值不能被更改。

private关键字

对象代表什么，就得封装对应的数据，并提供数据对应的行为

是一个权限修饰符
可以修饰成员(成员变量和成员方法)
被private修饰的成员只能在本类中才能访问.

1.private关键字是一个权限修饰符
2.可以修饰成员(成员变量和成员方法
3被private修饰的成员只能在本类中才能访问
4.针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
5.提供“setXxx(参数)”方法，用于给成员变量赋值，方法用public修饰
6.提供“getXxx()”方法，用于获取成员变量的值，方法用public修饰

【2】编写类的方法。–>即类的成员函数⁴，这些方法通常反映了对象的行为。

public class Calculator {
    // 定义加法计算方法
    public int add(int a, int b) {
        return a + b;
    }
}

Calculator calculator = new Calculator();
int result = calculator.add(2, 3);
System.out.println(result);  // 输出5

实例化该类

例如，如果您想在另一个类中使用“Person”类，您可以这样写：

Person person = new Person();
person.name = "John";
person.sayHello();

这将创建一个名为“person”的对象，将其名称设置为“John”，并调用其“sayHello”方法。

注意事项

在声明Java类时需要注意的其他重要概念包括静态变量和方法、访问修饰符、包名、导入类、注释、对象创建、继承和多态、抽象类和接口、异常处理、内存管理以及编程约定和风格。

以下是Java中声明一个类需要做以下准备：

1. 定义类名：类名应该是一个有意义的名称，遵循驼峰命名法，并且必须以字母开头，不能以数字或其他特殊字符开头。

2. 继承关系：如果这个类是继承自其他类，需要使用关键字extends，后面跟着被继承的类名。如果没有继承关系，可以省略这个部分。

3. 实现接口：如果这个类需要实现某些接口，需要使用关键字implements，后面跟着接口名。如果没有实现任何接口，可以省略这个部分。

4. 成员变量：在类中定义成员变量，即类的属性。需要指定变量的类型和名称，可以设置访问修饰符和初始值。

5. 构造方法：构造方法用于创建对象并初始化对象的状态。需要指定方法名和参数列表，可以设置访问修饰符。

6. 成员方法：定义类的行为和功能，需要指定方法名和参数列表，可以设置访问修饰符和返回值类型。

7. 内部类：Java中允许在类中定义其他类，这些类称为内部类。需要使用关键字class定义内部类，并且内部类可以访问外部类的成员变量和方法。

   声明类的过程需要遵循Java的语法规则，代码需要放在类的大括号中。
   同时，类的声明应该符合Java的面向对象编程思想，即将数据和行为封装在一起，实现高内聚、低耦合的代码结构。
   

8. 静态变量和方法：可以使用关键字static声明静态变量和方法，它们属于类而不是实例。静态变量和方法可以通过类名直接访问，不需要先创建对象。

9. 访问修饰符：Java中有四种访问修饰符，分别是public、protected、default和private。需要根据需要设置合适的访问修饰符来控制类的成员的访问权限。

10. 包⁵名：为了避免命名冲突，Java中可以使用包来组织类。需要使用关键字package来声明包名，并且应该按照一定规则来命名包名。

11. 导入类：如果需要使用其他包中的类，可以使用关键字import导入类。需要指定类的完整路径，或者使用通配符来导入整个包下的所有类。

12. 注释：Java中可以使用注释来解释代码的作用，方便其他开发者理解和维护代码。可以使用//来注释单行，使用/* … */来注释多行。

13. 对象的创建：声明类后，可以通过关键字new来创建类的对象。需要指定类名和构造方法的参数列表，可以将对象赋值给变量以便后续操作。

14. 对象的访问：可以通过对象来访问类的成员变量和方法。需要使用点号(.)来访问对象的成员，也可以使用this关键字来引用当前对象。

15. 继承和多态：Java中支持类的继承和多态特性。子类可以继承父类的属性和方法，并且可以重写父类的方法实现多态。

16. 抽象类和接口：Java中可以使用抽象类和接口来定义规范和约束，实现代码的复用和扩展。

17. 异常处理：Java中可以使用异常处理机制来处理程序运行时可能出现的异常。需要使用try-catch-finally语句块来捕获和处理异常。

18. 内存管理：Java中使用垃圾回收机制自动管理内存，不需要手动进行内存释放。但是需要避免内存泄漏和过度使用内存的情况，提高程序的运行效率和稳定性。

19. 类的加载和执行：Java代码在运行时需要经过编译、类加载、类初始化、方法调用等多个阶段。需要了解Java虚拟机的工作原理，掌握类加载和执行的过程。

20. 编程规范和风格：Java有一套编程规范和风格，需要遵循这些规范和风格，以便提高代码的可读性和可维护性。可以参考Oracle官方的编码规范，或者遵循Google、Alibaba等著名公司的编码规范。

    以上是Java中声明一个类需要做的准备工作，需要遵循Java的语法规则和面向对象编程思想，同时遵循Java的命名规范，使用有意义的名称来表示类、方法和变量，提高代码的可读性和可维护性。

扩展知识点

类是描述了一组有相同特性（属性）和相同行为（方法）的一组对象的集合。

除了基本的类和对象知识点之外，Java还有许多扩展的面向对象编程概念，例如：

继承：继承是一种机制，它允许一个类继承另一个类的属性和方法。子类可以重写父类的方法，或者添加新的方法和属性。
多态性：多态性是一种机制，它允许不同的对象对同一个方法做出不同的响应。多态性可以通过继承和接口实现。
抽象类和接口：抽象类和接口是一种机制，它们可以用于定义一组方法，但是没有实现。抽象类可以包含实现的方法，而接口只能包含方法的签名。
内部类：内部类是定义在另一个类内部的类。它们可以访问外部类的属性和方法，并且可以用于实现封装和代码重用。

贰._. 对象—>可以通过创建类的实例来创建对象。

[ 1 ]创建

（1）如何得到类的对象类名 对象名 = new 类名();
（2）如何使用对象·访问属性: 对象名.成员变量 +访问行为: 对象名.方法名(...)

public class 类名 {
成员变量 (代表属性)
成员方法 (代表行为)
构造器 
代码块 
内部类 
}

[ 2 ]在面向对象编程中，对象是一个具有行为、状态和标识的实体。

（1）行为：对象的行为是指它可以执行的操作或方法。这些方法定义了对象的功能和行为。

对象的行为是指它可以执行的操作或方法。这些方法定义了对象的功能。在Java中，您可以定义一个类并在其中定义方法。例如，如果您有一个名为Car的类，则可以定义一个名为drive的方法，该方法将执行汽车的驾驶操作。以下是一个示例：

public class Car {
  public void drive() {
    // code to drive the car
  }
}

例如，在一个名为Car的类中，可能会有一个名为startEngine()的方法，该方法启动汽车的引擎。

（2）状态： 对象的状态是指它的属性或数据。这些属性描述了对象的当前状态

对象的状态是指它的属性或变量。这些属性定义了对象的当前状态。在Java中，您可以在类中定义变量。例如，如果您有一个名为Car的类，则可以定义一个名为color的变量，该变量将存储汽车的颜色。

public class Car {
  String color;
}

例如，在Car类中，可能会有一个名为speed的属性，该属性描述了汽车的当前速度。

（3）标识：对象的标识是指它在程序中的唯一标识符。这通常是通过对象的引用或内存地址来实现的

对象的标识是指它的唯一性。每个对象都有一个唯一的标识符，使其与其他对象区分开来。在Java中，每个对象都有一个唯一的引用。

Car car1 = new Car();
Car car2 = new Car();

例如，在程序中创建一个名为myCar的Car对象，可以使用myCar来引用该对象。
在上面的示例中，car1和car2是两个不同的对象，每个对象都有自己的唯一标识符。

代码

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void sayHello() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public int getAge() {
        return age;
    }
}

在这个示例中，Person类具有以下属性和方法：

name和age是Person对象的状态，它们描述了一个人的姓名和年龄。
sayHello()是Person对象的行为，它定义了一个人打招呼的方法。
setAge()和getAge()是Person对象的行为，它们定义了设置和获取一个人年龄的方法。
Person类本身是一个对象，它具有自己的标识符，可以通过类名来引用它。

结果

【1】补充说明

第12行是构造函数的结尾，因此它不需要接受参数。在构造函数中，使用“this”关键字来引用类的成员变量，以便将传递给构造函数的参数分配给它们。在这种情况下，“this.age”是将传递给构造函数的“age”参数分配给类的“age”成员变量。这样做是为了避免参数和成员变量之间的混淆。如果您不使用“this”关键字，那么编译器将无法区分参数和成员变量，并且可能会导致错误。因此，“this.age”和“age”之间没有区别，但是使用“this”关键字可以使代码更加清晰易懂。

【2】get+set

通过get和set方法，我们可以在类的外部访问和修改私有属性的值，同时也可以对属性的访问进行控制，保证属性的安全性。

针对于每一个私有化的成员变量，都要提供 get和set方
set方 给成员变量赋值
get方法: 对外提供成员变量的值

Java对象的set和get方法
在Java中，对象的set和get方法是用于访问对象的私有属性的公共方法。set方法用于设置属性的值，而get方法用于获取属性的值。

以下是一个示例类，其中包含一个私有属性name和对应的set和get方法：

public class Person {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }
}

在上面的示例中，setName方法用于设置name属性的值，而getName方法用于获取name属性的值。注意，这些方法都是公共方法，因此可以从类的外部访问它们。

使用set和get方法的好处是可以控制对对象属性的访问。例如，如果您希望在设置属性值之前对其进行验证，则可以在set方法中添加验证逻辑。同样，如果您希望在获取属性值之前对其进行转换，则可以在get方法中添加转换逻辑。

在Java中，get和set方法是用来获取和设置一个类的私有属性的方法。通常情况下，私有属性是不能被外部直接访问的，而是需要通过get和set方法来进行访问。

（1）get方法用来获取私有属性的值，通常有以下特点：由于其只返回实例字段的值，有被叫做字段访问器（field accessor）

• 方法名以get开头，后面跟上属性名，首字母大写。
• 返回值类型通常为属性的数据类型。
• 没有参数。
  示例代码：

public class Person {
    private String name;
    public String getName() {
        return name;
    }
}

getter方法用于获取对象的属性值，通常以get开头，例如：

public int getAge() {
    return this.age;
}

这个方法可以获取一个名为age的整数属性的值，并返回它。

（2）set方法用来设置私有属性的值，通常有以下特点：

• 方法名以set开头，后面跟上属性名，首字母大写。
• 返回值类型通常为void。
• 有一个参数，参数类型为属性的数据类型。
  示例代码：

public class Person {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
}

setter方法用于更改对象的属性值，通常以set开头，例如：

public void setName(String name) {
    this.name = name;
}

这个方法可以更改一个名为name的字符串属性的值。

这两个方法可以提高对象的封装性和安全性，使对象属性只能通过这两个方法访问和修改。这样的话，如果有需要，可以在方法内部添加一些逻辑代码，以控制对属性的访问和修改。

public void setAge(int age) {
    if (age < 0) {
        System.out.println("年龄不能小于0");
    } else {
        this.age = age;
    }
}

get和set为什么一个有void一个没有

在Java中，get和set方法通常用于访问和修改类的私有变量。get方法用于获取变量的值，而set方法用于设置变量的值。因此，get方法通常返回变量的值，而set方法通常不返回任何值（即void）。

这是因为get方法的目的是获取变量的值，而set方法的目的是设置变量的值。如果set方法返回一个值，那么它可能会导致混淆，因为它看起来像是获取变量的值，而实际上它是设置变量的值。

【3】this关键字（不可替代的） 不可在静态方法在使用，因为静态方法不属于任何对象，所以它们不能使用this关键字。

使用"this"关键字来引用成员变量。
例如："this.name"可以引用对象的"name"成员变量。

当方法参数和实例变量具有相同的名称时，使用this关键字来引用实例变量是必要的。这是因为Java编译器会优先选择方法参数，而不是实例变量。
在Java中，当您在一个类中定义一个变量或方法时，它们默认是与当前对象相关联的。这意味着每个对象都有自己的一组实例变量和方法。当您创建一个新对象时，Java会为该对象分配一组新的实例变量和方法。因此，如果您在一个类中定义一个变量或方法，它们将与该类的每个对象相关联。

• 如果您在一个静态方法中使用this关键字，编译器将会报错。 因为静态方法不属于任何对象，所以它们不能使用this关键字。

//this关键字用于引用当前对象的实例变量x：

public class MyClass {
    int x;

    public void setX(int x) {
        this.x = x;
    }
}
//setX方法将传递的参数x分配给当前对象的实例变量x。由于方法参数和实例变量具有相同的名称，因此使用this关键字来引用实例变量是必要的。

• 此外，this关键字还可以用于调用当前对象的其他方法

public class MyClass {
    int x;

    public void printX() {
        System.out.println(this.x);
    }
}
//printX方法使用this关键字来引用当前对象的实例变量x，并将其打印到控制台上。

在 Java 中，类的成员变量和方法都可以被同一类中的其他方法访问。这是因为它们都属于同一个类，因此它们共享相同的作用域。
如果您将 printX() 方法定义为 static，则不能在内部访问 x 变量，因为 static 方法不能访问非静态成员变量。如果您想在 static 方法中访问 x 变量，则需要将 x 变量定义为 static。
演示如何在 static 方法中访问 static 变量：

public class MyClass {
    static int x;

    public static void printX() {
        System.out.println(x);
    }
}

（1）就近原则【this可以区别成员变量和局部变量】

Java的就近原则（nearest-neighbor rule）是指在进行方法重载（overloading）时，当参数类型不完全匹配时，会选择跟实参最为接近（nearest）的一个方法进行调用。

就近原则在Java中适用于方法重载的场景。当存在多个重载方法时，编译器会根据参数的类型和数量选择调用哪个方法。如果参数类型不完全匹配，则编译器会自动将参数类型转换为最接近的类型，然后再选择调用哪个方法。

举个例子，如果存在以下两个方法：

public void foo(int a) {
    System.out.println("int");
}

public void foo(float a) {
    System.out.println("float");
}

那么当我们调用foo(3.5)时，编译器会自动将参数类型转换为最接近的类型，即调用foo(float a)方法。

总之，Java的就近原则会自动寻找最接近的匹配来执行方法，提高了程序的灵活性和可读性。

特殊的

当一个类中有成员变量。和局部变量重名的时候，如果是直接调用局部变量那就是输出局部变量的值。
如果是输出this.变量名称的话，就是在输出成员变量。

为什么age的局部变量会直接覆盖引用的age赋值的123

根据你提供的代码，我看到在Person3类中有一个静态变量age和一个构造函数，构造函数中有一个参数age。在构造函数中，你使用了this.name = name来引用类中的成员变量name，但是你没有使用this.age = age来引用类中的静态变量age。因此，当你在sayHello()方法中声明一个名为age的局部变量时，它会覆盖静态变量age的值。如果你想引用静态变量age，你应该使用Person3.age而不是声明一个局部变量。

如果你想在构造函数中引用静态变量age，你可以使用Person3.age或者直接使用age，因为它们都引用了静态变量age。但是，我建议你使用Person3.age，因为它更清晰地表明你正在引用静态变量。

（2）动态VS静态实例

在动态实例中，this关键字指向当前正在使用该方法的对象。例如：

public class MyClass {
    private int num;

    public void setNum(int num) {
        this.num = num; // 使用this关键字指向当前对象的num属性
    }
}

MyClass obj = new MyClass();
obj.setNum(10); // 调用setNum方法，并传入10作为参数

在静态实例中，this关键字无法使用。因为静态方法不依赖于任何对象，它们与类一起加载，并且只能访问静态成员和方法。例如：

public class MyClass {
    private static int num;

    public static void setNum(int num) {
        MyClass.num = num; // 直接使用类名引用静态属性
    }
}

MyClass.setNum(10); // 调用setNum方法，并传入10作为参数

（3）私有和共有

Java中的this关键字代表当前对象，不论该对象是私有还是共有。

在私有方法和私有属性中，this关键字用于引用当前对象的私有属性和方法。例如：

public class Person {
   private String name;

   public void setName(String name) {
     this.name = name; //使用this引用当前对象的私有属性
   }

   private void printName() {
     System.out.println("My name is " + this.name); //使用this引用当前对象的私有方法
   }
}

在公有方法和公有属性中，this关键字也可以用于引用当前对象的公有属性和方法，但通常情况下可以省略this关键字。例如：

public class Person {
   public String name;

   public void printName() {
     System.out.println("My name is " + name); //直接引用公有属性，省略this关键字
   }
}

（4）inscode

Java中的this关键字是一个特殊的引用，它指向当前对象的内存地址。在Java中，每个对象都有自己独立的内存空间，this关键字可以让我们在对象内部访问自身的属性和方法。在Java中使用this关键字的语法如下：

1. 使用this关键字访问当前对象的属性：

public class Person {
    private String name;

    public void setName(String name) {
        this.name = name;
    }
}

2. 使用this关键字调用当前对象的方法：

public class Person {
    public void sayHello() {
        System.out.println("Hello, my name is " + this.getName());
    }
}

3. 在构造函数中使用this关键字调用当前对象的其他构造函数：

public class Person {
    private String name;
    private int age;

    public Person() {
        this("", 0); // 调用另一个构造函数
    }

    public Person(String name) {
        this(name, 0); // 调用另一个构造函数
    }

    public Person(int age) {
        this("", age); // 调用另一个构造函数
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
```Java中的this关键字是一个特殊的引用，它指向当前对象的内存地址。在Java中，每个对象都有自己独立的内存空间，this关键字可以让我们在对象内部访问自身的属性和方法。在Java中使用this关键字的语法如下：

1. 使用this关键字访问当前对象的属性：

```java
public class Person {
    private String name;

    public void setName(String name) {
        this.name = name;
    }
}

2. 使用this关键字调用当前对象的方法：

public class Person {
    public void sayHello() {
        System.out.println("Hello, my name is " + this.getName());
    }
}

3. 在构造函数中使用this关键字调用当前对象的其他构造函数：

public class Person {
    private String name;
    private int age;

    public Person() {
        this("", 0); // 调用另一个构造函数
    }

    public Person(String name) {
        this(name, 0); // 调用另一个构造函数
    }

    public Person(int age) {
        this("", age); // 调用另一个构造函数
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

无需this指示隐式字段

package work629;

public class BOOK {
    private String author;
    private String title;
    
    public BOOK() {
    }

    public BOOK(String author1, String title) {
        author1 = author;
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author1) {
        author = author1;
    }

    public String getTitle() {
        return this.title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public void showDisplayBook() {
        System.out.println("Author: " + author);
        System.out.println("Title: " + this.title);
    }
}

注意事项

（1）实例化对象：要使用一个类，您需要先创建该类的一个实例。您可以使用new关键字来实例化一个对象，如下所示：Person3 person = new Person3("Alice", 25);这将创建一个名为person的Person3对象其名称为"Alice"年龄为25岁。
（2）访问对象的属性：要访问对象的属性，您可以使用点号.运算符。如下所示：String name = person.name;
int age = person.age;这将分别将person对象的名称和年龄存储在name和age变量中。
（3）调用对象的方法：要调用对象的方法，您可以使用点号.运算符，后跟方法名称和括号，如下所示：person.sayHello();这将调用person对象的sayHello()方法，该方法将打印出该对象的名称和年龄。
（4）理解对象的生命周期：对象的生命周期是指对象从创建到销毁的整个过程。在Java中，对象的生命周期由垃圾回收器管理。当对象不再被引用时，垃圾回收器将自动销毁该对象。

[ 3 ]总结

Java的类和对象是Java编程中的重要概念。类是一种模板或蓝图，用于创建对象。对象是类的实例，具有状态和行为。要创建类，您需要使用关键字“class”后跟类名，并在类中定义变量和方法。要创建对象，您需要使用关键字“new”后跟类名，并将其分配给变量。要访问对象的变量或方法，您需要使用点号（.）后跟变量或方法名称。、

this关键字使用上要注意

package work629;

public class BOOK {
    private static String author;
    private String title;
    private double price;
    private String publisher;
    private int publishedYear;

    public BOOK() {
    }

    public BOOK(String author, String title, double price, String publisher, int publishedYear) {
        BOOK.author = author;
        this.title = title;
        this.price = price;
        this.publisher = publisher;
        this.publishedYear = publishedYear;
    }

    public String getAuthor() {
        return BOOK.author;
    }

    public void setAuthor(String author) {
        BOOK.author = author;
    }

    public String getTitle() {
        return this.title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public double getPrice() {
        return this.price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getPublisher() {
        return this.publisher;
    }

    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }

    public int getPublishedYear() {
        return this.publishedYear;
    }

    public void setPublishedYear(int publishedYear) {
        this.publishedYear = publishedYear;
    }

    public static void showDisplayBook() {
        System.out.println("Author: " + BOOK.author);
        System.out.println("Title: " + this.title);
        System.out.println("Price: " + this.price);
        System.out.println("Publisher: " + this.publisher);
        System.out.println("Published Year: " + this.publishedYear);
    }

}

解决方案一：将成员变量改为静态变量

package work629;

public class BOOK {
    private static String author;
    private static String title;
    private static double price;
    private static String publisher;
    private static int publishedYear;

    // 省略其他代码...
    
    public static void showDisplayBook() {
        System.out.println("Author: " + BOOK.author);
        System.out.println("Title: " + BOOK.title);
        System.out.println("Price: " + BOOK.price);
        System.out.println("Publisher: " + BOOK.publisher);
        System.out.println("Published Year: " + BOOK.publishedYear);
    }
}

解决方案二：将showDisplayBook方法改为非静态方法

package work629;

public class BOOK {
    private static String author;
    private String title;
    private double price;
    private String publisher;
    private int publishedYear;

    // 省略其他代码...
    
    public void showDisplayBook() {
        System.out.println("Author: " + BOOK.author);
        System.out.println("Title: " + this.title);
        System.out.println("Price: " + this.price);
        System.out.println("Publisher: " + this.publisher);
        System.out.println("Published Year: " + this.publishedYear);
    }
}

在Java中，静态方法无法访问非静态成员变量，因此在showDisplayBook方法中，无法直接访问this.title，this.price，this.publisher和this.publishedYear。

解决的问题

BOOK类

package work629;

public class BOOK {
    static String author;
    // private String title;
    // private double price;
    // private String publisher;
    // private int publishedYear;

    // 省略其他代码...

    public void showDisplayBook() {
        // System.out.println("Author: " + BOOK.author);
        // System.out.println("Title: " + this.title);
        // System.out.println("Price: " + this.price);
        // System.out.println("Publisher: " + this.publisher);
        // System.out.println("Published Year: " + this.publishedYear);
    }
}

BOOKTest测试类

package work629;

public class BOOKTest {
    public static void main(String[] args) {
        // BOOK book1 = new BOOK();
        // BOOK book2 = new BOOK();
        System.out.println("作者" + BOOK.author);
        BOOK.author = "Author Name";
        System.out.println(BOOK.author);
        // " 书名" + book1.getTitle() + " 价格" + book1.getPrice() + " 出版社"
        // + book1.getPublisher() + " 出版年间" + book1.getPublishedYear());

        // book1.showDisplayBook();
    }
}

为什么私有的就得用对象来调用author，静态的是用的是对象还是方法调用的

私有成员变量需要使用对象来调用是因为私有成员变量只能在类的内部访问，无法在类的外部直接访问。因此，如果你想在类的外部访问私有成员变量，你需要通过对象来调用。

静态成员变量可以通过类名直接访问，而不需要创建对象。这是因为静态成员变量属于类本身，而不是类的实例。因此，你可以通过类名来访问静态成员变量。

对于静态方法，你可以通过类名或对象来调用。如果你使用类名调用静态方法，它会直接在类上执行。如果你使用对象调用静态方法，它会在对象上执行，但实际上会忽略对象并在类上执行。