Newsgroup: it.comp.java
Titolo: ridefinire operatore +

Tra le molte domande che non mi sono mai posto e che di colpo mi assillano:
è possibile ridefinire il +? Cioè poter scrivere:
oggetto = oggetto1 + oggetto2;        // oggetti di una classe creata da me
Poi sul senso e sull'utilità della cosa immagino si potrebbe discutere, è
solo una domanda teorica.
Tempo fa un programmatore Eiffel (l'unico in realtà che io abbia mai visto)
mi ha detto di aver fatto questa cosa. In particolare aveva definito degli
oggetti "immagini" ed aveva implementato una differenza pixel a pixel tra
due immagini, usando il simbolo meno.
*Domanda più sensata*
già le stringhe sono oggetti che non necessitano del formalismo di tutti gli
altri oggetti, li istanzio senza new e li concateno con un +.
Ma a pensarci bene quando dico:
int[] n = new int[10];
che oggetto sto creando, o meglio di quale classe?
E questa strana classe che non trovo nell' API specification non possiede
nulla se non un attributo length che non trovo nelle API???
Quindi i vettori sono oggetti di una classe non documentata e priva di
metodi?
*Infine*
class Classe {
    public static void main(String[] args) {
        // bla bla
    }
}
ho una semplicissima classe siffatta. Quando eseguo l'applicazione e quindi
viene eseguito il corpo del main, in automatico, senza dir nulla, si
istanzia un'oggetto della classe Classe, sempre senza new?
spero che qualcuno risponda  almeno alla seconda domanda
grazie
maS

 
no. main e` un metodo statico: non hai bisogno di un'istanza (che otterresti
con il 'new') per richiamarlo. L'interprete fa una chiamata del tipo
 Classe.main( cmdLineArgs );
-- 
Ciao, Matteo                         !!  It has to start somewhere
                                     /\  It has to start sometime
mailto:
matteo.mattia
 (at) 
libero.it
  \/  What better place than HERE
                                     ĄĄ  What better time than NOW

 ?!? :/ ... davvero difficile a credersi.
Perche'? In C++ lo potresti fare tranquillamente, no?
Basta overloadare l'operatore meno. O sbaglio?
-- 
Tommaso Paba
Togli ".no-spam." per rispondere (se c'e')
http://spazioweb.inwind.it/pabasoftware


grazie per le risposte, e chissà quando non hai fretta... :-)
maS


Purtroppo questa notte ho meditato e mi sono posto un nuovo inedito
interrogativo. Se è così e non ho bisogno di un'instanza, come capita spesso
(String.valueOf()....) in realtà cosa accade? Dovrà pure esserci in memoria
una sequenza di istruzioni, cioè il main o il valueOf per essere
effettivamente eseguiti dovranno pure trovarsi in memoria, no? E questo
trovarsi in memoria non significa avere un'istanza di Classe e String??!
tx
maS

 writes:
m> Purtroppo questa notte ho meditato e mi sono posto un nuovo inedito
m> interrogativo. Se è così e non ho bisogno di un'instanza, come capita spesso
m> (String.valueOf()....) in realtà cosa accade? Dovrà pure esserci in memoria
m> una sequenza di istruzioni, cioè il main o il valueOf per essere
m> effettivamente eseguiti dovranno pure trovarsi in memoria, no? E questo
m> trovarsi in memoria non significa avere un'istanza di Classe e String??!
Allora quando  in Java richiami un  metodo di una classe  (che non sia
statico) se non erro vai a cercare l'oggetto e da questo risali con un
meccanismo più o meno lungo (ad esempio  se il metodo è final o no) ad
un  puntatore a  funzione che  è contentuta  nel 'text  segment' della
classe, e questa  funzione in realtà riceve i  parametri specificati +
1,  il this.   Se invece  chiami un  metodo statico  c'è  una chiamata
diretta (?) alla funzione che  risiede sempre nel 'text segment' della
funzione. Fisicamente, non credo che un oggetto contenga il codice, ma
solo dei  riferimenti al codice. Il  codice si trova in  quello che io
(credo impropriamente) definisco 'text segment'.
\begin{avviso}
 
Attenzione: rispondo ad ogni invio  di pubblicità non richiesta o spam
di qualsiasi  altro genere con  un messaggio al provider  di competen-
za.  Ai sensi  della  legge sulla  privacy  NON avete  il permesso  di
utilizzare i miei dati per questi scopi.
\end{avviso}
+----------------------------------------------------------------+
| Gian Uberto Lauri * "So, are you working on fixing that bug    |
| 
sa...@eng.it
      *  *now* or leaving it until later ?" - YES  |
+----------------------------------------------------------------+

 
-- 
dome

 writes:
dl> colgo l'occasione per chiedere una precisazione; se ho questo codice:
// Ripulito dal quoted unreadable e con una piccola modifica
public class Test {
    public static void main(String args[]) {
        Prova p = new Prova();
	Prova pp = new Prova();
        p.metodo();
	pp.metodo();
        Prova q = new Prova() {
            public void metodo() {
                System.out.println("definizione modificata");
            }
        };
        q.metodo();
        System.exit(0);
    }
}
class Prova {
    public void metodo() {
        System.out.println("definizione iniziale");
    }
}
dl> il codice dell'oggetto q e' diverso da quello della classe e dell'oggetto
dl> p; quindi gli oggetti java contengono
Se  osservi il  compilato  vedrai che  Test.java  genera Test.class  e
Test$1.class   in  quanto  al   momento  di   instanziare  q   tu  fai
implicitamente un  subclassing anonimo di  Prova. Nella classe  che il
debugger mi chiama Test$1 cui  appartiene q (nonostante il nome Test$1
è una sottoclasse di Prova e  non di Test) il codice di metodo() viene
'overridden' da una nuova definizione.
L'oggetto p  quindi contiene un  'riferimento' a Prova.metodo()  che è
nel  'text ssegment'  di Prova,  mentre  q contiene  un riferimento  a
Test$1.metodo() che è nel text segment di Test$1.
Supponendo di creare anche un oggetto pp di tipo Prova, in memoria c'è
qualcosa di simile a questo
+[Test]---+	     *(p)~~~~~*		     +----+ codice di una
|main()   |    	     { #      }	       	     | 	  | classe
+---------+	     *~!~~~~~~*		     +----*
	       	       /
+[Prova]--+ 	      /   *(pp)~~~~*	     *~~~~* oggetto
|metodo()<------------------#      }	     {    } istanziato
+---------+	       	  *~~~~~~~~*         *~~~~*
+[Test$1]-+    	     *(q)~~~~~*
|metodo()<-------------#      }
+---------+  	     *~~~~~~~~*
con due  oggetti (p  e pp) che  hanno un riferimento  (puntatore) alla
funzione (intendo il  bytecode) di Prova.metodo() e un  oggetto con un
riferimento alla funzione Test$1.metodo().
(Non occorre citare tutto un mio articolo quando si risponde :) )
