Java类和对象
在之前的编程学习中，我们主要使用基本数据类型和简单的方法来编写程序。虽然这种方式也能解决问题，但当程序变得复杂时，我们会发现代码变得难以管理和维护。
假设我们要描述一辆汽车，我们需要考虑很多方面：品牌、型号、颜色、发动机、轮胎、座椅等。如果我们要在程序中表示这些信息，仅仅使用简单的变量是不够的。我们需要一种更强大的方式来组织和管理这些相关的数据。
这就是面向对象编程的核心思想。在面向对象编程中，我们将现实世界中的事物抽象为程序中的对象，每个对象都有自己的属性和行为。
对象和类的基本概念
什么是对象？
对象是软件中的一个组件，它在内存中占有一块空间，并且在程序运行时可以用来表示现实世界中的某个事物或概念。每个对象都包含两部分内容：
属性（数据/状态） ：对象可以保存与自身相关的信息，这些信息称为属性或字段。例如，一个学生对象可以有姓名、学号、年龄等属性。行为（操作/方法） ：对象可以执行某些操作，这些操作称为方法。例如，学生对象可以有“参加考试”、“提交作业”等方法。
对象的本质是将数据和操作数据的方法封装在一起，使得程序结构更加清晰、易于维护。
对象的能力
每个对象都有两种基本能力：
存储数据 ：对象可以保存各种信息，这些信息称为字段（fields）执行操作 ：对象可以执行各种任务，这些任务称为方法（methods）
什么是类？
类就像是对象的“蓝图”或“模板”。它描述了某种类型对象应该具有什么样的属性和行为。
想象一下建筑蓝图。蓝图本身不是房子，而是房子的详细描述。当我们使用蓝图建造实际的房子时，我们就是在创建蓝图所描述房子的一个实例。
如果我们愿意，我们可以用同一个蓝图建造几座相同的房子，每座房子都是蓝图所描述房子的一个实例。
在编程中，类就是对象的蓝图。当我们创建对象时，我们就是在创建类的一个实例。
使用Java API中的类
到目前为止，我们在程序中使用的对象都是来自Java API的类创建的。例如：
当你需要从键盘或文件读取输入时，你可以使用Scanner对象
当你需要生成随机数时，你可以使用Random对象
当你需要向文件写入输出时，你可以使用PrintWriter对象
让我们看一个使用这些对象的例子：
import java.util.Scanner; import java.util.Random; import java.io. * ;
public class ObjectDemo { public static void main ( String
[]
args
)
throws
IOException {
int maxNumbers; // 要生成的随机数数量
int number; // 保存随机数
// 创建Scanner对象用于键盘输入
Scanner keyboard = new Scanner (System.in);
// 创建Random对象用于生成随机数
Random rand = new Random ();
// 创建PrintWriter对象用于文件输出
PrintWriter outputFile = new PrintWriter ( "numbers.txt" );
// 获取要生成的随机数数量
System.out. print ( "要生成多少个随机数？" );
maxNumbers = keyboard. nextInt ();
// 将随机数写入文件
for ( int count = 0 ; count < maxNumbers; count ++ ) {
// 生成随机整数
number = rand. nextInt ();
// 将随机整数写入文件
outputFile. println (number);
}
// 关闭文件
outputFile. close ();
System.out. println ( "完成" );
}
}
一个Scanner对象用于读取键盘输入
一个Random对象用于生成随机数
一个PrintWriter对象用于向文件写入数据
每个对象都有自己的方法和功能，程序通过调用这些对象的方法来完成特定的任务。
基本类型变量与对象
基本类型变量
基本数据类型 ：byte、short、int、long、char、float、double、boolean对象类型 ：通过类创建的对象 基本类型变量是计算机内存中的简单存储位置。当你声明一个基本类型变量时，编译器会为该变量分配足够的内存空间。
int wholeNumber; double realNumber;
int类型使用4字节内存
double类型使用8字节内存
对象的创建
声明引用变量 ：声明一个可以引用对象的变量创建对象 ：使用new关键字在内存中创建对象，并将其地址赋给引用变量 Random rand = new Random ();
Random rand：声明一个名为rand的变量，它可以引用Random类型的对象new Random()：new操作符在内存中创建一个对象，并返回该对象的内存地址=：将new操作符返回的内存地址赋给rand变量
引用变量与对象的关系 引用变量不直接存储数据，而是存储对象的内存地址。我们可以把这种关系比作风筝和线轴：
对象就像风筝，存在于内存中
引用变量就像线轴，用来控制风筝
编写自己的类
为什么需要编写自己的类？ Java API（应用程序编程接口）为开发者提供了大量已经编写好的类，这些类可以直接在你的程序中使用，极大地提高了开发效率。例如，String类用于处理字符串，Scanner类用于接收用户输入，ArrayList类用于动态数组操作，等等。
然而，在实际开发过程中，你经常会遇到一些特定的需求，这些需求并没有现成的类可以直接满足。例如，你可能需要表示一个“学生”、一个“图书”、一个“订单”或者一个“几何图形”等等。这时，Java标准库中并没有为你的具体业务场景量身定制的类。
这并不是问题，因为Java是一门面向对象的编程语言，允许你根据实际需求自定义类。你可以自己设计类的结构，定义它包含哪些属性（字段）、能做哪些操作（方法），从而创建出适合你项目的对象。例如，如果你需要表示一个矩形，可以自己编写一个Rectangle类，包含长度、宽度等字段，以及计算面积、设置尺寸等方法。
封装和管理与现实世界或业务相关的数据
实现特定的功能和行为
提高代码的可读性和可维护性
实现代码的复用和模块化
总之，当Java API中没有你需要的类时，你完全可以根据自己的需求编写类，为任何场景创建具有特定属性和功能的对象。这是Java编程的核心能力之一，也是面向对象思想的体现。
编写类的步骤 让我们通过编写一个Rectangle类来学习如何创建自己的类。这个类将表示矩形，具有以下特性：
length：存储矩形的长度
width：存储矩形的宽度
setLength：设置长度
setWidth：设置宽度
getLength：获取长度
getWidth：获取宽度
getArea：计算面积
第一步：创建类的基本结构 public class Rectangle { private double length; private double width; } 这个类定义了两个私有（private）字段：length（长度）和width（宽度）。所谓“私有字段”，是指它们只能在Rectangle类的内部被访问和修改，外部代码无法直接访问这两个变量。这种做法称为“数据封装”或“数据隐藏”，它的好处是可以防止外部代码随意更改对象的内部状态，从而保护数据的完整性和安全性。只有通过类中提供的公有（public）方法（如setter和getter方法），外部代码才能间接地读取或修改这些字段的值，这样可以在方法中加入必要的校验或逻辑，进一步增强代码的健壮性。
第二步：添加setter方法 public class Rectangle { private double length; private double width; /** * setLength方法在length字段中存储值 * @param len 要存储在length中的值 */ public void setLength ( double len ) { length = len; } /** * setWidth方法在width字段中存储值 * @param w 要存储在width中的值
第三步：添加getter方法 public class Rectangle { private double length; private double width; /** * setLength方法在length字段中存储值 * @param len 要存储在length中的值 */ public void setLength ( double len ) { length = len; } /** * setWidth方法在width字段中存储值 * @param w 要存储在width中的值
第四步：添加计算面积的方法 public class Rectangle { private double length; private double width; /** * setLength方法在length字段中存储值 * @param len 要存储在length中的值 */ public void setLength ( double len ) { length = len; } /** * setWidth方法在width字段中存储值 * @param w 要存储在width中的值
测试Rectangle类 现在让我们创建一个程序来测试Rectangle类：
public class RectangleDemo { public static void main ( String [] args ) { // 创建Rectangle对象 Rectangle box = new Rectangle (); // 设置长度为10.0，宽度为20.0 box. setLength ( 10.0 ); box. setWidth ( 20.0 ); // 显示长度 System.out. println ( "矩形的长度是：" + 矩形的长度是：10.0 矩形的宽度是：20.0 矩形的面积是：200.0
访问器和修改器方法
数据隐藏的重要性 在面向对象编程中，数据隐藏是一个重要概念。对象将其内部数据隐藏起来，不让类外部的代码直接访问。只有类的方法才能直接访问和修改对象的内部数据。
你通过将类的字段设为私有（private），将访问这些字段的方法设为公有（public）来隐藏对象的内部数据。
public class Rectangle { private double length; private double width;
public double getLength () { return length; }
public void setLength ( double length ) { this .length = length; } }
访问器和修改器
访问器方法（Accessor） ：获取字段值但不改变它的方法修改器方法（Mutator） ：在字段中存储值或以其他方式改变字段值的方法
getLength和getWidth是访问器方法
setLength和setWidth是修改器方法
避免过时数据 在Rectangle类中，getLength和getWidth方法返回存储在字段中的值，但getArea方法返回计算结果。你可能会想为什么矩形的面积不存储在字段中，就像长度和宽度一样。
面积不存储在字段中是因为它可能会过时。当一个项目的值依赖于其他数据，而该项目在其他数据改变时没有更新，就说该项目已经过时了。
如果矩形的面积存储在字段中，那么当长度或宽度字段改变时，该字段的值就会变得不正确。
在设计类时，你应该注意不要在字段中存储可能会过时的计算数据。相反，应该提供一个返回计算结果的方法。
实例字段和方法
实例字段 每当你根据某个类创建一个对象（实例）时，这个对象都会拥有属于自己的那一份字段，这些字段被称为“实例字段”。实例字段是存储在每个对象内部的数据副本。
也就是说，即使多个对象都是同一个类创建的，它们的实例字段也是彼此独立、互不影响的。每个对象都可以在自己的实例字段中保存不同的值，这样每个对象就能拥有属于自己的状态。
例如，如果你用Rectangle类创建了两个矩形对象，每个对象都有自己的length和width字段，分别记录各自的长度和宽度。
让我们看一个例子，创建多个Rectangle对象：
import javax.swing.JOptionPane;
public class RoomAreas { public static void main ( String [] args ) { double number; // 保存数字 double totalArea; // 总面积 String input; // 保存用户输入 // 创建三个Rectangle对象 Rectangle kitchen = new Rectangle (); Rectangle bedroom = new Rectangle (); Rectangle den = 这个程序创建了三个Rectangle对象：kitchen、bedroom和den。每个对象都有自己的length和width字段，可以存储不同的值。
实例方法 在Java中，实例方法 （Instance Method）是指那些必须通过类的对象（实例）来调用的方法。实例方法通常用于操作该对象的属性或实现与该对象相关的功能。每个对象都有自己独立的数据，实例方法在被调用时会自动作用于调用它的那个对象。
以Rectangle类为例，类中定义的setLength、setWidth、getLength、getWidth和getArea等方法，都是实例方法。它们只能通过Rectangle类的具体对象来调用，并且每次调用时，方法内部操作的都是当前对象（即调用者）的字段。例如，kitchen.setLength(number);会把number的值存储到kitchen对象的length字段中，而bedroom.setLength(number);则会把值存储到bedroom对象的length字段中。这样，每个对象都能独立维护自己的状态。
实例方法是与对象实例相关联的方法，必须通过对象来调用，能够访问和修改该对象的属性。
kitchen. setLength (number); 这个语句调用setLength方法，将值存储在kitchen对象的length字段中。
bedroom. setLength (number); 这个语句也调用setLength方法，但这次是将值存储在bedroom对象的length字段中。
构造函数
什么是构造函数？ 构造函数（Constructor）是一个特殊的方法，它在使用new关键字创建类的对象时被自动调用。构造函数的主要作用是对新创建的对象进行初始化操作，比如为实例字段（成员变量）赋初值、执行必要的准备工作等。每当你通过new创建一个对象时，都会自动执行该类的构造函数，从而确保对象的状态是有效的。
方法名必须与类名完全相同 ，包括大小写。例如，Rectangle类的构造函数名就必须是Rectangle。没有返回值类型 ，连void也不能写。可以有参数，也可以没有参数 。带参数的构造函数可以让你在创建对象时直接指定初始值，无参数的构造函数则通常为字段赋默认值。可以重载 。一个类可以有多个构造函数，只要它们的参数列表不同即可。 举例说明：如果你有一个Rectangle类，那么它的构造函数应该写成如下形式：
编写构造函数 public class Rectangle { private double length; private double width; /** * 构造函数 * @param len 矩形的长度 * @param w 矩形的宽度 */ public Rectangle ( double len , double w ) { length = len; width = w; } 这个构造函数接受两个参数，并将它们分别赋给length和width字段。
使用构造函数 Rectangle box = new Rectangle ( 7.0 , 14.0 ); 这个语句创建一个Rectangle对象，并将其地址赋给box变量。构造函数会将length字段设置为7.0，将width字段设置为14.0。
默认构造函数 如果你没有为类编写构造函数，Java会在编译类时自动提供一个。Java提供的构造函数称为默认构造函数。默认构造函数不接受参数，它将对象的所有数字字段设置为0，布尔字段设置为false。
无参构造函数 public Rectangle () { length = 1.0 ; width = 1.0 ; } 如果使用这个构造函数，创建Rectangle对象时就不需要传递参数：
Rectangle r = new Rectangle (); // 调用无参构造函数
将对象作为参数传递
对象参数的概念 在开发面向对象的应用程序时，很多情况下我们需要让方法能够接收对象作为参数。这样做的好处是，方法不仅可以操作基本数据类型，还能直接访问和操作对象的属性和方法，从而实现更强大和灵活的功能。
当你将一个对象作为参数传递给方法时，实际上传递的是该对象在内存中的引用（即内存地址），而不是对象本身的副本。也就是说，方法参数变量会指向同一个对象实例。这样，方法内部对该对象属性的修改，会影响到原始对象。
实际应用示例 为了更好地理解如何将对象作为参数传递给方法，我们来设计一个具体的案例：一个简单的骰子游戏。在这个游戏中，我们将定义三个类：
Die类 ：用于模拟骰子的行为，比如投掷和获取点数。Dealer类 ：代表庄家，负责管理游戏流程，比如发起投掷和判断胜负。Player类 ：代表玩家，记录玩家的姓名和当前得分。 通过这个例子，你将看到如何在方法中接收和操作对象参数，以及对象之间如何协作完成一个完整的功能。
import java.util.Random;
/** * Die类模拟一个骰子 */ public class Die { private int sides; // 骰子的面数 private int value; // 骰子的值 /** * 构造函数执行骰子的初始投掷 * @param numSides 这个骰子的面数 */ public Die ( int numSides ) { sides = numSides; roll (); 现在让我们创建一个程序来演示如何将Die对象作为参数传递：
public class DieArgument { public static void main ( String [] args ) { final int SIX_SIDES = 6 ; final int TWENTY_SIDES = 20 ; // 创建一个6面骰子 Die sixDie = new Die (SIX_SIDES); // 创建一个20面骰子 Die twentyDie = new Die (TWENTY_SIDES); 投掷一个6面骰子。 骰子的值：3 投掷一个20面骰子。 骰子的值：19
方法重载和构造函数重载
方法重载的概念 方法重载（Overloading）是面向对象编程中非常重要且常用的特性。它允许在同一个类中定义多个同名的方法，但这些方法的参数列表（参数的个数、类型或顺序）必须不同。
这样，虽然方法名相同，但根据传入的参数不同，Java编译器会自动选择合适的方法进行调用。
方法重载的意义在于：有时候我们希望对同一类操作提供多种不同的实现方式。例如，可能需要既能传递整数参数，也能传递浮点数参数，或者有时需要传递两个参数，有时只需要一个参数。
通过方法重载，我们可以让代码更加灵活、易读，并且便于维护。
重载的规则 两个或多个方法在同一个类中可以有相同的名称，只要它们的参数列表不同。这也适用于构造函数。
Java使用方法签名来区分同名的方法。方法签名由方法名称和参数的数据类型组成，按它们出现的顺序排列。
构造函数重载示例 public class Rectangle { private double length; private double width; /** * 无参构造函数 */ public Rectangle () { length = 0.0 ; width = 0.0 ; } /** * 带参数的构造函数 * @param len 长度 * @param w 宽度 现在我们可以用不同的方式创建Rectangle对象：
Rectangle box1 = new Rectangle (); // 调用无参构造函数 Rectangle box2 = new Rectangle ( 5.0 , 10.0 ); // 调用带参数的构造函数
BankAccount类示例 下面我们通过一个更为详细和复杂的例子来理解方法重载：BankAccount（银行账户）类。这个类不仅展示了构造函数的重载，还演示了同名方法（如deposit和withdraw）的重载用法。
通过不同的参数类型和数量，BankAccount类可以灵活地处理多种初始化和账户操作场景。
public class BankAccount { private double balance; // 账户余额 /** * 这个构造函数将起始余额设置为0.0 */ public BankAccount () { balance = 0.0 ; } /** * 这个构造函数将起始余额设置为作为参数传递的值 * @param startBalance 起始余额 */ public BankAccount ( double startBalance ) { balance = 这个类有三个重载的构造函数和多个重载的方法，提供了不同的方式来创建账户和执行操作。
实例字段的作用域
实例字段的可见性 实例字段（也称为成员变量）是在类中定义但在方法体外部声明的变量。它们属于类的每一个对象（实例），并且在整个类的范围内都可见。也就是说，类的所有实例方法都可以直接访问和修改这些实例字段，无需通过参数传递。例如，如果你在类中声明了一个private double balance;字段，那么类中的所有方法（如deposit、withdraw、getBalance等）都可以直接读取或更改balance的值。
需要注意的是，实例字段的可见性还受到访问修饰符（如private、protected、public）的影响。通常我们将实例字段声明为private，以实现封装，只允许类的内部方法访问和修改它们，而不允许外部直接访问。
实例字段在类的所有方法中都是可见的，并且可以被这些方法访问和修改，这也是对象能够维护自身状态的基础。
局部变量与实例字段 当在方法中声明的局部变量（包括方法的参数）与类中的实例字段（成员变量）同名时，局部变量会“遮蔽”同名的实例字段。
也就是说，在该方法体内直接使用这个名字时，实际上访问的是局部变量而不是实例字段。这种情况下，如果你想在方法内部访问被遮蔽的实例字段，必须使用this关键字来明确表示。
例如，this.value表示当前对象的实例字段value，而直接写value则指的是方法的参数或局部变量。这样可以避免命名冲突导致的混淆，并确保你访问的是正确的变量。
public class Example { private int value; // 实例字段 public void setValue ( int value ) { // 参数与实例字段同名 this .value = value; // 使用this访问实例字段 } public int getValue () { return value; // 可以直接访问实例字段 } }
库和import语句
库的概念 库（Library）是Java中用于组织和管理相关类、接口、枚举等代码结构的机制。它类似于操作系统中的文件夹，可以将功能相近或属于同一模块的类归类存放，形成层次分明的结构。
通过使用库，不仅可以避免类名冲突（因为不同库下可以有同名的类），还可以提升代码的可维护性和可读性。
在实际开发中，通常会根据项目的功能模块、业务逻辑或公司/组织的域名反写来命名库。
例如，java.util库中包含了各种实用工具类，com.example.bank库可能包含银行相关的业务类。使用库还可以方便地进行访问控制和代码管理，使大型项目的结构更加清晰有序。
使用import语句 当你需要使用其他包中的类时，你需要使用import语句。例如：
import java.util.Scanner; import java.util.Random; import java.io. * ; 这些import语句使Scanner、Random和文件I/O类在你的程序中可用。
习题 A. 类是对象的模板，对象是类的实例
B. 对象是类的模板，类是对象的实例
C. 类和对象没有区别
D. 类就是对象
在Java中，用于实现封装，使字段只能在类内部访问的访问修饰符是？
A. public
B. private
C. protected
D. static
A. 用于初始化对象
B. 用于销毁对象
C. 用于调用方法
D. 用于定义变量
A. 方法名相同，参数列表不同
B. 方法名不同，参数列表相同
C. 方法名和参数列表都相同
D. 返回类型不同
A. new 类名()
B. create 类名()
C. make 类名()
D. init 类名()
A. getter方法
B. setter方法
C. 构造函数
D. 普通方法
A. this
B. super
C. self
D. that
设计一个Student类，包含学生的姓名和年龄属性，以及相应的getter和setter方法。
public class Student { // 私有字段 private String name; private int age; // 无参构造函数 public Student () { name = "" ; age = 0 ; } // 带参数的构造函数 public Student (String name , int age ) { this .name = 为Student类编写多个构造函数，包括无参构造函数、只接收姓名的构造函数和接收姓名与年龄的构造函数。
public class Student { private String name; private int age; // 无参构造函数 public Student () { this .name = "未知" ; this .age = 0 ; } // 只接收姓名的构造函数 public Student (String name ) { this .name = name; this 编写一个方法，接受Student对象作为参数，并显示学生的信息。
public class Student { private String name; private int age; public Student (String name , int age ) { this .name = name; this .age = age; } public String getName () { return name; } public 在Student类中添加重载的方法，比如设置成绩的方法可以接受整数或浮点数参数。
public class Student { private String name; private double score; public Student (String name ) { this .name = name; this .score = 0.0 ; } // 方法重载：设置整数成绩 public void setScore ( int score ) { this .score = score; */
public void setWidth ( double w ) {
width = w;
}
}
*/
public void setWidth ( double w ) {
width = w;
}
/**
* getLength方法返回Rectangle对象的长度
* @return length字段中的值
*/
public double getLength () {
return length;
}
/**
* getWidth方法返回Rectangle对象的宽度
* @return width字段中的值
*/
public double getWidth () {
return width;
}
}
*/
public void setWidth ( double w ) {
width = w;
}
/**
* getLength方法返回Rectangle对象的长度
* @return length字段中的值
*/
public double getLength () {
return length;
}
/**
* getWidth方法返回Rectangle对象的宽度
* @return width字段中的值
*/
public double getWidth () {
return width;
}
/**
* getArea方法返回Rectangle对象的面积
* @return 长度乘以宽度的结果
*/
public double getArea () {
return length * width;
}
}
box.
getLength
());
// 显示宽度
System.out. println ( "矩形的宽度是：" + box. getWidth ());
// 显示面积
System.out. println ( "矩形的面积是：" + box. getArea ());
}
}
new
Rectangle
();
// 获取并存储厨房的尺寸
input = JOptionPane. showInputDialog ( "厨房的长度是多少？" );
number = Double. parseDouble (input);
kitchen. setLength (number);
input = JOptionPane. showInputDialog ( "厨房的宽度是多少？" );
number = Double. parseDouble (input);
kitchen. setWidth (number);
// 获取并存储卧室的尺寸
input = JOptionPane. showInputDialog ( "卧室的长度是多少？" );
number = Double. parseDouble (input);
bedroom. setLength (number);
input = JOptionPane. showInputDialog ( "卧室的宽度是多少？" );
number = Double. parseDouble (input);
bedroom. setWidth (number);
// 获取并存储书房的尺寸
input = JOptionPane. showInputDialog ( "书房的长度是多少？" );
number = Double. parseDouble (input);
den. setLength (number);
input = JOptionPane. showInputDialog ( "书房的宽度是多少？" );
number = Double. parseDouble (input);
den. setWidth (number);
// 计算房间的总面积
totalArea = kitchen. getArea () + bedroom. getArea () + den. getArea ();
// 显示房间的总面积
JOptionPane. showMessageDialog ( null , "房间的总面积是：" + totalArea);
System. exit ( 0 );
}
}
// ... 其他方法保持不变
}
}
/**
* roll方法模拟骰子的投掷
*/
public void roll () {
// 创建Random对象
Random rand = new Random ();
// 获取骰子的随机值
value = rand. nextInt (sides) + 1 ;
}
/**
* getSides方法
* @return 这个骰子的面数
*/
public int getSides () {
return sides;
}
/**
* getValue方法
* @return 骰子的值
*/
public int getValue () {
return value;
}
}
// 投掷骰子
rollDie (sixDie);
rollDie (twentyDie);
}
/**
* 这个方法模拟骰子投掷，显示骰子的面数和值
* @param d 要投掷的Die对象
*/
public static void rollDie (Die d ) {
// 显示面数
System.out. println ( "投掷一个" + d. getSides () + "面骰子。" );
// 投掷骰子
d. roll ();
// 显示骰子的值
System.out. println ( "骰子的值：" + d. getValue ());
}
}
*/
public Rectangle ( double len , double w ) {
length = len;
width = w;
}
// ... 其他方法
}
startBalance;
}
/**
* 这个构造函数将起始余额设置为String参数中的值
* @param str 作为String的起始余额
*/
public BankAccount (String str ) {
balance = Double. parseDouble (str);
}
/**
* deposit方法向账户存款
* @param amount 要添加到balance字段的金额
*/
public void deposit ( double amount ) {
balance += amount;
}
/**
* deposit方法向账户存款
* @param str 要添加到balance字段的金额，作为String
*/
public void deposit (String str ) {
balance += Double. parseDouble (str);
}
/**
* withdraw方法从账户取款
* @param amount 要从balance字段减去的金额
*/
public void withdraw ( double amount ) {
balance -= amount;
}
/**
* withdraw方法从账户取款
* @param str 要从balance字段减去的金额，作为String
*/
public void withdraw (String str ) {
balance -= Double. parseDouble (str);
}
/**
* getBalance方法返回账户余额
* @return balance字段中的值
*/
public double getBalance () {
return balance;
}
}
name;
this .age = age;
}
// getter方法：获取姓名
public String getName () {
return name;
}
// setter方法：设置姓名
public void setName (String name ) {
this .name = name;
}
// getter方法：获取年龄
public int getAge () {
return age;
}
// setter方法：设置年龄
public void setAge ( int age ) {
this .age = age;
}
// 显示学生信息的方法
public void displayInfo () {
System.out. println ( "姓名: " + name);
System.out. println ( "年龄: " + age);
}
}
// 测试类
public class StudentTest {
public static void main ( String [] args ) {
// 使用无参构造函数创建对象
Student student1 = new Student ();
student1. setName ( "张三" );
student1. setAge ( 20 );
student1. displayInfo ();
System.out. println ( "----------------" );
// 使用带参构造函数创建对象
Student student2 = new Student ( "李四" , 22 );
student2. displayInfo ();
}
}
姓名: 张三 年龄: 20 ---------------- 姓名: 李四 年龄: 22
使用private修饰字段实现封装
提供getter和setter方法访问私有字段
定义无参和带参两种构造函数
使用this关键字区分参数和字段
.age
=
0
;
}
// 接收姓名和年龄的构造函数
public Student (String name , int age ) {
this .name = name;
this .age = age;
}
public void displayInfo () {
System.out. println ( "姓名: " + name + ", 年龄: " + age);
}
}
// 测试类
public class ConstructorTest {
public static void main ( String [] args ) {
// 使用不同的构造函数创建对象
Student student1 = new Student ();
student1. displayInfo ();
Student student2 = new Student ( "王五" );
student2. displayInfo ();
Student student3 = new Student ( "赵六" , 25 );
student3. displayInfo ();
}
}
姓名: 未知, 年龄: 0 姓名: 王五, 年龄: 0 姓名: 赵六, 年龄: 25
一个类可以有多个构造函数（构造函数重载）
构造函数的参数列表必须不同
根据传入的参数不同，调用相应的构造函数
int
getAge
() {
return age;
}
}
// 测试类
public class ObjectParameterTest {
public static void main ( String [] args ) {
Student student1 = new Student ( "张三" , 20 );
Student student2 = new Student ( "李四" , 22 );
// 传递对象作为参数
displayStudentInfo (student1);
displayStudentInfo (student2);
}
// 接收Student对象作为参数的方法
public static void displayStudentInfo (Student student ) {
System.out. println ( "学生信息:" );
System.out. println ( " 姓名: " + student. getName ());
System.out. println ( " 年龄: " + student. getAge ());
System.out. println ( "----------------" );
}
}
学生信息: 姓名: 张三 年龄: 20 ---------------- 学生信息: 姓名: 李四 年龄: 22 ----------------
对象可以作为参数传递给方法
在方法中可以通过对象引用访问对象的字段和方法
传递的是对象的引用，不是对象的副本
System.out. println (name + "的成绩已设置为: " + score);
}
// 方法重载：设置浮点数成绩
public void setScore ( double score ) {
this .score = score;
System.out. println (name + "的成绩已设置为: " + score);
}
// 方法重载：设置两个成绩（计算平均分）
public void setScore ( int score1 , int score2 ) {
this .score = (score1 + score2) / 2.0 ;
System.out. println (name + "的平均成绩已设置为: " + this .score);
}
public void displayInfo () {
System.out. println ( "姓名: " + name + ", 成绩: " + score);
}
}
// 测试类
public class MethodOverloadTest {
public static void main ( String [] args ) {
Student student = new Student ( "张三" );
// 调用不同的重载方法
student. setScore ( 85 );
student. displayInfo ();
student. setScore ( 88.5 );
student. displayInfo ();
student. setScore ( 90 , 95 );
student. displayInfo ();
}
}
张三的成绩已设置为: 85 姓名: 张三, 成绩: 85.0 张三的成绩已设置为: 88.5 姓名: 张三, 成绩: 88.5 张三的平均成绩已设置为: 92.5 姓名: 张三, 成绩: 92.5 Java类和对象 | 自在学
方法重载允许同一个类中有多个同名方法
重载方法的参数列表必须不同（类型、个数或顺序）
根据调用时传入的参数类型和数量，Java会自动选择匹配的方法
