继承和多态的代码示例

父类
// 抽象方法
// 抽象类 abstract
public abstract class Vehicle {
	private String no;
	private String brand;
	private String color;
	private float mileage;

	public String getNo() {
		return no;
	}

	public void setNo(String no) {
		this.no = no;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public float getMileage() {
		return mileage;
	}

	public void setMileage(float mileage) {
		this.mileage = mileage;
	}

	// 必须有一个空构造方法
	public Vehicle() {
		super();
	}

	public Vehicle(String no) {
		super();
		this.no = no;
	}

	// 抽象方法 abstract
	// 抽象类
	public abstract float calRent(int day);

}


子类

public class Car extends Vehicle {
	private String type;

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

	public Car() {
		super();
	}

	public Car(String no, String type) {
		super(no);
		this.type = type;
	}

	public float calRent(int days) {
		switch (type) {
		case "gl8":
			return 600 * days;
		case "550i":
			return 500 * days;
		case "bk":
			return 300 * days;

		}
		return 0;
	}

}

子类


public class Bus extends Vehicle {
	private int seartCount;

	public int getSeartCount() {
		return seartCount;
	}

	public void setSeartCount(int seartCount) {
		this.seartCount = seartCount;
	}

	public Bus() {
		super();
	}

	public Bus(String no, int seartCount) {
		super(no);
		this.seartCount = seartCount;
	}

	public float calRent(int days) {
		if (seartCount <= 16)
			return 800 * days;
		else
			return 1500 * days;

	}
}

测试类

public class Test {
	public static void main(String[] args) {
		Car car = new Car("11111", "bk");
		System.out.println(car.calRent(10));

		Bus bus = new Bus("22222", 19);
		System.out.println(bus.calRent(10));

		// 多态:多种形态 程序执行结果随着父类变量指向的不同而改变
		// 子类对象可以直接赋值给父类变量
		Vehicle vehicle = new Car("11111", "gl8");
		System.out.println(vehicle.calRent(10));
		Vehicle vehicle2 = new Bus("2222", 6);
		System.out.println(vehicle2.calRent(10));
	}

}


<think>嗯,用户之前问了关于C++构造函数的问题,现在又转向了面向对象的三大特性:封装、继承多态。看起来他们可能在系统学习C++的面向对象编程部分。需要给出清晰的代码示例,同时解释每个特性的基本概念应用场景。 首先,用户需要的是代码示例,所以每个特性都应该有对应的代码段。要确保代码简洁易懂,避免复杂化。然后,每个部分需要简要说明,让用户能够理解这些特性是如何在代码中体现的。 封装部分,应该展示如何通过访问修饰符(public、private、protected)来隐藏内部数据,提供公共接口。比如一个类有私有成员变量,然后通过公共方法进行访问修改。 继承的话,可以选一个基类派生类的例子,比如AnimalDog,展示派生类如何继承基类的成员,并且可以扩展自己的方法。同时,可能需要提到继承的类型,比如公有继承、保护继承等,但用户可能更关注基本应用,所以先展示公有继承例子多态部分,需要涉及虚函数动态绑定。基类中声明虚函数,派生类重写,然后通过基类指针或引用来调用派生类的方法。最好用一个例子,比如基类Shape派生类Circle、Rectangle,展示如何通过基类指针调用不同派生类的draw方法。 用户可能对这三个概念的实际应用不太清楚,所以需要解释每个特性的作用好处。比如封装提高安全性,继承促进代码复用,多态增强扩展性等。 另外,要注意用户可能对C++的语法不太熟悉,所以代码示例中的关键字如virtual、public、private等需要适当解释,但不要过于深入,保持简洁。 可能的疑问点:为什么使用虚函数?为什么要用public继承?是否需要提及虚析构函数?可能用户的问题比较基础,暂时不需要深入虚析构函数,但可以提到多态需要基类虚函数的存在。 需要检查代码示例是否有错误,比如继承的语法是否正确,虚函数是否正确使用,以及多态调用的方式是否正确。确保示例能够编译运行,不会有语法错误。 总结一下,回答结构应该是先分别介绍封装、继承多态,每个部分一个代码示例,加上解释,最后可能总结三者如何共同作用。确保语言口语化,避免技术术语堆砌,但关键术语仍需准确使用。</think>好的!以下是一个结合 **封装、继承多态** 的 C++ 代码示例,并逐段解释其核心思想: --- ### 📦 **1. 封装(Encapsulation)** **核心**:隐藏内部数据,通过公共方法控制访问。 ```cpp #include <iostream> #include <string> using namespace std; // 基类:Animal(封装了私有成员 name) class Animal { private: string name; public: Animal(string n) : name(n) {} // 公共方法访问私有成员 string getName() const { return name; } // 虚函数:为多态留接口 virtual void speak() const { cout << name << " makes a sound." << endl; } }; ``` **解释**: - `name` 是私有成员,外部无法直接修改,必须通过 `getName()` 方法访问。 - `speak()` 是虚函数,为派生类的多态行为提供基础。 --- ### 🧬 **2. 继承(Inheritance)** **核心**:派生类继承基类的属性方法,并扩展新功能。 ```cpp // 派生类 Dog(继承 Animal) class Dog : public Animal { public: Dog(string name) : Animal(name) {} // 重写基类虚函数 void speak() const override { cout << getName() << " says: Woof!" << endl; } }; // 派生类 Cat(继承 Animal) class Cat : public Animal { public: Cat(string name) : Animal(name) {} void speak() const override { cout << getName() << " says: Meow!" << endl; } }; ``` **解释**: - `Dog` `Cat` 继承自 `Animal`,获得 `name` 属性 `speak()` 方法。 - 通过 `override` 关键字重写 `speak()`,实现不同动物的叫声。 --- ### 🔄 **3. 多态(Polymorphism)** **核心**:同一接口在不同派生类中表现不同行为。 ```cpp int main() { // 基类指针指向派生类对象 Animal* animals[] = { new Dog("Buddy"), new Cat("Whiskers") }; // 多态调用 speak() for (Animal* animal : animals) { animal->speak(); // 根据实际对象类型调用对应方法 } // 释放内存 delete animals[0]; delete animals[1]; return 0; } ``` **输出**: ``` Buddy says: Woof! Whiskers says: Meow! ``` **解释**: - 基类指针 `Animal*` 可以指向 `Dog` 或 `Cat` 对象。 - 通过虚函数 `speak()`,实际调用的是派生类重写的方法,实现**动态绑定**。 --- ### 🔑 **关键点总结** | 特性 | 作用 | 实现方式 | |----------|--------------------------------------------|-----------------------------------| | **封装** | 保护数据,提供安全接口 | `private`/`public` 访问修饰符 | | **继承** | 复用代码,建立类层次结构 | `class Derived : public Base` | | **多态** | 同一接口不同实现,增强扩展性 | 虚函数(`virtual` + `override`) | --- ### 🛠️ **深入理解** 1. **虚函数表(vtable)**: - 编译器为含虚函数的类生成虚函数表,存储函数地址。 - 多态调用时通过查表确定实际调用的函数。 2. **动态绑定 vs 静态绑定**: - **动态绑定**(多态):运行时确定函数调用(通过虚函数)。 - **静态绑定**:编译时确定函数调用(如非虚函数)。 3. **纯虚函数抽象类**: - 若基类的虚函数无实际意义,可声明为纯虚函数: ```cpp virtual void speak() const = 0; // 纯虚函数 ``` - 包含纯虚函数的类称为**抽象类**,不能实例化。 --- ### 🌰 **实际应用场景** - **游戏开发**:基类 `Enemy`,派生类 `Boss`、`Monster` 实现不同行为。 - **GUI 框架**:基类 `Widget`,派生类 `Button`、`TextBox` 重写绘制方法。 - **数据处理**:基类 `DataProcessor`,派生类 `CSVProcessor`、`JSONProcessor` 实现不同解析逻辑。 如果有具体需求,可以进一步优化代码设计! 🚀
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值