Risposta rapida
I modificatori di ereditarietà dei membri consentono agli sviluppatori di inserire le linee guida su come ereditare i membri di un oggetto.
Risposta lunga, noiosa, estesa
La combinazione di metodi non virtuali e metodi virtuali (e metodi "finali" o "sigillati" e "astratti"), in un algoritmo, consente di limitare un obiettivo.
Ricorda che questi modificatori possono variare da una lingua di programmazione a un'altra P.L.
-
MustInherit di V.B. è comunemente usato come virtual , in altri P.L.
-
Overriden di V.B. è comunemente usato come override , in altri P.L.
-
NotOverridable di V.B. non è usato esplicitamente in molti P.L., di solito aggiungo un piccolo commento di una riga come /* nonvirtual */ .
In Java, prima che venisse aggiunto l'indicatore @override o la direttiva, ho usato /* @override */ .
Sviluppo un sacco di O.O. programmi, di solito fatti interamente da me stesso, la maggior parte per lavoro, a volte per hobby. Anche nei piccoli programmi aggiungo i modificatori, perché la logica del programma richiede.
Un buon esempio, è quando ne combini diversi:
public class EntityClass
{
public virtual bool IsReady()
{
bool Result = false;
// depends on the class
return Result;
} // bool IsReady()
public virtual bool GenerateKey()
{
bool Result = false;
// depends on the class
return Result;
} // bool GenerateKey()
public virtual bool BeforeInsert()
{
bool Result = false;
// depends on the class
return Result;
} // bool BeforeInsert()
public virtual bool ConfirmedInsert()
{
bool Result = false;
// depends on the class
return Result;
} // bool ConfirmedInsert()
public virtual bool AfterInsert()
{
bool Result = false;
// depends on the class
return Result;
} // bool AfterInsert()
public /* nonvirtual */ bool InsertAndGenerateKey()
{
bool Result = false;
if (this.IsReady())
{
Result = GenerateKey();
if (Result)
{
Result = BeforeInsert();
if (Result)
{
Result = ConfirmedInsert();
if (Result)
{
AfterInsert();
}
}
}
} // if (this.IsReady())
return Result;
} // bool InsertAndGenerateKey
public /* nonvirtual */ bool InsertAndIgnoreKey()
{
bool Result = false;
if (this.IsReady())
{
Result = BeforeInsert();
if (Result)
{
Result = ConfirmedInsert();
if (Result)
{
AfterInsert();
}
}
} // if (this.IsReady())
return Result;
} // bool InsertAndIgnoreKey(...)
public /* nonvirtual */ bool InsertWithAssignedKey()
{
bool Result = false;
if (this.IsReady())
{
Result = BeforeInsert();
if (Result)
{
Result = ConfirmedInsert();
if (Result)
{
AfterInsert();
}
}
} // if (this.IsReady())
return Result;
} // bool InsertWithAssignedKey(...)
} // class EntityClass
In questo esempio in C #, ci sono diversi metodi, parte di una singola classe.
Verifica che i metodi non virtuali combinati, di solito chiamano altri metodi virtuali.
Questa combinazione, limitata dai modificatori, definisce un processo,
chiamato "Strategy Design Pattern", che ha un obiettivo, ma, tuttavia, consente,
alcune personalizzazioni per sottoclassi.