Observer pattern when all observers adhere to common interface?!

Hi,

I have an assignment to implements bridge,factory method,singleton and
observer pattarns

There is a single bank which contains SavingAccounts
When the there is a change to the bank it needed to notify all accounts
owners

So i have been told that a SavingAccount should be an observer
But since ALL accounts type adhere to common interface(Account) i
wonder
why should it be an observer as well?!?! isnt observer is for objects
which doensot
adhere to common interface?

Thanks in advance.

class Account
{
public:

    Account(AccountType Type,string Name,int Duration,int
PercentOnDeposit,int OpenningYear,int InitialDeposit);
    virtual ~Account();

    //Requests forwards to implementation
    virtual int GetSavingPeriod();
    virtual int GetSavingTime();
    virtual AccountType GetAccountType();

    //Requests handle by Account
    virtual bool Transfer(int amount,std::string
sourceAccount="",string
destinationAccount="")=0;
    virtual bool Close()=0;

protected:

    static AccountImpl* ImplementationFactory(AccountType
accountType,int
SavingPeriod,int PercentOnDeposit,int OpenningYear,int InitialDeposit);

    AccountImpl* GetAccountImpl();

    private:

    AccountImpl* m_Impl;

};

//
// Account implementation abstraction
//
class AccountImpl
{
public:
    virtual ~AccountImpl();

    virtual bool DrawMoney()=0;
//Close the account
    virtual AccountType GetAccountType()=0;
    //Tansfer money from source to destination
    virtual bool MakeTransfer(int amount,string
source="",

string destination="")=0;

    //Common for all implementations
    int GetSavingPeriod();
//for how long this account is opened
    float GetPercentOnDeposit();
    int GetSavingTime();
//how much time passed from openning
    int GetCurrentBalance();

protected:

    AccountImpl(int Duration,int PercentOnDeposit,int OpenningYear,int
InitialDeposit);

    int m_SavingPeriod;
    float m_PercentOnDeposit;
    int m_OpenningYear;
    int m_CurrentBalance;

};

//
// Refined account abstraction
//
class SavingAccount:public Account
{
    friend class Account;

public:
                SavingAccount(AccountType accountType,string
Name,int
OpenningYear,int Duration,int Percentege,int InitialDeposit);
    virtual ~SavingAccount();

    bool Transfer(int amount,std::string
sourceAccount="",string
destinationAccount="");
    bool Close();

protected:

    void AuditForIncomeTax(string message);

};

class Bank:public Subject
{
public:

    virtual ~Bank();

    static Bank& getObj() { return sng; }

    void OpenAccount(AccountType accountType,string name,int
OpenningYear,int SavingPeriod,int Percentege,int InitialDeposit);

    void InvestInStockExchange(int amount);
    void GiveBonus(int amount);
    void InviteForMeeting(string message);
    Account* GetAccount(string OwnerName);

    void CloseAll();
    //Subject implementation
    string GetBulletin();

    typedef vector<Account*>::iterator accountIt;

private:

    static Bank sng;
    Bank();
    Bank(const Bank& bank);
    void operator =(Bank& bank);
    vector<Account*> m_accounts;
    string m_latestNews;

};

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]