Java中的面向对象编程
立即解锁
发布时间: 2025-08-18 02:26:13 阅读量: 3 订阅数: 11 

Java编程实战:从入门到精通
### Java 中的面向对象编程
#### 1. Java 基础注意事项
Java 是区分大小写的语言。例如,不能将 `public` 写成大写的 `Public`,否则程序将无法编译。以下是运行 Java 小程序(applet)的步骤:
1. 编译 Java 小程序代码。
2. 将 HTML 页面规范保存为 `MyFirstApplet.html` 文件,且该文件需与 Java 小程序的 `.class` 文件位于同一目录。
3. 使用 JDK 中的 `appletviewer` 命令运行小程序,命令为:`appletviewer MyFirstApplet.html`。
由于小程序窗口的高度和宽度是以像素为单位指定的,所以 `appletviewer` 窗口的实际尺寸取决于显示器的分辨率和大小。
#### 2. Java 面向对象编程概述
Java 是一种面向对象的语言。在非面向对象的编程语言中,解决问题通常需要用数字和字符(即基本数据类型)来表达。而在 Java 这样的面向对象语言中,除了基本数据类型(如数字和字符,也称为原始数据类型),还可以定义与特定问题相关的其他实体或对象。通过这些对象来解决问题,不仅会影响程序的结构,还会改变问题解决方案的表达方式。
例如,如果问题涉及棒球运动员,Java 程序中可能会有 `BaseballPlayer` 对象;如果要编写一个处理加利福尼亚水果生产的程序,可能会有 `Oranges` 对象。面向对象编程不仅是一种构建程序的合理方法,而且通常更易于理解。
#### 3. 什么是对象
任何事物都可以被视为对象。以树为例,`Tree` 可以看作是一类对象的统称,是一个比较抽象的概念。更具体的树的类型,如橡树(`Oak`)、白蜡树(`Ash`)和红杉树(`Redwood`),是 `Tree` 的子类。例如,院子里的橡树 `myOak`、你的院子里的白蜡树 `thatDarnedTree` 以及著名的红杉树 `generalSherman`,都是具体类型树的实例。
以下是树的类关系图:
```mermaid
graph LR
classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px
A(Tree):::process --> B(Oak):::process
A --> C(Ash):::process
A --> D(Redwood):::process
B --> E(myOak):::process
C --> F(yourAsh):::process
D --> G(generalSherman):::process
```
类是一个规范或蓝图,用一段程序代码表示,用于定义构成特定类型对象的要素。子类继承父类的所有属性,并可以有额外的特性。每个类的对象都有一组共同的属性,但每个对象的这些属性值是唯一的。
#### 4. 定义对象的类
类的定义确定了定义该特定类对象的所有参数。不同的人可能会根据不同的需求,使用不同数量的参数来定义同一个类的对象。例如,定义 `Hat` 类时,可以只使用两个参数:帽子的类型(如 “Fedora” 或 “Baseball cap”)和尺寸(数值)。这些定义对象的参数被称为类的实例变量、属性或类字段。实例变量可以是基本数据类型,也可以是其他类的对象。
以下是 Java 中 `Hat` 类的定义示例:
```java
class Hat {
// Stuff defining the class in detail goes here.
// This could specify the name of the hat, the size,
// maybe the color, and whatever else you felt was necessary.
}
```
需要注意的是,`class` 是 Java 中的关键字,只能用于类的定义。在 Java 中还有很多其他关键字,不能将它们用于其他目的。
每个类的对象都有一组特定的值来表征该对象。例如,`CowboyHat` 对象可以由帽子类型(如 “Stetson”)、颜色(如 “White”)和尺寸(如 6)来定义。对象的参数值并不一定是固定的,例如 `CowboyHat` 对象的 `owner` 参数可以在帽子出售或转让时更改,`hatOn` 参数可以表示帽子是否戴在头上。
以下是 `CowboyHat` 类的不同实例:
| 实例 | 类型 | 颜色 | 尺寸 | 所有者 | 帽子状态 |
| ---- | ---- | ---- | ---- | ---- | ---- |
| 实例 1 | Stetson | White | 6 | Jed | false |
| 实例 2 | Stetson | Gray | 7 | Slim | true |
#### 5. 对对象进行操作
类对象不仅仅是各种数据项的集合。除了表征对象的参数外,类还定义了可以对对象执行的操作。这些操作取决于对象的类型、包含的属性以及使用方式。
以 `CowboyHat` 类为例,可以定义 `putHatOn` 和 `takeHatOff` 操作,用于设置 `hatOn` 参数的值,还可以定义 `changeOwner` 操作来更改帽子的所有者。
以下是 `CowboyHat` 类的完整定义示例:
```java
class CowboyHat {
private String owner;
private int size;
private boolean hatOn = false;
// Constructor to create a CowboyHat object
public CowboyHat(String person, int theSize) {
size = theSize;
owner = person;
}
// Method to put the hat on
public void putHatOn() {
hatOn = true;
}
// Method to take the hat off
public void takeHatOff() {
hatOn = false;
}
// Method to change the owner
public void changeOwner(String newOwner) {
owner = newOwner;
}
// Method to get the hat size
public int getSize() {
return size;
}
}
```
该代码应保存为 `CowboyHat.java` 文件。类的定义代码位于类名后面的花括号内,每个方法的代码也位于花括号内。类中的实例变量 `owner`、`size` 和 `hatOn` 被声明为 `private`,这意味着只有类的方法内部可以直接访问和更改它们的值。而类的方法被声明为 `public`,可以从类外部访问。
构造函数 `CowboyHat` 用于创建 `CowboyHat` 对象,构造函数的名称必须与类名相同。
#### 6. Java 程序语句
Java 方法中的代码由程序语句组成,每个程序语句以分号结尾。一个语句可以跨多行,因为语句的结束由分号决定,而不是行的结束。例如:
```java
hatOn = false;
```
也可以写成:
```java
hatOn =
false;
```
在编写代码时,可以使用空格和制表符来提高代码的可读性,但不能在名称中间插入空格,否则编译器会将其视为两个单词。
### Java 中的面向对象编程(续)
#### 7. 类的封装性
在 Java 的面向对象编程中,封装是一个重要的特性。从 `CowboyHat` 类的例子可以看出,使用 `private` 关键字修饰实例变量,如 `owner`、`size` 和 `hatOn`,这就实现了对这些变量的封装。封装的目的是保护类的内部数据,防止外部代码直接访问和修改。只有通过类内部定义的公共方法,如 `putHatOn()`、`takeHatOff()`、`changeOwner()` 和 `getSize()` 等,才能间接访问和操作这些私有变量。
封装的好处主要体现在以下几个方面:
- **数据安全性**:外部代码无法随意修改类的内部数据,只能通过类提供的方法进行操作,这样可以避免数据被错误修改,保证数据的完整性。
- **代码可维护性**:当类的内部实现发生变化时,只要公共方法的接口保持不变,外部代码就不需要进行修改。例如,如果要修改 `CowboyHat` 类中 `size` 变量的存储方式,只要 `getSize()` 方法的返回值保持一致,外部调用该方法的代码就不会受到影响。
#### 8. 构造函数的作用
构造函数是一种特殊的方法,用于创建类的对象。在 `CowboyHat` 类中,构造函数 `public CowboyHat(String person, int theSize)` 的作用是初始化 `CowboyHat` 对象的属性。构造函数的名称必须与类名相同,并且没有返回类型。
构造函数的执行过程如下:
1. 当使用 `new` 关键字创建对象时,如 `CowboyHat myHat = new CowboyHat("John", 7);`,会调用相应的构造函数。
2. 构造函数接收传入的参数,如 `person` 和 `theSize`,并将这些参数赋值给对象的实例变量,从而完成对象的初始化。
不同的构造函数可以有不同的参数列表,这就实现了构造函数的重载。例如,可以为 `CowboyHat` 类添加另一个构造函数:
```java
public CowboyHat() {
owner = "Unknown";
size = 0;
hatOn = false;
}
```
这样,在创建 `CowboyHat` 对象时,如果不传入参数,就会调用这个无参构造函数,将对象的属性初始化为默认值。
#### 9. 方法的定义和调用
在 Java 中,方法是类中执行特定任务的代码块。以 `CowboyHat` 类中的方法为例,每个方法都有特定的功能。
- `putHatOn()` 方法:将 `hatOn` 属性设置为 `true`,表示帽子戴在头上。
- `takeHatOff()` 方法:将 `hatOn` 属性设置为 `false`,表示帽子被取下。
- `changeOwner(String newOwner)` 方法:将 `owner` 属性更新为新的所有者名称。
- `getSize()` 方法:返回 `size` 属性的值。
方法的定义格式如下:
```java
[访问修饰符] [返回类型] 方法名([参数列表]) {
// 方法体
}
```
其中,访问修饰符可以是 `public`、`private` 等,用于控制方法的访问权限;返回类型指定方法执行后返回的数据类型,如果方法不返回任何值,则使用 `void`;参数列表是方法接收的输入参数。
调用方法的步骤如下:
1. 创建类的对象,如 `CowboyHat myHat = new CowboyHat("John", 7);`。
2. 使用对象名和方法名调用方法,如 `myHat.putHatOn();`。
#### 10. 面向对象编程的优势总结
面向对象编程在 Java 中具有诸多优势,以下是一个总结表格:
| 优势 | 描述 |
| ---- | ---- |
| **可维护性** | 类的封装和模块化使得代码结构清晰,易于理解和修改。当需要修改某个功能时,只需要修改相应类的内部实现,而不会影响其他部分的代码。 |
| **可扩展性** | 可以通过继承和多态等特性,方便地扩展类的功能。例如,可以创建 `CowboyHat` 类的子类,添加新的属性和方法,而不需要修改父类的代码。 |
| **可重用性** | 类和对象可以在不同的程序中重复使用。例如,`CowboyHat` 类可以在多个与帽子相关的程序中使用,提高了代码的复用率,减少了开发时间和工作量。 |
#### 11. 面向对象编程的流程总结
下面是一个使用 mermaid 绘制的流程图,展示了 Java 面向对象编程的基本流程:
```mermaid
graph LR
classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px
A(定义类):::process --> B(定义实例变量):::process
B --> C(定义构造函数):::process
C --> D(定义方法):::process
D --> E(创建对象):::process
E --> F(调用方法操作对象):::process
```
这个流程图展示了从定义类开始,到创建对象并对对象进行操作的整个过程。具体步骤如下:
1. **定义类**:使用 `class` 关键字定义类,如 `class CowboyHat`。
2. **定义实例变量**:在类中定义用于存储对象属性的变量,如 `private String owner;`。
3. **定义构造函数**:创建用于初始化对象属性的构造函数,如 `public CowboyHat(String person, int theSize)`。
4. **定义方法**:在类中定义各种方法,用于操作对象的属性,如 `putHatOn()`、`takeHatOff()` 等。
5. **创建对象**:使用 `new` 关键字和构造函数创建类的对象,如 `CowboyHat myHat = new CowboyHat("John", 7);`。
6. **调用方法操作对象**:通过对象名调用类的方法,对对象进行操作,如 `myHat.putHatOn();`。
通过以上步骤,就可以实现一个完整的 Java 面向对象程序。在实际开发中,按照这个流程进行编程,可以提高代码的质量和开发效率。
0
0
复制全文


