AbstractClass

Details
Kategorie: Design Patterns
Zugriffe: 8099

Ein Beispiel für den Aufbau einer abstrakten Klasse in C#

Im Beispiel werden zur Demonstration nicht abstrakte Klassen implementiert (Addition und PI) sowie die Abstrakte für Subtraktion, Division und Multiplikation

using System;
using System.Globalization;
 
namespace AbstractClass
{
    abstract class Calculator
    {
        public double Addition(double num1, double num2) //non abstract method
        {
            return (num1 + num2);
        }
        public abstract double Multiplikation(double num1, double num2); //abstract method       
        public abstract double Division(double num1, double num2); //abstract method       
        public abstract double Subtraktion(double num1, double num2); //abstract method       
    }
 
    class Program : Calculator
    {
        public override double Multiplikation(double n1, double n2)
        {
            return (n1 * n2);
        }
 
        public override double Division(double n1, double n2)
        {
            return (n1 / n2);
        }
 
        public override double Subtraktion(double n1, double n2)
        {
            return (n1 - n2);
        }
 
        static void Main(string[] args)
        {
            Program obj = new Program();
 
            const string fehlermeldung = "Bitte eine gültige Zahl - Format: #.#";
          
            // Abfrage der Werte
            Console.WriteLine("PI");
            double pi = GetUserInput("Ein Wert:", fehlermeldung);
             
            Console.WriteLine("Addition | Multiplikation | Subtraktion");
            double a = GetUserInput("1. Wert:", fehlermeldung);
            double b = GetUserInput("2. Wert:", fehlermeldung);
 
            Console.WriteLine("Division | Eingabe von 0 nicht erlaubt");
            double aZero = GetUserInput("1. Wert:", fehlermeldung, false);
            double bZero = GetUserInput("2. Wert:", fehlermeldung, false);
 
            // Berechnungen durchführen
            double resultPi = pi*Math.PI;
            double resultAddition = obj.Addition(a, b);
            double resultSubtraktion = obj.Subtraktion(a, b);
            double resultMultiplikation = obj.Multiplikation(a, b);
            double resultDivision = obj.Division(aZero, bZero);
 
            // Ausgabe an Benutzer
            Console.WriteLine("\nErgebnisse:");
            Console.WriteLine("PI\t\t:{0}*{1}={2}", pi, Math.PI.ToString(CultureInfo.InvariantCulture), resultPi);
            Console.WriteLine("Addition\t:{0}+{1}={2}", a, b, resultAddition);
            Console.WriteLine("Subtraktion\t:{0}-{1}={2}", a, b, resultSubtraktion);
            Console.WriteLine("Multiplikation\t:{0}*{1}={2}",a,b, resultMultiplikation);
            Console.WriteLine("Division\t:{0}+{1}={2}",aZero, bZero, resultDivision);
             
            Console.ReadLine();
 
        }
 
        static double GetUserInput(string question, string errorMessage, Boolean allowZero = true)
        {
            double a;
            Console.Write(question);
            if (double.TryParse(Console.ReadLine(), out a) )
            {
                if (!allowZero && (int)a == 0)
                {
                    Console.WriteLine("0 nicht erlaubt.");
                    a = GetUserInput(question, errorMessage);
                }
 
            }
            else{
                Console.WriteLine(errorMessage );
                a = GetUserInput(question, errorMessage);
            }
            return a;
        }
    }
}

Neuste Einträge

Composite Pattern

Dieses Pattern kann genutzt werden, um Baumähnliche Strukturen abzubilden.

Als Beispiel habe ich hier eine kleine Firmenstruktur implementiert.
Die Klasse des CompositePattrns

namespace CompositePattern
{
    interface IMitarbeiter
    {
        string Bezeichnung();
    }
 
    class Chef : IMitarbeiter
    {
        public virtual string Bezeichnung()
        {
            return "Ich bin der Chef und mache alles anders.";
        }
    }
 
    class Teamleiter : Chef, IMitarbeiter
    {
        public override string Bezeichnung()
        {
            return "Ich bin der 1. Honk vom Chef";
        }
    }
 
    class Teamleiter2 : Chef, IMitarbeiter
    {
        public override string Bezeichnung()
        {
            return "Ich bin der 2. Honk vom Chef";
        }
    }
 
    class Gruppenleiter : Teamleiter, IMitarbeiter
    {
        public override string Bezeichnung()
        {
            return "Ich bin der Gruppenleiter vom 1. Honk";
        }
    }
 
    class GruppenMitarbeiter : Gruppenleiter, IMitarbeiter
    {
        public new string Bezeichnung()
        {
            return "Ich bin GruppenMitarbeiter des Gruppenleiter´s vom 1. Honk und darf aufräumen.";
        }
    }
 
    
}

Und hier noch die Programmklasse

using System;
using System.Collections.Generic;
 
namespace CompositePattern
{
    class Program
    {
        static void Main(string[] args)
        {
 
            IMitarbeiter grpMitarbeiter = new GruppenMitarbeiter();
            IMitarbeiter grpLeiter = new Gruppenleiter();
            IMitarbeiter teamleiter = new Teamleiter();
            IMitarbeiter teamleiter2 = new Teamleiter2();
            IMitarbeiter chef = new Chef();
 
            List<imitarbeiter> objMitarbeiter = new List<imitarbeiter>();
 
 
            objMitarbeiter.Add(grpMitarbeiter);
            objMitarbeiter.Add(grpLeiter);
            objMitarbeiter.Add(teamleiter2);
            objMitarbeiter.Add(teamleiter);
            objMitarbeiter.Add(chef);
 
 
            IColor txtWeiss = new Weiss();
            txtWeiss.Draw();
             
            foreach (IMitarbeiter obj in objMitarbeiter)
            {
                //obj.Bezeichnung();
                Console.WriteLine(obj.GetType() + "\n> " + obj.Bezeichnung());
            }
 
            Console.ReadLine();
        }
    }
}
 
</imitarbeiter></imitarbeiter>

Und so sieht es aus:

Neuste Einträge