实例讲解继承封装多态(一)

最新推荐文章于 2025-06-20 18:55:22 发布
原创最新推荐文章于 2025-06-20 18:55:22 发布 · 2.8k 阅读
4 ·
CC 4.0 BY-SA版权
C++ 专栏收录该内容
28 篇文章
订阅专栏
本文深入探讨了继承、封装和多态中的一个重要概念——父类指针如何指向子类对象。通过实例解析，帮助读者理解和掌握这种编程技巧及其在实际应用中的作用。
摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >
1.

#include<iostream>
#define PI 3.1415926;
using namespace std;
class Shape  //抽象类的  定义
{
public:
 virtual double GetArea()  = 0;  //纯虚函数
 virtual double GetPerim()  = 0;  //纯虚函数
};
class Rectangle : public Shape   //矩形类，公有继承
{
public: Rectangle(double aa, double bb)   //带参数的 构造函数
  {
   a=aa;
   b=bb;
   cout<<"长"<<a<<"宽"<<b<<endl;
  }
 virtual double GetArea() 
  { 
   return a * b; 
  } 
 virtual double GetPerim()
  { 
   return 2*( a + b ); 
  }
private: 
 double a; 
 double b;
};
class Circle : public Shape    //圆类，公有继承    
 {
 public: Circle(double rr)      //带参数的 构造函数
    {
    r=rr;
    cout<<"半径"<<r<<endl;
   }  
    virtual double GetArea() 
    { 
     return r * r * PI; 
    }  
    virtual double GetPerim() 
    { 
     return 2 * r * PI;
    }
private: 
 double r;
};
 void main()
 { 
  double length, width;
  cout << "输入长和宽: "; 
  cin >> length >> width;
  Rectangle rect(length, width);
  cout << "面积是："<< rect.GetArea() << endl<<"周长是："<<rect.GetPerim()<<endl; 
   
  double rr; 
  cout << "输入半径: "; 
  cin >> rr; 
  Circle cir(rr);
  cout << "面积是："<<cir.GetArea() << endl<<"周长是："<<cir.GetPerim()<<endl;
 }







2.

/*2012年12月28日
  某公司的雇员分为以下若干类：
Employee：这是所有员工总的父类，
                     属性：员工的姓名,员工的生日月份。
                     方法：getSalary(int month) 根据参数月份来确定工资，
如果该月员工过生日，则公司会额外奖励100元。
SalariedEmployee：Employee的子类，拿固定工资的员工。
属性：月薪
HourlyEmployee：Employee的子类，按小时拿工资的员工，
每月工作超出160小时的部分按照1.5倍工资发放。
属性：每小时的工资、每月工作的小时数
SalesEmployee：Employee的子类，销售人员，工资由月销售额和提成率决定。
属性：月销售额、提成率
BasedPlusSalesEmployee：SalesEmployee的子类，有固定底薪的销售人员，
        工资由底薪加上销售提成部分。
  属性：底薪。


写一个程序，把若干各种类型的员工放在一个Employee数组里，
写一个函数，打印出某月每个员工的工资数额。
注意：要求把每个类都做成完全封装，不允许非私有化属性。
*/
public class Employee {

public Employee(String name, int month)
{
this.name = name;
this.month = month;
}

public float get_Salary(int month)
{
//如果月份为员工生日月份，则增加100的
if (month == this.month)
{
return 100;
}
else
{
return 0;
}

}

private String name;   //员工姓名
private int month;   //员工的生日月份

public static void main(String args[])
{
Employee a[] = new Employee[4];

a[0] = new SalariedEmployee("A", 2, 1000);
a[1] = new HourlyEmployee("B", 3, 2000, 200);
a[2] = new SalesEmployee("C", 4, 50000, (float) 0.1);
a[3] = new BasedPlusSalesEmployee("D", 5, 50000, (float) 0.1, 1000);

System.out.println("A的工资为" + a[0].get_Salary(2));
System.out.println("B的工资为" + a[1].get_Salary(2));
System.out.println("C的工资为" + a[2].get_Salary(2));
System.out.println("D的工资为" + a[3].get_Salary(2));

}
}


//拿固定工资的员工
class SalariedEmployee extends Employee
{
public SalariedEmployee(String name, int month, float salary)
{
super(name, month);
this.salary = salary;
}

@Override
public float get_Salary(int month)
{
return salary + super.get_Salary(month);  
}

private float salary;   //月薪
}


//按小时拿工资的员工
class HourlyEmployee extends Employee
{
public HourlyEmployee(String name, int month, float salary, int hour)
{
super(name, month);
this.salary = salary;
this.hour = hour;
}

@Override
public float get_Salary(int month)
{
//大于160小时的情况
if (hour > 160)
{
return (float) (salary * 160 + (hour - 160) * salary * 1.5 
+ super.get_Salary(month));
}
else
{
return salary * hour + super.get_Salary(month);
}
}

private float salary;  //每小时工资
private int hour;    //每月工作的小时数
}


//销售人员
class SalesEmployee extends Employee
{
public SalesEmployee(String name, int month, float sale, float bonus)
{
super(name, month);
this.sale = sale;
this.bonus = bonus;
}

@Override
public float get_Salary(int month)
{
return sale * bonus + super.get_Salary(month);
}

private float sale;  //销售额
private float bonus;  //提成率
}


//有固定底薪的销售人员
class BasedPlusSalesEmployee extends SalesEmployee
{
public BasedPlusSalesEmployee(String name, int month, float sale,
float bonus, float baseSalary)
{
super(name, month, sale, bonus);
this.baseSalary = baseSalary;
}

@Override
public float get_Salary(int month)
{
return baseSalary + super.get_Salary(month);
}

private float baseSalary; //底薪
}


/*
 * 问题一：main函数需要放在与文件同名的public类中，否则运行时一直启动上次的程序
 * 问题二：错误: 找不到或无法加载主类Test
 *      原因：原先把main函数放在Test类里面，运行发现错误后又把Test类删除，
 * 将class文件重构一下就可以了
 */











3.


#include 

class A
{
    A()
    {
        printf("A constrution.\n");
     }
    ~A()
    {
        printf("A deconstrution.\n");
    }
    void funA();
   virtual  void funB();
};

 void A::funA()
｛
        printf("A::funA ...\n");
 }    
    
void A::funB()
｛
        printf("A::funB ...\n");
}

class B : public A
{
public:
    B()
    {
        printf("B constrution.\n");
     }
    ~B()
    {
        printf("B deconstrution.\n");
    }
    void funA();
     virtual  void funB();
};

 void B::funA()
｛
        printf("B::funA ...\n");
 }    
    
void B::funB()
｛
        printf("B::funB ...\n");
}

void main()
{
    A *a = new B();
    B b;
    a-
();
    a->funB();
    b.funA();
    b.funB();
    delete a;
}
输出结果：










这个地方的理解有两处：

1. 构造函数为什么是四个？




答：

先做如下三个类假设
class A {}
class B : public A {}
class C : public B {}

若某函数 定义为 fun(A * pa);

你完全可以这样调用它，B b; fun(&b);

从逻辑上很好理解，因为类B、类C的实例是可以看作类A的实例的。
从内存上看，形如
A    --------
B    --------+++++++
C    --------+++++++~~~~~~~

- 记号表示类A的成员，+ 表示类B的成员，~表示类C的成员。示意各类占用的内存情况，可以很明显的看出来，类C的前部存放的是类B的内容，而类B的前部存放的是类A的内容。
2. 析构函数为什么是三个？




答：

这个地方的析构，在delete a;  只是调用了类A的析构函数，然后分别析构了类B和类A。




回答完毕！





父类指针指向子类对象 的理解



从概念上讲，父类指针指向之类对象是“是一个”的概念，就是说一个子类的对象也可以称为是一个父类的对象。比如一只猫也可以称为一只动物。

从内存上讲，分两种情况，如果父类不含有虚函数和含有虚函数

如果没有虚函数，那么情况很简单，子类的对象的开头部分含有父类对象的数据，也可以当做子类对象包含了一个父类对象。比如说一个父类具有两个int，继承自它的子类又定义了两个double，那么子类的内存分布是先有两个int再有两个double。这时，函数的调用的原理是简单的根据指针的类型寻找函数的地址偏移，也就是说按照父类的类定义查找函数的地址再执行，没有多态的效果。

如果有虚函数，那么父类和继承它的子类的对象内存开头都会有一个虚函数指针。然后才是像没有虚函数的时候那样的内存分布。有了这个虚函数指针，调用函数时就不再根据指针的类型来查找函数的地址，而是根据指向的对象的中的虚函数指针来查找函数的地址，由于这个虚函数指针存在于对象的内存内部，所以调用的函数是子类的版本还是父类的版本是有对象本身决定的而不是由指针的类型决定的，于是就有了多态的效果。