在繼承

Question

更換對象我有一個包含兩個原始和自定義屬性的類：

public class Version_1 
{ 
    public string Name { get; set; } 
    public int Age { get; set; } 
    public WeirdDad Weird { get; set; } 
    public MysteriousDad Mysterious { get; set; } 
} 

在未來，我希望有一個int屬性加我的自定義對象之一的定製擴展類，在這樣：

public class Version_2 : Version_1 
{ 
    public string IdentityCode { get; set; } 
    public WeirdChild Weird { get; set; } 
} 

在Version_2類中，WeirdDad對象的外觀已被其子WeirdChild替換，所以我想替換它。 在這個例子中，我將在Version_2類中同時使用WeirdDad和WeirdChild。

你將如何實現這個例子？

Answer 1

想繼承+多態性

下面是一些代碼，我會照顧做出點.. 。

public abstract class WeirdPerson() { 
    public virtual void DoThis() { 
     // base/default implementation as desired 
    } 

    public virtual void DoThat() { // ditto } 
    public abstract void GoWildAndCrazy; 
} 

public class WeirdChild : WeirdPerson { 
    public override void DoThis() { // weird child behavior} 
    // etc. 
} 

public class WeirdDad : WeirdPerson { 
    // override and add methods as needed. 
} 

public class Version_1 
{ 
    public string Name { get; protected set; } 
    public int Age { get; protected set; } 
    public WeirdPerson WeirdFamilyMember { get; protected set; } 
    public MysteriousDad Mysterious { get; protected set; } 

    public Version_1 (WeirdChild child, string name, int age, MysteriousDad Dad) { 

    } 
} 

public class Version_2 : Version_1 { 
    public Version_2 (WeirdDad dad, string name, int age, MysteriousDad grandfather) : base (dad, name, age, grandfather) {} 
} 

---

• WeirdPerson - 爲所有子類型定義基本內容的更一般概念。
  • 子類型將得到「固定」之類的東西Name - 繼承
  • 子類型可以override默認行爲（方法） - 多態性
  現在
  • 我們沒有滑稽的東西： public class WeirdDad : WeirdChild
• 構造
  • Version_1,Version_2構造函數強制客戶端提供正確的WeirdPerson子類型。
  • 客戶必須給我們所有必需的東西。
  • 我們可以驗證/交叉驗證傳入參數。
• 我們不需要任何討厭的interface
  • abstract類允許我們有默認的行爲（方法）和默認狀態（性質）的任何類的
  • public方法和屬性是一般意義上的接口。我們不需要（C＃關鍵字）interface爲了遵循原理代碼接口不執行
  • abstract方法強制子類實現。只是。喜歡。一個。interface。
• new
  • 警告。方法隱藏在當時斷開了繼承鏈。如果我們從這個類繼承，我們不會繼承原始基類的方法實現。
• 里氏是幸福的。

---

附加重構

充分利用Version層次結構平行的WeirdPerson層次結構

假設這適合你的設計。我想，一年之後，你會很高興你做到了。

public abstract class Version_X { 
    // all the original properties here. 

    // virtual and abstract methods as needed 

    // LOOK! standard-issue constructor! 
    protected Version_X (WeirdPerson person, ...) { // common validation, etc. } 
} 

public class Version_1 : Version_X { 
    public Version_1(WeirdChild child, ...) : base (child, ...) {} 
} 

public class Version_2 : Version_X { 
    public Version_2 (WeirdDad dad, ...) {} 
} 

---

編輯 - 通過comment discussion with DVK

最少知識原理的啓發說，客戶不應該知道內部細節使用類。需要知道如何撰寫正確的Version和Weird是一種違規行爲，可以爭辯。

讓我們假設一個默認的構造函數，爲Visitor比方說，有必要在整體設計別處。允許這意味着客戶可以控制Version/Weird組合。

抽象 - 鬆散耦合 - 在abstract類。具體類必須正確組成，所以「強耦合」在創建具體對象（顯式類型構造函數參數）中是固有的，但底層鬆耦合允許具有所需的靈活性。

public enum WeirdFamily { Child, Dad, Mother, TheThing } 

public static class AdamsFamilyFactory() { 
    public static Version_X Create (WeirdFamily familyMember) { 
     switch (familyMember) { 
      case Dad: 
       return BuildAdamsDad(); 
     // . . . 
     } 
    } 
} 

public static class MunstersFactory() { // Munsters implementation } 

// client code 

List<Version_X> AdamsFamily = new List<Version_X>(); 
Version_X Pugsly = AdamsFamilyFactory.Create(WeirdFamily.Child); 
AdamsFamily.Add(Pugsly); 

List<Version_X> Munsters= new List<Version_X>(); 
Version_X Eddie= MunstersFactory.Create(WeirdFamily.Child); 
Munsters.Add(Eddie); 

DoTheMonsterMash(Munsters); 
DoTheMonsterMash(AdamsFamily); 

public void DoTheMonsterMash(List<Version_X> someWeirdFamily { 
    foreach (var member in someWeirdFamily) 
     member.GoWildAndCrazy(); 
} 

Answer 2

我相信你想要做的就是所謂的方法隱藏。你VERSION_2類應該是這樣的：

public class Version_2 : Version_1 
{ 
    public string IdentityCode { get; set; } 
    public new WeirdChild Weird { get; set; } 
} 

當您要訪問從VERSION_1的「古怪」屬性，你將不得不作出一個呼叫base.Weird

請記然而，這是不推薦是一種代碼味道。

Answer 3

恕我直言，VERSION_2不應該繼承VERSION_1，因爲它不能完全表現像VERSION_1：

Version_2 version_2Instance = new Version_2(); 
version_2Instance.Weird = new WeirdDad(); 

不要忘記繼承假設您正在擴展的基類，而不是對矯正它。

如何使用模板類和抽象基類：

public abstract class VersionBase<T> 
{ 
    public string Name { get; set; } 
    public int Age { get; set; } 
    public abstract T Weird { get; set; } 
    public MysteriousDad Mysterious { get; set; } 
} 

然後：

public class Version_1 : VersionBase<WeirdDad> 
{ 
    public override WeirdDad Weird { get; set; } 
} 

public class Version_2 : VersionBase<WeirdChild> 
{ 
    public string IdentityCode { get; set; } 
    public override WeirdChild Weird { get; set; } 
} 

Answer 4

你需要重新考慮你正在嘗試做的一點點事情，因爲你所提議打破Liskov替換校長。

來源：https://en.wikipedia.org/wiki/Liskov_substitution_principle

可替代性是面向對象編程的一個原則。它指出，在一個計算機程序中，如果S是T的一個子類型，那麼類型T的對象可以用類型S的對象代替（即，類型S的對象可以替換類型T的對象），而不會改變任何合意的該程序的屬性（正確性，執行的任務等）。

如果只想VERSION_2包含一個WeirdChild，而不是任何類型實現WeirdDad類的，這是可以做到的，但你需要備份的水平，並開始在思維泛型，接口，和/或抽象類。

例如：

public interface IWeirdFamilyMember 
{ 
    // put some properties here 
} 

public interface IMyClass<T> where T: IWeirdFamilyMember 
{ 
    string Name { get; set; } 
    int Age { get; set; } 
    T Weird { get; set; } 
} 

最後，你可以定義你的階級作爲階級：

public class Version_1 : IMyClass<WeirdDad> 
{ 
    string Name { get; set; } 
    int Age { get; set; } 
    WeirdDad Weird { get; set; } 
} 

public class Version_2 : IMyClass<WeirdChild> 
{ 
    string Name { get; set; } 
    int Age { get; set; } 
    WeirdChild Weird { get; set; } 
} 

與Ksv3n的例子的問題是，你是假設開發商分配WeirdDad的WeirdChild子到奇怪的財產，實際上，它可以是任何類型的WeirdDad，或者一個WeirdDad本身。這是運行時異常的祕訣。

Answer 5

我同意@CodingMadeEasy，使用新是一個嗅覺代碼。

因此，我建議使用顯式接口實現。

interface IVersion_1 
{ 
    WeirdDad Weird { get; set; } 
} 


interface IVersion_2 
{ 
    WeirdChild Weird { get; set; } 
} 

class Version_1 : IVersion_1 
{ 
    public string Name { get; set; } 
    public int Age { get; set; } 
    public WeirdDad Weird { get; set; } 
    public MysteriousDad Mysterious { get; set; } 
} 

class Version_2 : Version_1, IVersion_2 
{ 
    public string IdentityCode { get; set; } 
    WeirdChild IVersion_2.Weird { get; set; } 
} 

所以在客戶端，這取決於接口的類型，正確的屬性將被稱爲