klasy abstrakcyjne w projekcie zaliczeniowym

Witam

Mam napisać program na zaliczenie (także w wersji okienkowej), który będzie obsługiwał u klientów 3 rodzaje kont (jeden klient może mieć różne rodzaje konta): 1 rodzaj to konto bieżące można wpłać tam pieniądze, wypłać tylko do wielkości środków na koncie, 2 rodzaj konto oszczędnościowe z którego nie można wypłacić a wpłacić można tylko raz na początku nie można dokładać pieniędzy, 3- rodzaj to konto kredytowe można z niego wypłacać nawet jak saldo jest ujemne ale wpłać można tylko do wielkości debetu. Chcę to zrobić za pomocą klasy abstrakcyjnej Konto z której wszystkie inne dziedziczą. Poniżej podaje kody wszystkich klas, czy możecie powiedzieć czy taka logika ma sens. Następnie klasy nie abstrakcyjne będą listą kont u danego klienta.
klasa abstrakcyjna

 abstract class Konto
    {
        public double saldo = 0;

        public double Wplac(double kwota)
        {
            saldo += kwota;
            return saldo;
        }

        public double Wyplac(double kwota)
        {
            saldo -= kwota;
            return saldo;
        }
    }

klasa konto bieżące

    class Biezace : Konto
    {
        public double Wplacaj(double kwota)
        {
            base.Wplac(kwota);
            return saldo;
        }
        public double Wyplacaj(double kwota)
        {
            if (saldo >= kwota)
                base.Wyplac(kwota);
            return saldo;
        }
    }

klasa oszczednosci

    class Lokata : Konto
    {
        public double Wplacanie(double kwota)
        {
            if (saldo == 0)
                base.Wplac(kwota);
           

            return saldo;

        }
    }

klasa kredytowe konto

  class Debet: Konto
    {
        public double Wplac(double kwota)
        {
            if (saldo <= kwota)
                base.Wplac(kwota);
            return saldo;
        }
        public double Wyplacanie(double kwota)
        {
            base.Wyplac(kwota);
            return saldo;
        }
    }

klasa klienta z listą kont

   class Klient
    {
        private string nazwisko;

        public Lokata Lokata { get; set; }
        public Debet Debet { get; set; }
        public Biezace Biezace { get; set; }
  }

na razie wymyśliłam to tak, na razie chodzi mi o samą logiczność, nanstępnie w xaml będę musiała to jeszcze uzupełnić o binding.
Dziękuję

Myślę, że lepszą opcją byłby tutaj interface, bo saldo teoretycznie nie może być ujemne, więc w zależności co implementuje ten interface będzie miał nieco inną obsługę metod wpłacać i wypłacać. Moim zdaniem metoda Wypłacanie nie powinna być typu double, tylko void.

Metody w klasie abstrakcyjnej mogłyby być chronione, a nie publiczne. Poza tym zmienił bym ich nazwy na ZwiekszSaldo i ZmniejszSaldo, bo w tym momencie jest trochę mylące, że istnieje w kodzie metoda Wplac i Wplacanie. Logika raczej ok.

Ja bym w tym przypadku potraktował klienta jako agregat, a nie encje, tak samo, jak konta i powiązał je wartością IdKlienta i IdKonta. Klient zawierałby listę wartości IdKont i metody jak "otwórz konto, zamknij konto". Każdy agregat innego rodzaju konta miałby inne metody jak "Dokonaj wpłaty" lub "Spłać zadłużenie" zawierał by również listę transakcji. Stan konta byłby też wartością można by do niego użyć wzorca Money.

Ale po co się tak, męczyć skoro twój nauczyciel i tak pewnie będzie miał to w nosie albo co gorsza nie zrozumie tego.

Można wiedzieć na zaliczenie czego ci to potrzebne ?

dziękuję za odpowiedzi :) potrzbne mi to na zaliczenie przedmiotu programowanie zdarzeniowe i obiektowe (c# wpf) w programie musi byc dziedziczenie i wiązanie danych

Używanie typu zmiennoprzecinkowego double to obliczeń finansowych nie jest dobrym pomysłem
Typy zmiennoprzecinkowe są precyzyjne tylko dla liczb które mają w mianowniku potęgę liczby 2..
Należy stosować typ decimal. .
Dziwię się że ktoś o tym może nie wiedzieć

Zimny Krawiec napisał(a):

Używanie typu zmiennoprzecinkowego double to obliczeń finansowych nie jest dobrym pomysłem
Typy zmiennoprzecinkowe są precyzyjne tylko dla liczb które mają w mianowniku potęgę liczby 2..
Należy stosować typ decimal. .
Dziwię się że ktoś o tym może nie wiedzieć

A co zrobisz jak jakiś shejk będzie chciał wpłacić na konto oszczędnościowe 79228162514264337593543950335 dolarów i 3 centy?

wiem że typ decimal jest lepszy niestety w momencie parsowania wykrzykuje mi błąd nie umiem tego naprawić, takiej sytuacji nie mam przy typie double

Liczba 79228162514264337593543950335 to największa dodatnia liczba decimal.

2^96 - 1 .
Liczba decimal składa się z 16 bajtów - 128 bitów , które są przechowywane w 4 polach:

int lo
int mid
int hi
int flags

a jeden z konstruktorów wygląda tak:

public Decimal(int lo, int mid, int hi, bool isNegative, byte scale)
        {
            this.lo = lo;
            this.mid = mid;
            this.hi = hi;

            flags = scale << 16; // tutaj następuje promocja liczbowa do typu int a następnie przesunięcie w lewo - dla mniej obeznanych
            if(isNegative)
            {
                flags = flags | -0x80000000;
            }      
        }

Widać , że ostatnie pole nie jest wykorzystywane nawet w 50% ale cóż . Nie ja to wymyślałem .

Parsowanie u mnie działa :

Console.Write("Podaj liczbę : ");
            decimal liczba;
            if (!Decimal.TryParse(Console.ReadLine(), out liczba))
                Console.WriteLine("Nieprawidłowa liczba!");

To nie tak, ze decimal.jest lepszy. Jest jedyny dopuszczalny.
Jakiego parsowania?

Wstaw kod Agnieszko to razem coś zaradzimy . .
Miło powitać płeć piękną na takim forum .

oto kod klasy

    class Konto
    {
        private int numer;
        private decimal saldo=0;
        string nazwa;

        
        public Konto(string nazw, int nr, decimal saldy)
        {
            nazwa = nazw;
            numerkonta = nr;
            saldo = saldy;
        }
        public int numerkonta { get; set; }
        public decimal Wplac(decimal kwota)
        {
            saldo += kwota;
            return saldo;
        }
        public decimal Wyplac(decimal kwotw)
        {
            saldo -= kwotw;
            return saldo;
        }
        public string NumerSaldo
        {
            get
            {
                string nrk = numerkonta.ToString();
                string sald = saldo.ToString();
                return nazwa + " " + nrk + " " + sald;
            }
        }

    }

a oto kod xaml.cs

    public partial class MainWindow : Window
    {
        private ObservableCollection<Konto> konty = new ObservableCollection<Konto>();
        public MainWindow()
        {
            InitializeComponent();

            konty.Add(new Konto("a",123,15.00));
            konty.Add(new Konto("b",456,20.00));
            konty.Add(new Konto("c",789,28.00));
            konty.Add(new Konto("d", 147, 30.00));



            lista.ItemsSource = konty;
            lista.Focus();
            lista.SelectedIndex = 0;
        }

        private void ok_Click(object sender, RoutedEventArgs e)
        {
            int k;
            k = int.Parse(tnr.Text);
        }

        private void lista_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {

        }
    }

Jeden ważny "szczegół". Saldo nie powinno być polem publicznym, i powinno być wystawione poprzez właściwość tylko do odczytu. W przeciwnym razie każdy będzie mógł robić z saldem co chce obchodząc wszelką walidacje.