一、本章知识回顾
面向对象基础概念表格
知识点 说明
类 对象的模板，描述一类事物的共同特征
对象 类的具体实例
成员变量 对象的属性（状态）
成员方法 对象的行为（功能）
构造方法 创建对象时初始化成员变量
this关键字 指向当前对象的引用
对象的组合 一个类把其他类的对象作为成员
二、为什么需要类与对象？
2.1 问题引入
假设要处理小明养的两只狗的信息：
| 狗名 | 年龄 | 颜色 |
|---|---|---|
| 小白 | 3岁 | 白色 |
| 小花 | 10岁 | 花色 |
表格转换结果
狗名 年龄 颜色
小白 3岁 白色
小花 10岁 花色
如果用之前学过的数组来处理：
String[] dog1 = {“小白”, “3”, “白色”};
String[] dog2 = {“小花”, “10”, “花色”};
AI写代码
java
运行
数组方式的问题：
数据类型不明确（年龄”3”是字符串，不方便计算）
通过下标获取信息（dog1[0]是名字，dog1[1]是年龄，容易混淆）
不能体现狗的行为（如”叫”、”跑”等）
解决方式：用类来定义狗的特征和行为，用对象来表示具体的某只狗。
三、类的定义
3.1 类的基本结构
类是Java中最基本的”模板”，用来描述一类事物的属性（成员变量）和行为（成员方法）。
java
class Dog {
// 1. 成员变量（属性）
String name; // 名字
int age; // 年龄
String color; // 颜色
// 2. 成员方法（行为）
void bark() {
System.out.println(name + "：汪汪汪！");
}
void run() {
System.out.println(name + "正在奔跑");
}
void showInfo() {
System.out.println("名字：" + name + "，年龄：" + age + "岁，颜色：" + color);
}
}
3.2 成员变量
位置：在类中、方法外部定义
作用：描述对象的属性（状态）
默认值：即使不赋值，也有默认初始值
类型 默认值
int 0
double 0.0
boolean false
char ‘\u0000’
引用类型（String等） null
3.3 成员方法
位置：在类中定义
作用：描述对象的行为（功能）
结构：修饰符 + 返回值类型 + 方法名 + 参数列表 + 方法体
java
// 方法结构示例
public void bark() { // 无返回值，无参数
System.out.println(“叫”);
}
public int add(int a, int b) { // 有返回值，有参数
return a + b;
}
四、对象的创建与使用
4.1 创建对象（实例化）
使用 new 关键字 + 构造方法创建对象：
java
public class DogTest {
public static void main(String[] args) {
// 创建Dog类的对象
Dog dog1 = new Dog(); // 声明 + 创建 + 赋值
// 或者分两步写
Dog dog2; // 1.声明对象变量
dog2 = new Dog(); // 2.创建对象（分配内存）
}
}
4.2 使用对象
通过 对象名.成员变量 和 对象名.成员方法() 来访问：
java
public class DogTest {
public static void main(String[] args) {
// 创建对象
Dog dog1 = new Dog();
Dog dog2 = new Dog();
// 给成员变量赋值
dog1.name = "小白";
dog1.age = 3;
dog1.color = "白色";
dog2.name = "小花";
dog2.age = 10;
dog2.color = "花色";
// 调用成员方法
dog1.showInfo(); // 输出：名字：小白，年龄：3岁，颜色：白色
dog1.bark(); // 输出：小白：汪汪汪！
dog2.showInfo(); // 输出：名字：小花，年龄：10岁，颜色：花色
dog2.run(); // 输出：小花正在奔跑
}
}
运行结果：
text
名字：小白，年龄：3岁，颜色：白色
小白：汪汪汪！
名字：小花，年龄：10岁，颜色：花色
小花正在奔跑
4.3 类与对象的关系图
text
┌─────────────────────────────────────┐
│ 类（模板） │
│ ┌─────────────────────────────────┐ │
│ │ class Dog { │ │
│ │ String name; // 成员变量 │ │
│ │ int age; │ │
│ │ void bark() {…} // 方法 │ │
│ │ } │ │
│ └─────────────────────────────────┘ │
└─────────────────────────────────────┘
│
│ 实例化（new）
↓
┌───────────────────────┐ ┌───────────────────────┐
│ 对象1（实例1） │ │ 对象2（实例2） │
│ ┌─────────────────┐ │ │ ┌─────────────────┐ │
│ │ name = “小白” │ │ │ │ name = “小花” │ │
│ │ age = 3 │ │ │ │ age = 10 │ │
│ │ color = “白色” │ │ │ │ color = “花色” │ │
│ └─────────────────┘ │ │ └─────────────────┘ │
└───────────────────────┘ └───────────────────────┘
核心理解：
类：图纸（抽象）
对象：根据图纸造出的房子（具体）
同一个类可以创建多个对象，每个对象有自己的属性值
五、构造方法
5.1 什么是构造方法？
构造方法是专门用来创建对象时初始化成员变量的特殊方法。
特点：
方法名与类名相同
没有返回值类型（连void都不写）
创建对象时自动调用
5.2 无参构造方法
java
class Dog {
String name;
int age;
// 无参构造方法
Dog() {
System.out.println("一只新的狗被创建了");
}
}
public class Test {
public static void main(String[] args) {
Dog dog = new Dog(); // 自动调用构造方法，输出：一只新的狗被创建了
}
}
5.3 有参构造方法
java
class Dog {
String name;
int age;
String color;
// 有参构造方法
Dog(String n, int a, String c) {
name = n;
age = a;
color = c;
System.out.println("创建了：" + name);
}
void showInfo() {
System.out.println("名字：" + name + "，年龄：" + age + "，颜色：" + color);
}
}
public class Test {
public static void main(String[] args) {
// 创建对象时直接传入参数
Dog dog1 = new Dog(“小白”, 3, “白色”);
Dog dog2 = new Dog(“小花”, 10, “花色”);
dog1.showInfo(); // 名字：小白，年龄：3，颜色：白色
dog2.showInfo(); // 名字：小花，年龄：10，颜色：花色
}
}
5.4 注意事项
情况 说明
没有定义任何构造方法 系统自动提供无参构造方法
定义了有参构造方法 系统不再提供无参构造方法
想同时使用两种 需要重载构造方法（手动写两个）
六、this关键字
6.1 解决命名冲突
当成员变量和局部变量（包括参数）同名时，this.成员变量 表示成员变量。
java
class Dog {
String name;
int age;
// 参数名和成员变量名相同
Dog(String name, int age) {
this.name = name; // this.name 是成员变量，name 是参数
this.age = age;
}
void showInfo() {
System.out.println("名字：" + name + "，年龄：" + age);
}
}
为什么需要this？
如果不写this，会发生”局部变量覆盖成员变量”：
java
// 错误写法
Dog(String name, int age) {
name = name; // 左边和右边都是参数name，成员变量name没有被赋值
age = age; // 同样的问题
}
6.2 this的其他用法
java
class Dog {
String name;
Dog() {
this("无名"); // 调用本类的有参构造方法
}
Dog(String name) {
this.name = name;
}
}
七、对象的组合
一个类可以把其他类的对象作为自己的成员变量，这叫对象的组合。
示例：人养狗
java
// 狗类
class Dog {
String name;
int age;
Dog(String name, int age) {
this.name = name;
this.age = age;
}
void bark() {
System.out.println(name + "：汪汪！");
}
}
// 人类（组合了Dog类）
class Person {
String name;
Dog pet; // 把Dog对象作为成员变量
Person(String name, Dog pet) {
this.name = name;
this.pet = pet;
}
void walkPet() {
System.out.println(name + "正在遛 " + pet.name);
pet.bark();
}
void showInfo() {
System.out.print(name + "的宠物：");
System.out.println("名字：" + pet.name + "，年龄：" + pet.age + "岁");
}
}
public class Test {
public static void main(String[] args) {
// 先创建狗
Dog dog = new Dog(“小白”, 3);
// 再创建人（把狗作为参数传入）
Person person = new Person("小明", dog);
person.showInfo(); // 小明的宠物：名字：小白，年龄：3岁
person.walkPet(); // 小明正在遛小白 \n 小白：汪汪！
}
}
运行结果：
text
小明的宠物：名字：小白，年龄：3岁
小明正在遛小白
小白：汪汪！
八、完整示例：有理数类（教材例题）
根据教材第4章的有理数类例题，以下是一个完整的封装示例：
java
/**
有理数类（封装分数）
成员变量：分子、分母
成员方法：加法、减法、乘法、除法、化简
*/
class Rational {
int numerator; // 分子
int denominator; // 分母// 构造方法
Rational(int numerator, int denominator) {
this.numerator = numerator;
this.denominator = denominator;
reduce(); // 创建时自动化简
}// 求最大公约数（用于化简）
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}// 化简分数
void reduce() {
int g = gcd(numerator, denominator);
numerator /= g;
denominator /= g;
}// 加法
Rational add(Rational r) {
int newNum = this.numerator * r.denominator + r.numerator * this.denominator;
int newDen = this.denominator * r.denominator;
return new Rational(newNum, newDen);
}// 减法
Rational subtract(Rational r) {
int newNum = this.numerator * r.denominator - r.numerator * this.denominator;
int newDen = this.denominator * r.denominator;
return new Rational(newNum, newDen);
}// 输出分数
void display() {
if (denominator == 1) {
System.out.println(numerator);
} else {
System.out.println(numerator + “/“ + denominator);
}
}
}
public class RationalTest {
public static void main(String[] args) {
Rational r1 = new Rational(1, 3); // 1/3
Rational r2 = new Rational(2, 5); // 2/5
System.out.print("1/3 + 2/5 = ");
r1.add(r2).display(); // 11/15
System.out.print("1/3 - 2/5 = ");
r1.subtract(r2).display(); // -1/15
}
}
九、常见错误与注意点
错误写法 正确写法 说明
Dog dog; dog.name = “小白”; Dog dog = new Dog(); 必须先创建对象才能使用
class dog { … } class Dog { … } 类名首字母大写（规范）
构造方法写了返回值类型 Dog() { }（无void） 构造方法不能有返回值
this 在静态方法中使用 只能在非静态方法中使用 static方法中不能用this
忘记写构造方法导致无法初始化 提供合适的构造方法 或使用setter方法赋值
十、小结
本章学习了：
类的定义：成员变量 + 成员方法
对象的创建：使用 new 关键字
构造方法：与类同名，无返回值，用于初始化
this关键字：区分成员变量和局部变量
对象的组合：一个类包含其他类的对象
核心代码模板：
java
class 类名 {
// 1. 成员变量
数据类型 变量名;
// 2. 构造方法
类名(参数列表) {
this.成员变量 = 参数;
}
// 3. 成员方法
返回值类型 方法名(参数列表) {
// 方法体
}
}
// 使用
类名 对象名 = new 类名(参数);
对象名.方法名();
