面向对象内容的三条主线
Java类及类的成员: (重点)属性、方法、构造器; （熟悉)代码块、内部类。
面向对象的特征：封装、继承、多态、（抽象）
其他关键字的使用：this、 super、 package、 import、 static、 final、 interface、abstract等
面向对象完成具体功能的操作三步流程
步骤1：创建类，并设计类的内部成员（属性、方法）
步骤2：创建类的对象。比如：Phone phone = new Phone();
步骤3：通过对象，调用其内部声明的属性或方法，完成相关的功能。
面向对象的概述及两大要素：类与对象
面向对象编程（Object-Oriented Programming，简称OOP）是一种程序设计思想，它将现实世界中的事物抽象成对象，并通过对象之间的交互来实现程序的功能。面向对象编程具有封装、继承和多态三大特性。
面向对象编程的两大要素是类和对象。
1. 类
类是面向对象编程中的基本概念，它是一种抽象的概念，用来描述一类具有相同属性和行为的对象。类包括属性和方法两个部分。
属性：类的属性用来描述对象的特征，例如人类的属性可以包括姓名、年龄、性别等。
该类事物的状态信息。对应类中的 成员变量
成员变量<=> 属性<=> Field
方法：类的方法用来描述对象的行为，例如人类的方法可以包括走路、说话、吃饭等。
该类事物要做什么操作，或者基于事物的状态能做什么。对应类中的 成员方法
(成员)方法<=>函数 => Method
//定义一个Phone类
public class Phone {
//定义属性：品牌和价格
String brand; //品牌
Double price; //价格
//定义方法：打电话和发送信息
public void call(){ //打电话
System.out.println("手机能够拨打电话~~~");
}
public void sendMessage(){ //发送信息
System.out.println("手机可以发送信息~~~");
}
}
// 定义一个测试类，类名为PhoneText
public class PhoneText {
// 定义该类的主方法
public static void main(String[] args) {
// 创建一个名为phone的Phone对象
Phone phone = new Phone();
//通过Phone的对象，调用其内部声明的属性或方法
//格式：“对象.属性”或“对象.方法”
// 给phone对象的brand属性赋值为"华为"
phone.brand = "华为";
// 给phone对象的price属性赋值为3999.0
phone.price = 3999.0;
// 打印输出phone对象的brand属性和price属性
System.out.println(phone.brand + "--" +phone.price);
// 调用phone对象的call方法
phone.call();
// 调用phone对象的sendMessage方法
phone.sendMessage();
}
}
2. 对象
对象是类的实例化，是具体的一个实体，它拥有类的所有属性和方法。例如，一个人类的对象可以是小明、小红等。
总之，面向对象编程是一种强大的编程思想，它可以使程序更加模块化、易于维护和扩展。类和对象是面向对象编程的两大要素，它们是实现面向对象编程的基础。
类的实例化与对象的内存解析
类的实例化是指根据类的定义创建一个对象的过程。Java中使用关键字new来实例化一个类，如下所示：
类名 对象名 = new 类名();
其中，类名是要实例化的类的名称，对象名是新创建的对象的名称。new关键字用于创建一个新的对象，并返回该对象的引用，赋值给对象名变量。
对象的内存解析是指在Java虚拟机中，对象在内存中的分配和存储方式。Java中的对象都是存储在堆内存中的，每个对象都有一个唯一的地址（引用），可以通过对象名来访问对象。
对象在内存中的存储方式包括两个方面：对象头和实例数据。
对象头包括对象的标识、类型、状态和锁等信息。实例数据包括对象的属性和方法等信息。对象的属性和方法都是存储在对象的实例数据中的。
在Java中，每个对象都有一个默认的构造函数，如果没有定义构造函数，则使用默认的构造函数创建对象。如果定义了构造函数，则必须使用构造函数来创建对象。构造函数用于初始化对象的属性和方法等信息。
总之，类的实例化是创建一个对象的过程，而对象的内存解析是对象在内存中的存储方式。在Java中，对象都是存储在堆内存中的，每个对象都有一个唯一的地址（引用），可以通过对象名来访问对象。
成员变量与局部变量的对比及练习
成员变量和局部变量都是Java中的变量，但它们有一些不同点。
1. 定义位置不同：成员变量定义在类中，方法外；局部变量定义在方法中，或者方法的代码块中。
2. 作用域不同：成员变量的作用域是整个类，可以被类中的任何方法访问；而局部变量的作用域只限于定义它的方法或代码块中。
3. 初始化不同：成员变量有默认值，可以不进行初始化；而局部变量必须在使用前进行初始化。
4. 生命周期不同：成员变量的生命周期与对象的生命周期相同，当对象被销毁时，成员变量也被销毁；而局部变量的生命周期只在方法或代码块执行期间存在，执行完毕后就被销毁。
下面是一个成员变量和局部变量的对比练习：
public class VariableDemo {
// 成员变量
private int memberVar = 10;
public void method() {
// 局部变量
int localVar = 20;
System.out.println("成员变量的值：" + memberVar);
System.out.println("局部变量的值：" + localVar);
}
public static void main(String[] args) {
VariableDemo demo = new VariableDemo();
demo.method();
}
}
在上面的代码中，我们定义了一个成员变量`memberVar`和一个方法`method`，在方法中定义了一个局部变量`localVar`。在`method`方法中，我们分别输出了成员变量和局部变量的值。在`main`方法中，我们创建了一个`VariableDemo`对象，并调用了`method`方法。
运行程序，输出结果如下：
成员变量的值：10 局部变量的值：20
可以看到，成员变量和局部变量的值分别输出了。这说明成员变量和局部变量虽然都是变量，但是它们的作用和用法是不同的。在实际编程中，需要根据具体情况选择使用成员变量或局部变量。
方法的作用与方法的声明
方法的作用：
方法是一段可重复使用的代码，可以接受输入参数并返回结果。方法的作用是将代码分解成小块，使程序更易于理解和维护。通过使用方法，可以避免在程序中重复编写相同的代码。方法还可以使代码更加模块化，使得不同的部分可以独立开发和测试。
方法的声明：
方法的声明包括方法名、参数列表、返回类型和方法体。方法名是用来标识方法的唯一名称。参数列表是一组用逗号分隔的参数，用于传递给方法的输入数据。返回类型是方法返回的值的类型。方法体是包含在花括号中的代码块，用于执行方法的操作。
方法的练习：
下面是一个简单的Java方法的练习，该方法接受两个整数作为参数，并返回它们的和。
public class Calculator {
public static int add(int a, int b) {
return a + b;
}
public static void main(String[] args) {
int result = add(2, 3);
System.out.println("2 + 3 = " + result);
}
}
在这个例子中，我们定义了一个名为“add”的静态方法，它接受两个整数作为参数，并返回它们的和。在main方法中，我们调用了add方法，并将结果保存在一个变量中，然后使用System.out.println方法打印结果。运行程序时，输出应该是“2 + 3 = 5”。
一个方法的声明示例，以及各个部分的含义如下：
public int add(int a, int b) {
int sum = a + b;
return sum;
}
其中，各个部分的含义如下：
- `public`：表示该方法是公有的，可以被其他类访问。
- `int`：表示该方法返回一个整型值。
- `add`：表示该方法的名称。
- `(int a, int b)`：表示该方法的参数列表，其中 `a` 和 `b` 分别是两个整型参数。
- `{}`：表示该方法的方法体，即实现该方法的代码块。
- `int sum = a + b;`：表示该方法的具体实现，将两个整型参数相加并赋值给 `sum`。
- `return sum;`：表示该方法将 `sum` 作为返回值返回。
方法的调用过程以及方法中的局部变量在内存中的存储方式：
方法的调用过程分为两个阶段：方法的声明和方法的调用。方法的声明是在类中定义方法的过程，而方法的调用是在程序中调用已经声明的方法的过程。
在方法中定义的局部变量在方法调用时会在栈内存中分配一段空间，当方法调用结束后，这段空间会被释放。因此，局部变量的生命周期仅限于方法的执行期间，并且局部变量的值只在方法内部有效。
属性与方法的整体练习及代码实现
以下是一个简单的Java类，包含属性和方法的定义：
public class Person {
private String name;
private int age;
private String gender;
public Person(String name, int age, String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public void sayHello() {
System.out.println("Hello, my name is " + name);
}
public void introduce() {
System.out.println("My name is " + name + ", I am " + age + " years old, and I am a " + gender);
}
}
这个类定义了一个Person对象，包含了三个属性：name、age和gender。它还定义了一个构造函数，用于初始化这些属性。同时，它还定义了一些方法，包括：
- getName()和setName()：用于获取和设置name属性的值。
- getAge()和setAge()：用于获取和设置age属性的值。
- getGender()和setGender()：用于获取和设置gender属性的值。
- sayHello()：用于输出一个简单的问候语，包含对象的name属性。
- introduce()：用于输出一个详细的自我介绍，包含对象的name、age和gender属性。
这个类可以通过以下代码进行测试：
public class Main {
public static void main(String[] args) {
Person person = new Person("Alice", 20, "female");
person.sayHello();
person.introduce();
}
}
这个代码会创建一个Person对象，设置它的属性，并调用它的sayHello()和introduce()方法进行输出。输出结果如下：
Hello, my name is Alice
My name is Alice, I am 20 years old, and I am a female
对象数组的使用
1. 对象数组的使用
对象数组是由多个对象组成的数组，每个元素都是一个对象。可以通过下标访问数组中的元素，也可以使用循环遍历整个数组。
对象数组的定义方式如下：
class MyClass {
// 类的成员变量和方法
}
MyClass[] myArray = new MyClass[10]; // 创建一个包含10个MyClass对象的数组
对象数组的初始化方式有两种：
1. 逐个初始化
MyClass[] myArray = new MyClass[10];
for (int i = 0; i < myArray.length; i++) {
myArray[i] = new MyClass();
}
2. 批量初始化
MyClass[] myArray = {new MyClass(), new MyClass(), new MyClass()};
3. 对象数组的代码实现
下面是一个使用对象数组的示例代码，创建一个包含5个Person对象的数组，然后遍历数组，输出每个对象的信息：
class Person {
String name;
int age;
void print() {
System.out.println("Name: " + name + ", Age: " + age);
}
}
public class Main {
public static void main(String[] args) {
Person[] persons = new Person[5];
persons[0] = new Person();
persons[0].name = "Alice";
persons[0].age = 20;
persons[1] = new Person();
persons[1].name = "Bob";
persons[1].age = 25;
persons[2] = new Person();
persons[2].name = "Charlie";
persons[2].age = 30;
persons[3] = new Person();
persons[3].name = "David";
persons[3].age = 35;
persons[4] = new Person();
persons[4].name = "Eva";
persons[4].age = 40;
for (int i = 0; i < persons.length; i++) {
persons[i].print();
}
}
}
输出结果如下：
Name: Alice, Age: 20
Name: Bob, Age: 25
Name: Charlie, Age: 30
Name: David, Age: 35
Name: Eva, Age: 40
方法应用
方法的重载及代码实现
方法的重载是指在同一个类中，可以定义多个同名但参数列表不同的方法。方法的重载可以提高代码的复用性和可读性。
方法的重载需要满足以下两个条件：
1. 方法名相同；
2. 参数列表不同（参数个数、类型或顺序不同）。
下面是一个方法的重载示例：
public class Calculator {
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
}
上面的代码中，Calculator类中定义了两个add方法，一个是传入两个int类型的参数，另一个是传入两个double类型的参数，这两个方法的方法名相同，但参数列表不同，因此它们是方法的重载。
在调用这两个方法时，根据传入的参数类型自动匹配对应的方法，例如：
Calculator calculator = new Calculator();
int result1 = calculator.add(1, 2); // 调用第一个add方法
double result2 = calculator.add(1.0, 2.0); // 调用第二个add方法
方法的重载可以让我们在不同的场景下使用同一个方法名，提高代码的可读性和可维护性。
需要注意的是，方法的重载不能只根据返回值类型来区分，因为Java编译器无法根据返回值类型来确定调用哪个方法，例如：
public class Test {
public int add(int a, int b) {
return a + b;
}
public double add(int a, int b) {
return a + b;
}
}
上面的代码中，Test类中定义了两个add方法，一个返回int类型，另一个返回double类型，但它们的参数列表相同，因此编译器无法确定调用哪个方法，会出现编译错误。
可变个数形参的方法及代码实现
可变个数形参的方法是指方法的参数个数是可变的，可以传入任意个参数。在Java中，可变个数形参的方法使用“...”来表示，它可以接收任意个数的参数，并将这些参数封装成一个数组。
下面是一个可变个数形参的方法的代码实现：
public class VariableParameter {
public static void main(String[] args) {
printNumbers(1, 2, 3, 4, 5);
printNumbers(6, 7, 8);
}
public static void printNumbers(int... numbers) {
for (int number : numbers) {
System.out.print(number + " ");
}
System.out.println();
}
}
上面的代码中，我们定义了一个printNumbers方法，它的参数列表中使用了可变个数形参int... numbers。在方法体中，我们使用了for-each循环遍历传入的参数，并打印输出每一个参数。
在main方法中，我们分别调用了两次printNumbers方法，第一次传入了5个参数，第二次传入了3个参数。由于printNumbers方法使用了可变个数形参，所以它可以接收任意个数的参数，不需要为每个参数都定义一个形参。
运行上面的代码，输出结果如下：
1 2 3 4 5
6 7 8
从上面的输出结果可以看出，printNumbers方法成功地接收了传入的任意个数的参数，并正确地输出了每一个参数。
方法值传递机制的剖析及代码实现
方法值传递机制是指在Java中，方法参数传递时，传递的是参数值的副本，而不是参数本身。这意味着在方法内部修改参数值不会影响原始参数的值。
下面是一个简单的例子来说明方法值传递机制：
public class MethodValuePassing {
public static void main(String[] args) {
int x = 10;
changeValue(x);
System.out.println(x); // 输出结果为10，因为changeValue方法中修改的是x的副本，不会改变原始x的值
}
public static void changeValue(int a) {
a = 20;
}
}
在上面的例子中，我们定义了一个名为`changeValue`的方法，它接受一个整数参数`a`。在`main`方法中，我们定义了一个整数变量`x`并将其初始化为10，然后调用`changeValue`方法并将`x`作为参数传递。在`changeValue`方法中，我们修改了参数`a`的值为20。但是，当我们在`main`方法中打印`x`的值时，输出结果仍然为10。
这是因为Java中的方法值传递机制是按值传递的。在调用方法时，Java会将参数的值复制一份并传递给方法。在方法内部，对参数值的任何修改都只会影响参数值的副本，而不会影响原始参数的值。
如果我们想在方法内部修改原始参数的值，可以使用引用传递机制。在Java中，对象参数是按引用传递的，这意味着在方法内部对对象参数的任何修改都会影响原始对象的值。下面是一个使用引用传递机制的例子：
public class MethodReferencePassing {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
changeValue(arr);
System.out.println(Arrays.toString(arr)); // 输出结果为[2, 4, 6]，因为changeValue方法中修改了arr数组中的元素
}
public static void changeValue(int[] a) {
for (int i = 0; i < a.length; i++) {
a[i] *= 2;
}
}
}
在上面的例子中，我们定义了一个名为`changeValue`的方法，它接受一个整数数组参数`a`。在`main`方法中，我们定义了一个整数数组`arr`并将其初始化为{1, 2, 3}，然后调用`changeValue`方法并将`arr`作为参数传递。在`changeValue`方法中，我们使用循环遍历数组并将每个元素的值乘以2。当我们在`main`方法中打印`arr`的值时，输出结果为[2, 4, 6]，因为`changeValue`方法中修改了`arr`数组中的元素。
这是因为在Java中，对象参数是按引用传递的。在调用方法时，Java会将对象的引用（即内存地址）复制一份并传递给方法。在方法内部，对对象的任何修改都会影响原始对象的值，因为原始对象和方法内部的对象引用指向的是同一个对象。
递归方法及代码实现
递归方法是指在方法内部调用自身的方法。递归方法常被用于处理树形结构、图形结构等具有递归性质的数据结构。下面是一个简单的递归方法的示例：
public static int factorial(int n) {
if (n == 0 || n == 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}
上述代码实现了一个阶乘的递归方法，当n为0或1时，返回1；否则返回n乘以n-1的阶乘。
在使用递归方法时需要注意以下几点：
1. 递归方法必须有一个终止条件，否则会导致无限递归，使程序崩溃。
2. 递归方法的效率较低，因为每次调用方法都会创建一个新的栈帧，占用内存较大。
3. 递归方法的调用深度不能太大，否则会导致栈溢出错误。
4. 递归方法的实现需要考虑清楚递归的过程和结果，避免出现逻辑错误。
总之，递归方法是一种强大的编程工具，可以用来解决很多复杂的问题。但是在使用时需要谨慎，避免出现递归错误。
package与import关键字的使用
Java 中，package 和 import 关键字都是用来管理代码的命名空间和导入其他类的。
1. package 关键字
package 关键字是用来声明一个 Java 包的。包是一种组织代码的方式，它可以将相关的类和接口放在一个命名空间中，以便于管理和使用。
在一个 Java 文件中，package 声明应该放在文件的第一行。语法如下：
package 包名;
例如，我们可以将一个类放在一个名为 com.example 的包中：
package com.example;
public class MyClass {
// ...
}
当我们需要使用这个类时，我们需要使用完整的包名来引用它：
com.example.MyClass myObject = new com.example.MyClass();
2. import 关键字
import 关键字是用来导入其他类的。当我们需要使用其他包中的类时，我们可以使用 import 关键字将它们导入到当前的命名空间中。
在一个 Java 文件中，import 声明应该放在 package 声明之后，类定义之前。语法如下：
import 包名.类名;
例如，我们可以导入 java.util 包中的 ArrayList 类：
import java.util.ArrayList;
public class MyClass {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
// ...
}
}
在这个例子中，我们使用了 ArrayList 类，它属于 java.util 包。通过 import 关键字，我们将 ArrayList 类导入到了当前的命名空间中，这样我们就可以直接使用它了。
除了单个类之外，我们还可以使用通配符 * 导入一个包中的所有类：
import java.util.*;
这样，我们就可以使用 java.util 包中的所有类了。
总结
在 Java 中，package 和 import 关键字都是用来管理代码的命名空间和导入其他类的。package 关键字用来声明一个 Java 包，而 import 关键字用来导入其他类。通过使用这两个关键字，我们可以更好地组织和管理 Java 代码。
面向对象的特征1
面向对象的特征1-封装性及代码实现
面向对象的特征之一是封装性，它指的是将数据和行为封装在一个类中，对外部隐藏实现细节，只暴露必要的接口。封装性可以保护数据的安全性和完整性，同时也提高了代码的可维护性和可重用性。
在Java中，封装性可以通过访问修饰符来实现。Java中有四种访问修饰符：public、protected、default和private。它们的作用范围如下：
- public：可以被任何类访问。
- protected：可以被同一个包内的类和子类访问。
- default：可以被同一个包内的类访问。
- private：只能被当前类访问。
下面是一个简单的Java类的例子，演示了封装性的实现：
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void sayHello() {
System.out.println("Hello, my name is " + name + ", I'm " + age + " years old.");
}
}
在这个例子中，我们定义了一个名为Person的类，它有两个私有的成员变量name和age。我们提供了两个公有的方法getName和getAge，用于获取这两个成员变量的值。同时，我们也提供了两个公有的方法setName和setAge，用于设置这两个成员变量的值。这样，外部的代码就无法直接访问这两个成员变量，只能通过这四个公有方法来访问。最后，我们还定义了一个公有的方法sayHello，用于输出Person对象的信息。
通过这个例子，我们可以看到封装性的实现方式：将数据和行为封装在一个类中，并使用访问修饰符来控制外部的访问。这样可以保证数据的安全性和完整性，同时也提高了代码的可维护性和可重用性。
封装性的几种不同权限修饰符的测试及代码实现
Java面向对象的特征之一是封装性，它指的是将类的实现细节隐藏起来，只对外部提供有限的接口来访问类的属性和方法。Java中有四种权限修饰符，分别是public、protected、default和private，它们用于控制类的成员的访问权限。
1. public修饰符
public修饰符是最开放的权限修饰符，它表示该成员可以被任何类访问。在同一个包内或不同包内的任何类中都可以访问public成员。
示例代码：
public class Person {
public String name;
public int age;
public void sayHello() {
System.out.println("Hello, I am " + name + ", " + age + " years old.");
}
}
public class Main {
public static void main(String[] args) {
Person person = new Person();
person.name = "Tom";
person.age = 18;
person.sayHello();
}
}
在这个例子中，Person类中的name和age属性和sayHello方法都是public的，所以在Main类中可以直接访问和修改这些成员。
2. protected修饰符
protected修饰符表示该成员只能被同一个包内的类和子类访问。在不同包内的非子类中无法访问protected成员。
示例代码：
public class Animal {
protected String name;
protected int age;
protected void sayHello() {
System.out.println("Hello, I am " + name + ", " + age + " years old.");
}
}
public class Dog extends Animal {
public void setInfo(String name, int age) {
this.name = name;
this.age = age;
}
public void introduce() {
sayHello();
System.out.println("I am a dog.");
}
}
public class Main {
public static void main(String[] args) {
Dog dog = new Dog();
dog.setInfo("Tom", 3);
dog.introduce();
}
}
在这个例子中，Animal类中的name和age属性和sayHello方法都是protected的，所以在Dog类中可以直接访问和修改这些成员。而在Main类中无法访问Animal类的protected成员。
3. default修饰符
default修饰符也称为包级私有访问权限，它表示该成员只能被同一个包内的类访问。在不同包内的类中无法访问default成员。
示例代码：
class Car {
String brand;
int price;
void sayHello() {
System.out.println("Hello, I am a " + brand + " car, priced at " + price + " dollars.");
}
}
public class Main {
public static void main(String[] args) {
Car car = new Car();
car.brand = "Toyota";
car.price = 20000;
car.sayHello();
}
}
在这个例子中，Car类中的brand和price属性和sayHello方法都是default的，所以在同一个包内的Main类中可以直接访问和修改这些成员。而在其他包中无法访问Car类的default成员。
4. private修饰符
private修饰符是最严格的权限修饰符，它表示该成员只能被同一个类内部的其他成员访问，无法被外部类访问。
示例代码：
public class Student {
private String name;
private int age;
public void setInfo(String name, int age) {
this.name = name;
this.age = age;
}
public void sayHello() {
System.out.println("Hello, I am " + name + ", " + age + " years old.");
}
}
public class Main {
public static void main(String[] args) {
Student student = new Student();
student.setInfo("Tom", 18);
student.sayHello();
}
}
在这个例子中，Student类中的name和age属性都是private的，只有setInfo方法可以修改这些属性。而在Main类中无法直接访问和修改Student类的private属性。
类的成员之三：构造器的使用
构造器是一种特殊的方法，用于创建对象并初始化对象的成员变量。在Java中，每个类都可以定义一个或多个构造器，构造器的名称必须与类名相同，不具有返回值类型。
构造器的使用：
1. 创建对象时自动调用构造器。
2. 构造器可以用来初始化对象的成员变量。
3. 构造器可以有多个参数，也可以没有参数。
4. 如果没有定义构造器，Java会自动生成一个默认的构造器。
练习：
定义一个类，包含以下成员变量：姓名、年龄、性别、身高、体重。为该类定义两个构造器，一个无参构造器和一个有参构造器。在有参构造器中，初始化所有成员变量。在无参构造器中，使用默认值初始化所有成员变量。定义一个方法，用于输出该类的所有成员变量。
代码实现：
public class Person {
private String name;
private int age;
private String gender;
private double height;
private double weight;
// 有参构造器
public Person(String name, int age, String gender, double height, double weight) {
this.name = name;
this.age = age;
this.gender = gender;
this.height = height;
this.weight = weight;
}
// 无参构造器
public Person() {
this.name = "";
this.age = 0;
this.gender = "";
this.height = 0.0;
this.weight = 0.0;
}
// 输出成员变量
public void printInfo() {
System.out.println("姓名：" + name);
System.out.println("年龄：" + age);
System.out.println("性别：" + gender);
System.out.println("身高：" + height);
System.out.println("体重：" + weight);
}
}
测试代码：
public class TestPerson {
public static void main(String[] args) {
Person person1 = new Person("Tom", 20, "男", 170.0, 60.0);
person1.printInfo();
Person person2 = new Person();
person2.printInfo();
}
}
输出结果：
姓名：Tom
年龄：20
性别：男
身高：170.0
体重：60.0
姓名：
年龄：0
性别：
身高：0.0
体重：0.0
实例变量赋值过程_JavaBean_UML类图
JavaBean是一种Java语言编写的可重用组件，它是一种符合JavaBean规范的Java类，具有以下特点：
1. 具有无参构造方法；
2. 属性私有化，通过公共方法进行访问；
3. 属性具有get和set方法，并且遵循JavaBean规范。
UML类图是一种用来描述类之间关系的图形化工具，它可以帮助我们更好地理解类的结构和关系。
以下是一个JavaBean的UML类图和代码实现：
UML类图：
+------------------------------------------+
| Person |
+------------------------------------------+
| -name: String |
| -age: int |
+------------------------------------------+
| +Person() |
| +Person(name: String, age: int) |
| +getName(): String |
| +setName(name: String): void |
| +getAge(): int |
| +setAge(age: int): void |
+-----------------------------------------+
代码实现：
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
在Java中，实例变量的赋值过程可以分为以下三个步骤：
1. 分配内存空间：在堆内存中为实例变量分配内存空间；
2. 初始化默认值：将实例变量的默认值赋值给它们；
3. 显式赋值：如果有显式赋值，将显式赋值赋给实例变量。
例如，在上面的Person类中，当创建一个Person对象时，将按照以下步骤进行：
1. 在堆内存中为Person对象分配内存空间；
2. 将name和age实例变量的默认值（null和0）赋值给它们；
3. 如果创建Person对象时传入了name和age的值，则将这些值赋给相应的实例变量。
例如：
Person p = new Person();
p.setName("Tom");
p.setAge(20);
在这个例子中，将创建一个Person对象，并将它的name设置为"Tom"，age设置为20。
