Classi Astratte

<Serializable()> _
Public MustInherit Class Chart 

Public MustOverride Sub Draw() 

• Essere modificati tramite polimorfismo, definendone, quindi, il corpo;
• Essere ridichiarati MustOverride, rimandandone ancora la definizione.

Module Module1

    'Classe astratta che rappresenta un risolutore di equazioni.
    'Dato che di equazioni ce ne possono essere molte tipologie
    'differenti, non ha senso rendere questa classe istanziabile.
    'Provando a scrivere qualcosa come:
    '  Dim Eq As New EquationSolver()
    'Vi verrà comunicato un errore, in quanto le classi
    'astratte sono per loro natura non istanziabili
    MustInherit Class EquationSolver
        'Per lo stesso discorso fatto prima, se non conosciamo come
        'è fatta l'equazione che questo tipo contiene non
        'possiamo neppure tentare di risolverla. Perciò
        'ci limitiamo a dichiarare una funzione Solve come MustOverride.
        'Notate che il tipo restituito è un array di Single,
        'in quanto le soluzioni saranno spesso più di una.
        Public MustOverride Function Solve() As Single()
    End Class

    'La prossima classe rappresenta un risolutore di equazioni
    'polinomiali. Dato che la tipologia è ben definita,
    'avremmo potuto anche non rendere astratta la classe
    'e, nella funzione Solve, utilizzare un Select Case per
    'controllare il grado dell'equazione. Ad ogni modo, è
    'utile vedere come si comporta l'erediterietà attraverso
    'più classi astratte.
    'Inoltre, ci ritornerà molto utile in seguito disporre
    'di questa classe astratta intermedia
    MustInherit Class PolynomialEquationSolver
        Inherits EquationSolver

        Private _Coefficients() As Single

        'Array di Single che contiene i coefficienti dei
        'termini di i-esimo grado all'interno dell'equazione.
        'L'elemento 0 dell'array indica il coefficiente del
        'termine a grado massimo.
        Public Property Coefficients() As Single()
            Get
                Return _Coefficients
            End Get
            Set(ByVal value As Single())
                _Coefficients = value
            End Set
        End Property

        'Ecco quello a cui volevo arrivare. Se un metodo astratto
        'lo si vuole mantenere tale anche nella classe derivata,
        'non basta scrivere:
        '  MustOverride Function Solve() As Single()
        'Percè in questo caso verrebbe interpretato come
        'un membro che non c'entra niente con MyBase.Solve,
        'e si genererebbe un errore in quanto stiamo tentando
        'di dichiarare un nuovo membro con lo stesso nome
        'di un membro della classe base.
        'Per questo motivo, dobbiamo comunque usare il polimorfismo
        'come se si trattasse di un normale metodo e dichiararlo
        'Overrides. In aggiunta a questo, deve anche essere
        'astratto, e perciò aggiungiamo MustOverride:
        Public MustOverride Overrides Function Solve() As Single()

        'Anche in questo caso usiamo il polimorfismo, ma ci riferiamo
        'alla semplice funzione ToString, derivata dalla classe base
        'di tutte le entità esistenti, System.Object.
        'Questa si limita a restituire una stringa che rappresenta
        'l'equazione a partire dai suoi coefficienti. Ad esempio:
        '  3x^2 + 2x^1 + 4x^0 = 0
        'Potete modificare il codice per eliminare le forme ridondanti
        'x^1 e x^0.
        Public Overrides Function ToString() As String
            Dim Result As String = ""

            For I As Int16 = 0 To Me.Coefficients.Length - 1
                If I > 0 Then
                    Result &= " + "
                End If
                Result &= String.Format("{0}x^{1}", _ 
                    Me.Coefficients(I), Me.Coefficients.Length - 1 - I)
            Next

            Result &= " = 0"

            Return Result
        End Function
    End Class

    'Rappresenta un risolutore di equazioni non polinomiali.
    'La classe non è astratta, ma non presenta alcun codice.
    'Per risolvere questo tipo di equazioni, è necessario
    'sapere qualche cosa in più rispetto al punto in cui siamo
    'arrivati, perciò mi limiterò a lasciare in bianco
    Class NonPolynomialEquationSolver
        Inherits EquationSolver

        Public Overrides Function Solve() As Single()
            Return Nothing
        End Function
    End Class

    'Rappresenta un risolutore di equazioni di primo grado. Eredita
    'da PolynomialEquationSolver poichè, ovviamente, si
    'tratta di equazioni polinomiali. In più, definisce
    'le proprietà a e b che sono utili per inserire i
    'coefficienti. Infatti, l'equazione standard è:
    '  ax + b = 0
    Class LinearEquationSolver
        Inherits PolynomialEquationSolver

        Public Property a() As Single
            Get
                Return Me.Coefficients(0)
            End Get
            Set(ByVal value As Single)
                Me.Coefficients(0) = value
            End Set
        End Property

        Public Property b() As Single
            Get
                Return Me.Coefficients(1)
            End Get
            Set(ByVal value As Single)
                Me.Coefficients(1) = value
            End Set
        End Property

        'Sappiamo già quanti sono i coefficienti, dato
        'che si tratta di equazioni lineari, quindi ridimensioniamo
        'l'array il prima possibile.
        Sub New()
            ReDim Me.Coefficients(1)
        End Sub

        'Funzione Overrides che sovrascrive il metodo astratto della
        'classe base. Avrete notato che quando scrivete:
        '  Inherits PolynomialEquationSolver
        'e premete invio, questa funzione viene aggiunta automaticamente
        'al codice. Questa è un'utile feature dell'ambiente
        'di sviluppo
        Public Overrides Function Solve() As Single()
            If a <> 0 Then
                Return New Single() {-b / a}
            Else
                Return Nothing
            End If
        End Function
    End Class

    'Risolutore di equazioni di secondo grado:
    '  ax2 + bx + c = 0
    Class QuadraticEquationSolver
        Inherits LinearEquationSolver

        Public Property c() As Single
            Get
                Return Me.Coefficients(2)
            End Get
            Set(ByVal value As Single)
                Me.Coefficients(2) = value
            End Set
        End Property

        Sub New()
            ReDim Me.Coefficients(2)
        End Sub

        Public Overrides Function Solve() As Single()
            If b ^ 2 - 4 * a * c >= 0 Then
                Return New Single() { _ 
                    (-b - Math.Sqrt(b ^ 2 - 4 * a * c)) / 2, _ 
                    (-b + Math.Sqrt(b ^ 2 - 4 * a * c)) / 2}
            Else
                Return Nothing
            End If
        End Function
    End Class

    'Risolutore di equazioni di grado superiore al secondo. So
    'che avrei potuto inserire anche una classe relativa
    'alle cubiche, ma dato che si tratta di un esempio, vediamo
    'di accorciare il codice...
    'Comunque, dato che non esiste formula risolutiva per
    'le equazioni di grado superiore al quarto (e già,
    'ci mancava un'altra classe!), usiamo in questo caso
    'un semplice ed intuitivo metodo di approssimazione degli
    'zeri, il metodo dicotomico o di bisezione (che vi può
    'essere utile per risolvere un esercizio dell'eserciziario)
    Class HighDegreeEquationSolver
        Inherits PolynomialEquationSolver

        Private _Epsilon As Single
        Private _IntervalLowerBound, _IntervalUpperBound As Single

        'Errore desiderato: l'algoritmo si fermerà una volta
        'raggiunta una precisione inferiore a Epsilon
        Public Property Epsilon() As Single
            Get
                Return _Epsilon
            End Get
            Set(ByVal value As Single)
                _Epsilon = value
            End Set
        End Property

        'Limite inferiore dell'intervallo in cui cercare la soluzione
        Public Property IntervalLowerBound() As Single
            Get
                Return _IntervalLowerBound
            End Get
            Set(ByVal value As Single)
                _IntervalLowerBound = value
            End Set
        End Property

        'Limite superiore dell'intervallo in cui cercare la soluzione
        Public Property IntervalUpperBound() As Single
            Get
                Return _IntervalUpperBound
            End Get
            Set(ByVal value As Single)
                _IntervalUpperBound = value
            End Set
        End Property


        'Valuta la funzione polinomiale. Dati i coefficienti immessi,
        'noi disponiamo del polinomio p(x), quindi possiamo calcolare
        'i valori che esso assume per ogni x
        Private Function EvaluateFunction(ByVal x As Single) As Single
            Dim Result As Single = 0

            For I As Int16 = 0 To Me.Coefficients.Length - 1
                Result += Me.Coefficients(I) * x ^ (Me.Coefficients.Length - 1 - I)
            Next

            Return Result
        End Function

        Public Overrides Function Solve() As Single()
            Dim a, b, c As Single
            Dim fa, fb, fc As Single
            Dim Interval As Single = 100
            Dim I As Int16 = 0
            Dim Result As Single

            a = IntervalLowerBound
            b = IntervalUpperBound

            'Non esiste uno zero tra a e b se f(a) e f(b) hanno
            'lo stesso segno
            If EvaluateFunction(a) * EvaluateFunction(b) > 0 Then
                Return Nothing
            End If

            Do
                'c è il punto medio tra a e b
                c = (a + b) / 2
                'Calcola f(a), f(b) ed f(c)
                fa = EvaluateFunction(a)
                fb = EvaluateFunction(b)
                fc = EvaluateFunction(c)

                'Se uno tra f(a), f(b) e f(c) vale zero, allora abbiamo
                'trovato una soluzione perfetta, senza errori, ed
                'usciamo direttamente dal ciclo
                If fa = 0 Then
                    c = a
                    Exit Do
                End If
                If fb = 0 Then
                    c = b
                    Exit Do
                End If
                If fc = 0 Then
                    Exit Do
                End If

                'Altrimenti, controlliamo quale coppia di valori scelti
                'tra f(a), f(b) ed f(c) ha segni discorsi: lo zero si troverà
                'tra le ascisse di questi
                If fa * fc < 0 Then
                    b = c
                Else
                    a = c
                End If
            Loop Until Math.Abs(a - b) < Me.Epsilon
            'Cicla finchè l'ampiezza dell'intervallo non è
            'sufficientemente piccola, quindi assume come zero più
            'probabile il punto medio tra a e b:
            Result = c

            Return New Single() {Result}
        End Function
    End Class


    Sub Main()
        'Contiene un generico risolutore di equazioni. Non sappiamo ancora
        'quale tipologia di equazione dovremo risolvere, ma sappiamo per
        'certo che lo dovremo fare, ed EquationSolver è la classe
        'base di tutti i risolutori che espone il metodo Solve.
        Dim Eq As EquationSolver
        Dim x() As Single
        Dim Cmd As Char

        Console.WriteLine("Scegli una tipologia di equazione: ")
        Console.WriteLine(" l - lineare;")
        Console.WriteLine(" q - quadratica;")
        Console.WriteLine(" h - di grado superiore al secondo;")
        Console.WriteLine(" e - non polinomiale;")
        Cmd = Console.ReadKey().KeyChar
        Console.Clear()

        If Cmd <> "e" Then
            'Ancora, sappiamo che si tratta di un'equazione polinomiale
            'ma non di quale grado
            Dim Poly As PolynomialEquationSolver

            'Ottiene i dati relativi a ciascuna equazione
            Select Case Cmd
                Case "l"
                    Dim Linear As New LinearEquationSolver()
                    Poly = Linear
                Case "q"
                    Dim Quadratic As New QuadraticEquationSolver()
                    Poly = Quadratic
                Case "h"
                    Dim High As New HighDegreeEquationSolver()
                    Dim CoefNumber As Int16
                    Console.WriteLine("Inserire il numero di coefficienti: ")
                    CoefNumber = Console.ReadLine
                    ReDim High.Coefficients(CoefNumber - 1)
                    Console.WriteLine("Inserire i limti dell'intervallo in cui cercare gli zeri:")
                    High.IntervalLowerBound = Console.ReadLine
                    High.IntervalUpperBound = Console.ReadLine
                    Console.WriteLine("Inserire la precisione (epsilon):")
                    High.Epsilon = Console.ReadLine
                    Poly = High
            End Select

            'A questo punto la variabile Poly contiene sicuramente un oggetto
            '(LinearEquationSolver, QuadraticEquationSolver oppure
            'HighDegreeEquationSolver), anche se non sappiamo quale. Tuttavia,
            'tutti questi sono pur sempre polinomiali e perciò tutti
            'hanno bisogno di sapere i coefficienti del polinomio.
            'Ecco che allora possiamo usare Poly con sicurezza percè
            'sicuramente contiene un oggetto e la proprietà Coefficients
            'è stata definita proprio nella classe PolynomialEquationSolver.
            'N.B.: ricordate tutto quello che abbiamo detto sull'assegnamento
            '  di un oggetto di classe derivata a uno di classe base!
            Console.WriteLine("Inserire i coefficienti: ")
            For I As Int16 = 1 To Poly.Coefficients.Length - 1
                Console.Write("a{0} = ", Poly.Coefficients.Length - I)
                Poly.Coefficients(I - 1) = Console.ReadLine
            Next

            'Assegnamo Poly a Eq. Osservate che siamo andati via via dal
            'caso più particolare al più generale:
            '  - Abbiamo creato un oggetto specifico per un certo grado
            '    di un'equazione polinomiale (Linear, Quadratic, High);
            '  - Abbiamo messo quell'oggetto in uno che si riferisce
            '    genericamente a tutti i polinomi;
            '  - Infine, abbiamo posto quest'ultimo in uno ancora più
            '    generale che si riferisce a tutte le equazioni;
            'Questo percorso porta da oggetto molto specifici e ricchi di membri
            '(tante proprietà e tanti metodi), a tipi molto generali
            'e poveri di membri (nel caso di Eq, un solo metodo).
            Eq = Poly
        Else
            'Inseriamo in Eq un nuovo oggetto per risolvere equazioni non
            'polinomiali, anche se il codice è al momento vuoto
            Eq = New NonPolynomialEquationSolver
            Console.WriteLine("Non implementato")
        End If

        'Risolviamo l'equazione. Richiamare la funzione Solve da un oggetto
        'EquationSolver potrebbe non dirvi nulla, ma ricordate che dentro Eq
        'è memorizzato un oggetto più specifico in cui
        'è stata definita la funzione Solve(). Per questo motivo,
        'anche se Eq è di tipo classe base, purtuttavia contiene
        'al proprio interno un oggetto di tipo classe derivata, ed
        'è questo che conta: viene usato il metodo Solve della classe
        'derivata.
        'Se ci pensate bene, vi verrà più spontaneo capire,
        'poiché noi, ora, stiamo guardando ATTRAVERSO il tipo
        'EquationSolver un oggetto di altro tipo. È come osservare
        'attraverso filtri via via sempre più fitti (cfr
        'immagine seguente)
        x = Eq.Solve()

        If x IsNot Nothing Then
            Console.WriteLine("Soluzioni trovate: ")
            For Each s As Single In x
                Console.WriteLine(s)
            Next
        Else
            Console.WriteLine("Nessuna soluzione")
        End If

        Console.ReadKey()
    End Sub
End Module 

Classi Sigillate

NotInheritable Class Example
    '...
End Class 

Class A
    Sub DoSomething()
        '...
    End Sub
End Class

Class B
    Inherits A
    
    'Questa procedura sovrascrive la precedente versione
    'di DoSomething dichiarata in A, ma preclude a tutte le
    'classi derivate da B la possibilità di fare lo stesso
    NotOverridable Overrides Sub DoSomething()
        '...
    End Sub
End Class 

Classi Parziali

Partial Class [Nome]
    '...
End Class 

'Nel file Codice1.vb :
Partial Class A
    Sub One()
        '...
    End Sub
End Class

'Nel file Codice2.vb
Class A
    Sub Two()
        '...
    End Sub
End Class

'Nel file Codice3.vb
Class A
    Sub Three()
        '...
    End Sub
End Class

'Tutte le classi A vengono compilate come un'unica classe
'perchè una possiede la keyword Partial:
Class A
    Sub One()
        '...
    End Sub
    
    Sub Two()
        '...
    End Sub
    
    Sub Three()
        '...
    End Sub
End Class