Lezione del 28/4/2014

File testo

cigarette_smoke.txt

Introduzione alle classi

File 6.1_intro_classi.rb

#!/usr/bin/env ruby
#-------------------------------------------------------------------------#
#  Esercitazioni in Laboratorio per il Corso di                           #
#  Fondamenti di Informatica e Calcolo Numerico, AA 2013/2014             #
#                                                                         #
#  Autori:   Enrico Bertolazzi e Carlos Maximiliano Giorgio Bort          #
#            Dipartimento di Ingeneria Industriale, Universita` di Trento #
#  Sito web: http://www.ing.unitn.it/~bertolaz/                           #
#                                                                         #
#  Contatti: enrico.bertolazzi@unitn.it, cm.giorgiobort@unitn.it          #
#                                                                         #
#  Copyright (c) 2014 E.Bertolazzi e C.M. Giorgio Bort                    #
#-------------------------------------------------------------------------#

=begin
In questa lezione vediamo una introduzione alla programmazione ad oggetti,
punto di forza dei moderni linguaggi di programmazione, come C++, Python,
Java, e Ruby.
UN OGGETTO E' UNA ISTANZA DI UNA CLASSE.
Vediamo quindi brevemente cos'e' una classe, e cosa vuol dire istanziare una
classe per creare un oggetto.
=end

=begin
CLASSI:
  una classe e' un tipo di dato, definito da:
   - attributi: variabili/costanti che definiscono le proprieta' degli oggetti 
   - metodi: funzioni interne, che posso essere applicate agli attributi, ma
             anche a variabili esterne alla classe
  Nelle lezioni successive vedremo che classi diverse possono essere messe in
  relazione attraverso la relazione di EREDITARIETA'. Ereditare una classe
  significa creare nuove classi partendo da classi pre-esistenti ed
  estendendole con caratteristiche aggiuntive.

  N.B.: IN RUBY quasi TUTTO E' UN OGGETTO. Ogni valore booleano, intero, float,
  stringa, array, hash, struct, e classe sono FIGLI (i.e. ereditano) da altre
  classi, che a loro volta ereditano dalla classe 'Class'. Posso verificare 
  cio' invocando il metodo 'class':
=end
s = 'ciao'
puts "s e' una classe #{s.class}"
puts "#{s.class} e' una classe #{s.class.class}"
puts "\n"*3

=begin
OGGETTI:
  abbiamo detto che un oggetto e' una istanza di una classe. Istanziare
  significa allocare della memoria per l'oggetto, e inizializzare la classe.
  Per inizializzare una classe e' necessario invocare il suo metodo
   costruttore, che in Ruby si chiama 'new'. Ad esempio, data una classe
  'Cane', creero' l'oggetto 'fido' con il seguente comando:
      fido = Cane.new
=end

=begin
ESEMPIO:
  definiamo una classe e creiamo un oggetto istanziandola. Suppongo di
  voler creare un Juke Box con le informazioni delle mie canzoni preferite.
  Ogni canzone sara' una classe

Nota: ' buona norma dare i nomi alle classi con la prima lettera maiuscola.
  Se il nome della mia classe e' composto da piu' parole adottero' la 'CamelCase'
  notation (e.g. 'ClasseDiProva')
=end
class Canzone
  # 1) 'initialize' e' in nome del metodo COSTRUTTORE, che verra' invocato quando
  # istanzio la classe. In questo caso il costruttore ha tre argomenti:
  #   nome (Stringa) della canzone
  #   artista (Stringa) nome del cantante
  #   durata  (Float) durata –in secondi– del brano
  def initialize(nome, artista, durata)
    # Le variabili che iniziano con la chiocciolina @ e sono definite dentro
    # alla classe sono chiamate VARIABILI DI ISTANZA. Queste rappresentano gli
    # ATTRIBUTI della mia classe, e sono definite (i.e. hanno un valore diverso
    # da 'nil') solo allorquando la classe sia stata istanziata.
    # Lo SCOPE degli attributi e' tutto a classe.
    ### Per inizializzare la mia classe canzone faro':
    ### c1 = Song.new('Arabella', 'Arctic Monkeys', 207)
    @nome    = nome
    @artista = artista
    @durata  = durata
  end
end

# Per inizializzare la mia classe canzone faro':
c1 = Canzone.new('Arabella', 'Arctic Monkeys', 207)
puts c1.inspect




class Canzone
  # 2) Al momento la mia classe ha un costruttore che gli ho definito io, ma
  #    anche tutte le funzioni della classe da cui eredita. Abbiamo detto che
  #    in Ruby ogni classe eredita dalla classe 'Class', infatti:
  #       c1.class.class -> Class
  #    Ho quindi ereditato tutti i metodi di 'Class', che elenco con:
  #       puts Class.methods.sort
  #
  #    Ad esempio vedo che ho il metodo 'inspect', che mi da una descrizione
  #    della mia istanza. Tuttavia l'output del metodo non e' molto leggibile, 
  #    quindi posso sovrascrivere questo metodo.
  def inspect
    # Nota: per interpolare variabili di istanza in una stringa posso scrivere:
    #    "#{@nome}"   oppure   "#@nome"
    return "Canzone: #@nome -- #@artista : #@durata"
  end
end
puts "> Nuovo inspect:"
puts c1.inspect


# 3) Accessori: come posso fare a leggere il nome della mia canzone? Potrei 
#    pensare di scrivere:
#     puts c1.nome
# ma Ruby mi dira' che in metodo 'nome' non e' stato definito per la mia classe
# c1. Devo quindi definire dei metodi che mi permettano di leggere, ed in caso
# scrivere, gli attributi (i.e. le variabili di istanza) del mio oggetto.
# Questo lo posso fare con due metodi:
class Canzone
  
  # 3.1) definisco esplicitamente i metodi accessori...
  # per leggere il nome:
  #   def nome
  #     return @nome
  #   end
  # per scrivere il nome:
  #   def nome=(nuovo_nome)
  #     @nome = nuovo_nome
  #   end
  
  # 3.2) oppure posso creare degli accessori attraverso delle scorciatoie:
  #    attr_reader :nome
  #    attr_writer :nome
  # quando sono interessato sia all'accessore per la lettura che
  # a quello per la scrittura posso scrivere direttamente:
  attr_accessor :nome, :artista, :durata
end

puts c1.nome
c1.nome = "R U mine?"
puts c1.nome



leggi pixel, accendi e spegni pixel

File 6.2_ereditarieta.rb

#!/usr/bin/env ruby
#-------------------------------------------------------------------------#
#  Esercitazioni in Laboratorio per il Corso di                           #
#  Fondamenti di Informatica e Calcolo Numerico, AA 2013/2014             #
#                                                                         #
#  Autori:   Enrico Bertolazzi e Carlos Maximiliano Giorgio Bort          #
#            Dipartimento di Ingeneria Industriale, Universita` di Trento #
#  Sito web: http://www.ing.unitn.it/~bertolaz/                           #
#                                                                         #
#  Contatti: enrico.bertolazzi@unitn.it, cm.giorgiobort@unitn.it          #
#                                                                         #
#  Copyright (c) 2014 E.Bertolazzi e C.M. Giorgio Bort                    #
#-------------------------------------------------------------------------#

=begin
Nell'esempio precedente abbiamo visto cos'e' una classe, un oggetto, ed abbiamo
parlato brevemente di cos'e' l'ereditarieta'. In questo esempio tratteremo 
l'ereditarieta' in modo piu' completo
=end

# Definisco la classe Canzone con il metodo costruttore, inspect, e gli 
# accessori
class Canzone
  # accessori
  attr_accessor :nome, :artista, :durata
  
  # Costruttore
  def initialize(nome, artista, durata)
    @nome    = nome
    @artista = artista
    @durata  = durata
  end
  
  def inspect
    return "Canzone: #@nome -- #@artista : #@durata"
  end
end

# L'ereditarieta' mi permette di creare una classe che e' una specializzazione di
# un'altra classe. Ad esempio, creo una classe 'CanzoneKaraoke' e' deve essere 
# come la classe 'Canzone', con l'unica differenza che deve avere anche 
# informazioni sul testo della canzone.
# Devo quindi modificare soltanto il costruttore della classe
class CanzoneKaraoke < Canzone
  attr_reader :testo
  
  def initialize(nome, artista, durata, testo)
    # il metodo 'super' messo qui richiama il costruttore di 'Canzone'
    super(nome, artista, durata)
    @testo = testo
  end
end

# Proviamo ora la nostra classe 'CanzoneKaraoke'
# carico il testo della canzone da un file
testo = ""
IO.foreach('testi/cigarette_smoke.txt'){|line| testo << line}

k1 = CanzoneKaraoke.new('cigarette smoke', 'Arctic Monkeys', 176, testo)
# visualizziamo le informazioni sulla canzone:
puts k1.inspect
# mi restituisce: > Canzone: cigarette smoke -- Arctic Monkeys : 176
# che e' proprio l'output che avevo definito nella classe 'Canzone', ovviemente 
# senza informazioni sul testo. Modifico quindi il metodo 'inspect' di
# 'CanzoneKaraoke'
class CanzoneKaraoke < Canzone
  def inspect
    # 'super' in questo caso dice a Ruby di invocare il metodo 'initialize' di 
    # 'Canzone'
    descrizione = super
    return descrizione + " [ #{@testo[0..20]} ... ]"
  end
end
puts k1.inspect

File 6.3_self_metodiClasse.rb

#!/usr/bin/env ruby
#-------------------------------------------------------------------------#
#  Esercitazioni in Laboratorio per il Corso di                           #
#  Fondamenti di Informatica e Calcolo Numerico, AA 2013/2014             #
#                                                                         #
#  Autori:   Enrico Bertolazzi e Carlos Maximiliano Giorgio Bort          #
#            Dipartimento di Ingeneria Industriale, Universita` di Trento #
#  Sito web: http://www.ing.unitn.it/~bertolaz/                           #
#                                                                         #
#  Contatti: enrico.bertolazzi@unitn.it, cm.giorgiobort@unitn.it          #
#                                                                         #
#  Copyright (c) 2014 E.Bertolazzi e C.M. Giorgio Bort                    #
#-------------------------------------------------------------------------#

=begin
 Vedremo ora cos'e' in ruby la parola chiave 'self'. Quando usata all'interno
 di una classe, la parola 'self' e' utilizzata per riferirsi all'oggetto (i.e.
 istanza) corrente.

 Vedremo inolte cosa sono i metodi e le variabili di classe
=end


class Item1
  
  # metodo di istanza. E' creato solo dopo che ho instanziato la classe
  def initialize(item_nome)
    @item_nome = item_nome
  end
  
  # metodo di istanza
  def show
    # 'self' mi restituisce la rappresentazione dell'istanza dell'oggetto
    puts "Metodo di istanza 'show' invocato per #{self}"
  end  
 
  # se voglio una rappresentazione piu' leggibile
  #def to_s
  #  "Item: #{@item_nome}"
  #end
  
end

t = Item1.new('test')
t.show


############################################
#### METODI DI CLASSE ######################
############################################
puts "_"*40
class Item2
  # aggiungendo un 'self' al nome del metodo creo un metodo di classe. Questo 
  # metodo esiste anche senza instanziare la classe
  def self.show_class
    puts "Invocato metodo di classe"
  end
  
  def show_instance
    puts "Metodo di istanza"
    #puts "La variabile di instanza vale #{@var_instance}"
  end
end
Item2.show_class # ora uso il metodo 'show' senza istanziare la classe
#Item2.show_var_instance # da errore perche' la classe non e' stata inizializzata

# in alternativa avrei potuto scrivere
=begin
class Item2
  class << self
    def show
      puts "Invocato metodo di classe"
    end
  end
end
=end


#====#====#====#====#====#====#====#====#====#====#====#====#====#====#====#
#N.B. I metodi di classe non hanno accesso ai metodi di istanza, o alle
# variabili di istanza. Al contrario, metodi di istanza possono accedere
# alle variabili ed ai metodi di classe. Verifichiamo la prima affermazione:
#====#====#====#====#====#====#====#====#====#====#====#====#====#====#====#
puts "_"*40
class Item3
  # aggiungendo un 'self' al nome del metodo creo un metodo di classe. Questo 
  # metodo esiste anche senza instanziare la classe
  def self.show_class
    #show_instance   # questo da errore
    puts "@var_instanza = #{@var_instanza}" # questo da 'nil'
    puts "Invocato metodo di classe"
  end
  
  def show_instance
    @var_instanza = 3
    puts "Metodo di istanza"
    #puts "La variabile di instanza vale #{@var_instance}"
  end
end
Item3.show_class



############################################
#### VARIABILI DI CLASSE ###################
############################################
puts "_"*40
class Pianeta
  # le variabili di classe si definiscono con due '@'
  @@numero_pianeti = 0
  
  def initialize(name)
    @name = name
    @@numero_pianeti += 1
  end
  
  # definisco un metodo di classe che mi permette di accedere
  # alla variabile di istanza numero_pianeti
  def self.numero_pianeti
    @@numero_pianeti
  end  
end

Pianeta.new("earth")
Pianeta.new("uranus")
puts "Il mio sistema planetario ha #{Pianeta.numero_pianeti} pianeti"
# le variabili di classe possono essere usate per salvare dati che appartengono
# a una classe, ma non ad una istanza.





############################################
#### VARIABILI DI ISTANZA DI CLASSE ########
############################################
class Foo
  # N.B: una variabile nominata con un solo '@' e definita nel corpo della 
  # classe si chiama VARIABILE DI ISTANZA DI CLASSE
  @contatore_inst_class = 0
  
  @@contatore_class = 20
  
  def aumenta_cont_inst_class # questo metodo dara' errore!
    @contatore_inst_class += 1
  end
  
  def aumenta_cont_class
    # questo metodo FUNZIONA perche' POSSO USARE VARIABILI (ma anche metodi)
    # DI CLASSE NEI METODI di istanza
    @@contatore_class += 1
  end
  
  def self.increment_counter
    @contatore_inst_class += 1
  end
  
  def self.current_count_inst_class
    @contatore_inst_class
  end  
  
  def self.curret_count_cl
    @@contatore_class
  end
end

puts Foo.increment_counter # OK, funziona

f = Foo.new
#puts f.aumenta_cont_inst_class
puts "f.aumenta_cont_class #{f.aumenta_cont_class}"
# questo da errore perche' NON POSSO USARE VARIABILI DI
#  ISTANZA DI CLASSE NEI METODI DI ISTANZA



# e che differenza c'e' tra '@@contatore_class' e '@contatore_inst_class'? Vediamolo...
class Bar < Foo
  @contatore_inst_class = 100 # se non la definisco, vale 'nil', il suo valore non e' ereditato
  @@foo_var_cl = 140 # questo NON VIENE SOVRASCRITTO!!!
end
puts "Variabile @contatore_inst_class in Foo #{Foo.current_count_inst_class}"
puts "Variabile @contatore_inst_class in Bar #{Bar.current_count_inst_class}"

puts "Variabile @@contatore_class in Foo #{Foo.curret_count_cl}"
puts "Variabile @@contatore_class in Bar #{Bar.curret_count_cl}"

=begin RIASSUMENDO

A) I metodi di classe non hanno accesso ai metodi di istanza, 
   o alle variabili di istanza. Al contrario, metodi di istanza 
   possono accedere alle variabili ed ai metodi di classe.

B) Le variabili di istanza sono disponibili solo per istanze di classi,
   e si scrivono come '@foo'. Le variabili di classe invece sono disponibili 
   sia per i metodi di classe che per i metodi di istanza, e si scrivono 
   come '@@foo'.

C) Le variabili di istanza di classe si scrivono come le variabili di istanza
   ('@foo') ma vanno dichiarate nel corpo della classe e hanno proprieta' molto 
   diverse dalle variabili di istanza.

D) Le differenze tra VARIABILI DI CLASSE e VARIABILI DI ISTANZA DI CLASSE sono:

  1) le variabili di istanza di classe NON PERMETTONO LA CONDIVISIONE DI DATI
     ATTRAVERSO TUTTA LA CATENA DI EREDITARIETA`
     (cosa che invece fanno le variabili di classe).

  2) le variabili di istanza di classe possono essere
     USATE SOLO IN METODI DI CLASSE
=end

---