Newsgroup: it.comp.java
Titolo: [newbie] Consiglio scrittura metodo seguente

Dovrei scrivere un metodo Insieme unione(Insieme S) che restituisce un nuovo
insieme formato dall'unione degli elementi dell'istanza corrente e
dall'insieme in imput S.
La classe Insieme a cui dovra' appartenere questo metodo io l'ho scritta nel
modo seguente:
public abstract class Insieme {
 Object arrayOgg[];  //array di oggetti dove memorizzare gli elementi
dell'insieme
 int maxNumElementi; //il massimo numero di elementi che l'insieme può
contenere
 int cardinal;  // rappresenta il numero di elementi contenuti nell'insieme
/**
*costruttore Insieme() che crea un nuovo insieme vuoto che contiene al piu'
10 elementi
*
*/
 public Insieme() {
  int cardinal = 0;
  int maxNumElementi = 10;
  Object arrayOgg[] = new Object[maxNumElementi];
 }
/**
* costruttore Insieme(int maxNumElementi)
* maxNumElementi sara' il massimo numero di elementi che l'insieme potra'
contenere
*
*/
 public Insieme (int maxNumElementi) {
  int cardinal;
  Object arrayOgg[] = new Object[maxNumElementi];
  }
/** Metodo getMaxNumElementi
* param:
* return: il numero massimo degli elementi
*/
 public int getMaxNumElementi() {
  int maxElem = arrayOgg.length;
  return maxElem;
 }
/**
* Metodo boolean add(Object obj)
* param Object obj
* return true se riesce ad aggiungere il nuovo oggetto false altrimenti
*/
 public boolean add(Object obj){
  if (cardinal < maxNumElementi){
   arrayOgg[cardinal++] = obj;
  return true;
  }
  return false;
 }
/**
* Metodo boolean in(Object obj)
* param obj e' l'oggetto da controllare
* return true se l'oggetto appartiene all'istanza corrente false altrimenti
*/
 public boolean in(Object obj){
 boolean verifica = false;
 for (int i=0; i<arrayOgg.length; i++)
  if (arrayOgg[i] == obj)
   verifica = true;
 return verifica;
 }
La cosa che mi crea problemi e' : come faccio a farmi restituire un valore
di tipo insieme?
Questo tipo di Insieme dovra' contenere un array di oggetti lungo di
lunghezza sufficiente a contenere gli oggetti dei 2 insiemi.
Ma mentre la lunghezza dell'istanza corrente so calcolarla come calcolo la
lunghezza dell'array S che passo come parametro?
Grazie a chi mi dara' una mano.
Da come potete facilmente intuire sono alle prime armi.
Ciao!

  int maxNumElementi; //il massimo numero di elementi che l'insieme puň

prova a fare cosě:
/**
   * Ritorna il numero di elementi memorizzati.
   */
public int getElements() {
   this.getElements();
}
/**
   * Ritorna un'elemento dell'insieme
   */
public Object getObject(int index) {
   // elemento ritornato;
   Object elemento = null;
   // index deve avere un valore compreso tra 0 ed il getElements() - 1
   if(index <= getElements - 1) {
     elemento = arrayOgg[index];
   }
   return elemento;
}
/**
   * Ritorna un nuovo oggetto Insieme c dato
   * dall'unione dell'istanza corrente a e
   * l'oggetto passato come argomento b.
   */
public Insieme unione(Insieme b) {
   int elementiA = this.getElements();
   int elementiB = b.getElements();
   // il nuovo insieme avra una capacitň pari
   // alla somma degli elementi dei due insiemi
   Insieme c = new Insieme(elementiA + elementiB);
   // aggiungo gli elementi dell'insieme a...
   for(int i = 0; i < elementiA; i++) {
     c.add(this.getElement(i));
   }
   // ... poi quelli dell'insieme b
   for(int i = 0; i < elementiB; i++) {
     c.add(b.getElement(i));
   }
   // ritorno il nuovo insieme c
   return c;
}
Spero di non aver scritto cavolate e che ti sia chiaro.
Ciao.
-- 
Windows Millenium - Linux Mandrake 9.0
Java - Visual Basic


Non hai scritto cavolate anzi!
La cavolata l'ho scritta io dichiarando la classe come astratta per cui
l'errore che viene fuori e' proprio perche' una classe astratta non può
essere istanziata
Ci ripasso sopra un paio d'ore poi se servira tornerò a chiedere consigli
Grazie e alla prossima

dall'insieme in imput S.
Sembra che ti serva piů che altro un vettore, io se ho ben capito
qual'č il problema estenderei la classe Vector ed aggiungerei una
funzione unione. Qualcosa tipo:
class Insieme extends Vector {
  //...
  void unione(Insieme S) {
     for (int i = 0; i < S.size(); i++)
         this.addElement(S.get(i));
     this.TrimToSize();
  }
}
Ho messo void al metodo perchč mi hai messo un solo parametro,
altrimenti potresti pensare di fare un metodo static con due
parametri.
Se ho capito tutto il contrario di quello che dicevi scusami, tieni
presente che il codice č buttato lě, potrebbero esserci errori, non
tocco il Java da quando usavo l'1.2
-- 
_____________________
RedPelle
--==--==--==--==--==--==--
 
redp...@email.it
 
www.redpelle.cjb.net
--==--==--==--==--==--==--

dall'insieme in imput S.
Sembra che ti serva piů che altro un vettore, io se ho ben capito


 --
Non scusarti, di sicuro ne sai piu' di me. Probabilmente come dici tu e'
giusto ma io non posso discostarmi troppo dalla traccia dell'esercizio.
Devo scrivere una classe Insieme in cui sia definito un array di oggetti, un
intero che rappresenta il massimo numero di oggetti che l'array puň
contenere e un intero che rappresenta il numero di oggetti presenti.
In questa classe deve esserci il metodo di cui sopra e da tutta questa
classe devo derivarne un'altra che puň contenere solo istanza di tipo
stringa.
Spero di essermi spiegato bene, almeno faccio passare la curiosita' a chi si
e' incuriosito :-)
Ciao e grazie ancora

Non scusarti, di sicuro ne sai piu' di me.
Beh, non esageriamo...  :)



Non esagero affatto!

}
E' una buona idea e, anche se Spaten non potesse adottarla, gli segnalerei 
la possibilità di esaminare i sorgenti della classe Vector e (meglio?) 
ArrayList.
Si trovano nel file src.zip nella cartella del jdk.
Attenzione che derivando da tali classi, per risolvere l'esercizio, 
bisognerebbe lavorare ancora un pochino per assicurare il rispetto delle 
dimensioni massime. ;-)
-- 
Ciao
	Fabrizio C.

modo seguente:
// abstract appare sbagliato in questo caso
public abstract class Insieme {
    // meglio dichiarare i membri private o protected
    Object[] arrayOgg;
    // maxNumElementi non ti serve essendo sempre uguale a 
    // arrayOgg.length
    // informazioni duplicate sono soggette ad errori per 
    // la necessità di tenerle sincronizzate
    int maxNumElementi;
    // un nome più indicato per cardinal sarebbe count IMHO
    int cardinal;
    // duplichi inutilmente e malamente il codice dei costruttori
    // inoltre crei, assegni e distruggi le variabili locali cardinal
    // e maxNumElementi senza nessuna utilità:
    // rivedi un po' il concetto di scope
    // qui meglio
    // public Insieme() {
    //     this(10);
    // }
    public Insieme() {
        int cardinal = 0;
        int maxNumElementi = 10;
        Object[] arrayOgg = new Object[maxNumElementi];
    }
    // manca sincronizzazione: non inizializzi maxNumElementi
    // e ancora crei un cardinal locale senza usarlo
    public Insieme(int maxNumElementi) {
        int cardinal;
        Object[] arrayOgg = new Object[maxNumElementi];
    }
    // premesso che un nome più sensato sarebbe size,
    // qui si rivela l'inutilità di maxNumElementi
    public int getMaxNumElementi() {
        int maxElem = arrayOgg.length;
        return maxElem;
    }
    // nulla da segnalare
    public boolean add(Object obj) {
        if (cardinal < maxNumElementi) {
            arrayOgg[cardinal++] = obj;
            return true;
        }
        return false;
    }
    // corretto ma migliorabile:
    // adotta la stessa struttura del metodo precedente.
    // perché scorrere tutto l'array una volta che hai 
    // trovato ciò ce cerchi?
    // fai un return true. 
    // potrebbe essere un miglioramento nelle prestazioni
    // oltre che un chiarimento nella logica
    public boolean in(Object obj) {
        boolean verifica = false;
        for (int i = 0; i < arrayOgg.length; i++) {
            if (arrayOgg[i] == obj) {
                verifica = true;
            }
        }
        return verifica;
    }
}
HTH
-- 
Ciao
	Fabrizio C.

 Sembra che ti serva piů che altro un vettore, 
Estendere per estendere, c'e' gia' Set. Come molte collection, ha il metodo 
addAll(Collection c). Ora, siccome per definizione in un set gli elementi 
sono unici... ;-)
-- 
Life's something u don't get out alive..
ObjectZone - 
http://space.tin.it/computer/csadun

Cut
Ciao ho letto solo ora le tue risposte e ti ringrazio per il tempo che hai
dedicato a spiegarmi chiaramente dove sbaglio.
Premetto che in questo momento non riesco a leggere lo schermo del pc per
quanto sono stanco.
Comunque appena posso ti faccio sapere se i tuoi sforzi sono serviti a
qualcosa :)))
A presto.