类是一种定义代码的结构，包含属性和方法的模板,用于描述代码中的对象。
类可以看作是一个模板或者蓝图，它定义了对象的属性和方法。
类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
类的组成是由属性和行为两部分组成
一个类通常由以下部分组成：
类名应符合Java编码规范，通常以大写字母开头。
例如，定义一个类名为`Car`的类：
`public class Car {}`
成员变量的定义通常放置在类的开头部分，可以添加修饰符（如public、private、protected等），用于控制变量的访问权限。
例如，定义一个Car类，包含品牌和颜色两个成员变量：
`public class Car { private String brand; private String color; }`
方法通常用于操作类中的数据（成员变量），为成员变量赋值或取值，并将结果返回。方法也可以添加修饰符（如public、private、protected等），用于控制方法的访问权限。
例如，定义一个`Car`类，包含加速和刹车两个方法：
public class Car {
private String brand;
private String color;
private int speed;
public void accelerate(int increment) {
speed += increment;
}
public void brake(int decrement) {
speed -= decrement;
}
}
在这个例子中，`accelerate()`和`brake()`是方法，它们用于加速和刹车操作。
`brand`、`color`和`speed`是成员变量，用于描述车辆的品牌、颜色和速度。
类的定义步骤：
public class 类名 {
// 成员变量
变量1的数据类型 变量1；
变量2的数据类型 变量2;
…
// 成员方法
方法1;
方法2;
}
例如：
/*
手机类：
类名：
手机(Phone)
成员变量：
品牌(brand)
价格(price)
成员方法：
打电话(call)
发短信(sendMessage)
*/
public class Phone {
//成员变量
String brand;
int price;
//成员方法
public void call() {
System.out.println("打电话");
}
public void sendMessage() {
System.out.println("发短信");
}
}
对象是类的实例，存储在内存中,它是类定义的抽象描述在内存中的实际具体化的一个个体。
我们通过实例化（即创建）类来创建对象。
使用new关键字来创建一个类的对象。
类名 对象名 = new 类名();
例如，创建一个Car对象：
Car myCar = new Car();
这行代码创建了一个`Car`类的对象，并将其赋给变量`myCar`。
当执行该语句时，将会向操作系统请求一块内存空间，该空间用于存储新创建的`Car`对象。
完成创建后，系统会返回指向该对象的引用（地址），并将其存储在变量`myCar`中。
示例代码：
/*
创建对象
格式：类名 对象名 = new 类名();
范例：Phone p = new Phone();
使用对象
1：使用成员变量
格式：对象名.变量名
范例：p.brand
2：使用成员方法
格式：对象名.方法名()
范例：p.call()
*/
public class HuaWeiPhone{
public static void main(String[] args) {
//创建对象
Phone p = new Phone();
//使用成员变量
System.out.println(p.brand);
System.out.println(p.price);
p.brand = "华为";
p.price = 3999;
System.out.println(p.brand);
System.out.println(p.price);
//使用成员方法
p.call();
p.sendMessage();
}
}
例如，可以使用.（点）操作符来获取或修改对象的属性或调用对象的方法。
myCar.accelerate(10); // 将车速增加10
在这个例子中，我们使用myCar.accelerate(10)调用Car类中的accelerate()方法，并将参数10传递给该方法。这个方法将把车速增加10。
在Java中，变量可以分为成员变量和局部变量。
成员变量是定义在类中，方法之外的变量。
它们的生命周期和对象一样长，并且可以被类中的所有方法访问，因此也称作“对象属性”。
成员变量需要使用访问修饰符来修饰其可见性。
通常，成员变量也需要初始化，否则将默认为其类型的默认值（例如，数值类型默认为0，布尔类型默认为false，对象类型默认为null）。
下面是一个示例：
public class Person {
private String name; // 私有成员变量，只能在类中访问
public int age; // 公有成员变量，可以在类外部访问
// 构造函数，初始化成员变量
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 对象方法，访问和修改成员变量
public void sayHello() {
System.out.println("My name is " + name + ", and I am " + age + " years old.");
}
}
在这个例子中，Person类有两个成员变量：name和age。name被声明为私有的，只能在类内部访问和修改，而age被声明为公有的，可以在类外部访问和修改。Person类还包含一个构造函数，用于初始化这两个成员变量。
局部变量是在方法或代码块中定义的变量，只有在它们的作用域内访问和使用它们。
它们的生命周期只在方法或代码块中，在方法或代码块的结束时它们会被销毁。
局部变量不需要使用访问修饰符来管理可见性。
下面是一个示例：
public void calculate() {
int x = 5; // 局部变量
int y = 10; // 局部变量
int z = x * y; // 局部变量，计算结果
System.out.println("The result is " + z);
}
在这个例子中，calculate()方法有三个局部变量：x、y和z。它们只能在calculate()方法内访问和使用。z变量是这两个局部变量的乘积，它存储了计算的结果，并在打印出来后就被销毁了。
成员变量和局部变量是两种在Java中使用的变量类型，它们具有以下几个主要区别：
位置和作用域：
生命周期：
默认值：
访问修饰符：
public、private等，来控制它们的可见性和访问权限。存储位置：
下面是一个综合示例，展示了成员变量和局部变量的不同用法：
public class Example {
private int x; // 成员变量
private int y; // 成员变量
public void setX(int x) {
this.x = x; // 为成员变量x赋值
}
public void calculate() {
int z = x * y; // 计算结果存储在局部变量z中
System.out.println("The result is " + z);
}
public static void main(String[] args) {
Example example = new Example();
example.setX(5);
example.y = 10; // 直接为成员变量赋值
example.calculate(); // 计算结果并打印
}
}
在这个例子中，Example类有两个成员变量x和y，以及一个setX()方法用于设置成员变量x的值。calculate()方法定义了一个局部变量z，用于存储x和y的乘积结果。在main()方法中，我们创建了Example类的一个新实例，为成员变量x设置了值，直接为成员变量y赋值，然后调用calculate()方法来计算结果并打印。
在Java中，this关键字是一个引用，它指向当前对象，即正在执行方法的对象。
当我们使用this关键字时，它通常用于以下情况中：
this关键字，使编译器就能知道引用哪一个变量了。例如：
public class Example {
private String name;
public void setName(String name) {
this.name = name; // 使用 this 来区分成员变量和方法参数
}
}
在上面的代码中，变量name既是成员变量，也是方法setName()的参数。使用this可以将该方法的参数与成员变量区分开来。
this关键字来调用其他的构造器。这可以避免代码重复，同时确保所有构造器都执行到相同的初始化步骤。例如：
public class Example {
private String name;
public Example() {
this("John Doe"); // 调用带参构造器
}
public Example(String name) {
this.name = name;
}
}
在上面的代码中，我们定义了两个构造器，一个是默认构造器，另一个是带有一个参数的构造器。通过使用this关键字来调用另一个构造器，我们只需要在一个构造器中执行初始化步骤即可。
this关键字。（链式编程中很常见）例如：
public class Example {
private int count;
public Example increment() {
count++;
return this; // 返回当前对象
}
public int getCount() {
return count;
}
}
在上面的代码中，方法increment()返回当前对象的引用。这意味着可以使用链式语法来执行多次调用。
在Java中，构造方法是一种特殊的方法，用于创建和初始化对象。它们具有与类名相同的名称，并且没有返回类型。
格式：
public class 类名{
修饰符 类名( 参数 ) {
}
}
功能：主要是完成对象数据的初始化
示例代码：
class Student {
private String name;
private int age;
//构造方法
public Student() {
System.out.println("无参构造方法");
}
public void show() {
System.out.println(name + "," + age);
}
}
/*
测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
s.show();
}
}
Java中的构造方法有以下特点：
void。this关键字来调用本类的另一个构造方法，使用super关键字来调用父类的构造方法。如果没有定义构造方法，系统将给出一个默认的无参数构造方法
如果定义了构造方法，系统将不再提供默认的构造方法
示例代码：
public class Person {
private String name;
private int age;
public Person() {
// 默认构造方法
}
public Person(String name) {
this.name = name;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 使用this关键字调用另一个构造方法
public Person(int age) {
this("Unknown", age);
}
// 使用super关键字调用父类的构造方法
public Student(String name, int age, String school) {
super(name, age);
this.school = school;
}
}
JavaBean是一种符合特定规范的Java类，用于在Java中表示一些特定实体。
JavaBean类包含一些私有的成员变量、公共的getter/setter方法和零个或多个构造函数。
标准的JavaBean类需要满足以下要求：
私有的成员变量：JavaBean类中的成员变量必须是私有的，以确保对数据的封装性。
公共的getter/setter方法：JavaBean类中必须定义公共的getter/setter方法，以便外部访问成员变量。这些方法应该遵循标准的命名规范。
无参数的构造函数：JavaBean类必须提供一个无参数的构造函数，以便在使用某些框架（如Java标准的JavaBeans框架）时能够正确地初始化JavaBean对象。
可以包含其他有参构造函数：JavaBean类可以包含其他有参数的构造函数，但必须同时提供无参数的构造函数。
遵循JavaBean命名规范：JavaBean类的名称应该遵循JavaBean约定，即类名是一个或多个单词，每个单词的第一个字母大写，并且不包含下划线。例如，Person、Order等类名是合法的JavaBean类名，而person、Order_detail等则不是。