Erstellen Sie eine Oberklasse mit abstrakten Variablen und nicht abstrakten Methoden in C#

Question

Grundsätzlich sollte die Oberklasse Variablen (oder Eigenschaften, was auch immer funktioniert), die in den Unterklassen gesetzt werden und sollte auch Methoden, die alle Unterklassen verwenden, enthalten. Ich weiß nicht, ob es eine Möglichkeit gibt, dies zu tun, ohne 2 Klassen zu verwenden, eine, die eine Schnittstelle ist, die die Variablen enthält, und eine andere Klasse, die die Methoden enthält, aber ich nehme an, dass es solche gibt. Ich bin ziemlich neu in C#, wie Sie sich vorstellen können.

Nur zur Klarstellung, dies ist für ein Projekt in Unity und die Oberklasse wird eine allgemeine Zeichenklasse sein, die alle Unterklassen (Zeichen) verwenden.

Edit: Viele andere Variablen und Methoden werden später hinzugefügt werden, aber hier ist eine oberflächliche Vorschau von dem, was sollte es

using UnityEngine; 
using System.Collections; 

public abstract class CharacterClass : MonoBehaviour { 

    int MaxHitPoints { get; set; } 
    int ArmorRating { get; set; } 
    int Speed { get; set; } 
    int Strength { get; set; } 
    int Agility { get; set; } 

    void changeHP(int change) 
    { 
     MaxHitPoints += change; 
    } 

} 

Answer 1

die Super

eine allgemeine Zeichenklasse wird sein? Aber warte, es gibt so etwas wirklich nicht - Unity ist ein ECS-System.

Sie können nur GameObject s Komponenten hinzufügen. (Das heißt, Verhaltensweisen - alles, was Sie tun können, ist hinzuzufügen Verhalten (Renderer, Knochen Animatoren, Timer, Kameras, Collider, was auch immer) zu GameObject s

Es gibt keine Vererbung oder etwas wie Vererbung in Unity, es ist nicht auch nur vage OO. mit Unity viel ist wie Photoshop sagen!

(natürlich ist die Sprache, die derzeit als das Schreibens verwendet werden geschieht, Komponenten in der Einheit zu schreiben, ist eine OO-Sprache, aber das ist irrelevant, könnte ändere morgen, das macht Unity in keiner Weise OO.)

Answer 2

Objektorientierte Programmierkonzepte sind in Unity noch verwendbar Erstellen Sie Entitäten aus Komponenten.

using UnityEngine; 

public abstract class Character : MonoBehaviour 
{ 
    public int HitPoints { get; set; } 

    public virtual void ChangeHP(int amount) 
    { 
     HitPoints += amount; 
    } 

    void OnCollisionEnter(Collision other) 
    { 
     if (other.gameObject.CompareTag("DeathTrigger")) 
     { 
      Die(); 
     } 
    } 

    protected virtual void Die() 
    { 
     Debug.Log("I'm dead."); 
    } 
} 

public class LordOfTerror : Character 
{ 
    protected override void Die() 
    { 
     base.Die(); 
     Debug.Log("But I also come back from the dead very soon."); 
     HitPoints = 100; 
    } 
} 

Aber es ist wahr, dass diese Art der Programmierung funktioniert nur für kleine Erbschaft Bäume und nur mit einigen Einschränkungen oder Abhilfen Sie in Unity gewöhnen müßten. Im Allgemeinen ist es sinnvoll, Komponenten so weit wie möglich zu integrieren. Hier ist eine Variation auf das Beispiel zeigt, wie Sie objektorientiert mit Zusammensetzung kombinieren könnte:

using System; 
using UnityEngine; 

public abstract class StatAttribute 
{ 
    public int current; 
    public int min; 
    public int max; 

    public void Change(int amount) 
    { 
     current += amount; 
    } 
} 

public sealed class Health : StatAttribute 
{ 
    public event Action tookDamage; 

    public bool isAlive 
    { 
     get { return current > min; } 
    } 

    public void Damage(int amount) 
    { 
     base.Change(-amount); 
     // also fire an event to make other components play an animation etc. 
     if(tookDamage != null) 
      tookDamage(); 
    } 
} 

public sealed class Speed : StatAttribute 
{ 
    public int boost; 

    public int GetFinalSpeed() 
    { 
     return base.current * boost; 
    } 
} 

Normalerweise Sie beginnen mit einzelnen Komponenten Gameobjects angebracht. Alle zusammen bilden Ihr Zeichen. Sie haben Dinge wie Gesundheit, CharacterMovement, PlayerInput, Animation, usw. Irgendwann Ihr Hinweis, dass Code dupliziert und das ist, wo es Sinn machen könnte bestimmte Basisklassen zwischen den Komponenten zu teilen.