Classi

Da Wikipedia, l'enciclopedia libera.

La classe , in programmazione, è un ADT (Abstract Data Type - tipo di dato astratto) che costituisce la base della programmazione ad oggetti. Una classe racchiude in se sia dati (anche assai eterogenei, sia del livello built-in che appartenenti ad altre classi), che il codice (metodi o funzioni) che andrà ad agire su di essi.

I dati all'interno di una classe possono essere modificati solo attraverso i metodi o funzioni che tale classe mette a disposizione per la loro modifica.

I metodi di una classe, quindi, costituiscono l'interfaccia che presenta una classe con l'ambiente esterno. Essi proteggono i dati contenuti all'interno di una classe da loro manipolazioni errate a causa di fraintendimenti sui ruoli delle variabili modificabili sia all'interno che all'esterno delle istanze della classe.

Un programmatore che utilizza una classe realizzata in precedenza, non deve conoscere la sua implementazione interna per poterla utilizzare ma basta che conosca le prestazioni dei metodi che essa mette a disposizione. Ciò permette, nel corso di uno sviluppo di un programma per stadi successivi, di cambiare l'implementazione interna di una classe senza che si debbano modificare i programmi che facevano uso di essa. Questo concetto è conosciuto come trasparenza.

Il tipo di dato classe, quindi, si presta molto bene a rappresentare l'astrazione di un tipo di oggetti reali ed infatti all'interno dei linguaggi di programmazione ad oggetti viene ampiamente usato per dichiarare oggetti.
Data una classe, possono esser definiti più oggetti della stessa classe ed ognuno di esso viene detto istanza della classe o oggetto della classe. Ad esempio per controllare il tracciamento di triangoli in un pacchetto di grafica può essere conveniente definira una classe 'triangolo' che prevede la possibilità di dare un colore alla sua area interna; nella procedura si possono definire più istanze di tale classe e tracciare triangoli blu, triangoli verde, triangoli rossi etc.

Un esempio di Classe in java può essere questo

Si nota le varie caratteristiche della programmazione ad oggetti (ereditarietà, polimorfismo e livello di visibilità delle variabili )

public abstract class quadrupede {
        protected final double c = 3D;
        protected double peso;
        protected static int quantita=0;

        public quadrupede(){
                quantita++;
        }

        public abstract double getValore();
        public double getPeso () {return (peso);}
        public int getTotale () {return (quantita);}
}
class cavallo extends quadrupede{
        protected String razza;
        protected boolean domato;

        public cavallo(String myRazza,boolean myDomato,double myPeso){
                super();
                razza = new String(myRazza);
                domato = myDomato;
                peso = myPeso;
        }
        public double getValore(){return(c+peso);}
}
abstract class canide extends quadrupede{
        protected double lunghezza;
        
        public canide(){
                super();
        }
        
        public double getLunghezza(){return(lunghezza);}        
}
class cane extends canide{
        protected pedigree ped;
        
        public cane(pedigree myPed, double myLung, double myPeso){
                        super();
                        lunghezza = myLung;
                        ped = myPed;
                        peso = myPeso;
        }
        
        public double getValore(){return(2+c+10*lunghezza+ped.getNumAntenati());}
        
} 
class lupo extends canide{
        
        public lupo (double myLung, double myPeso){
                        super();
                        lunghezza = myLung;
                        peso = myPeso;
        }
        
        public double getValore(){return(Math.pow(c+peso,7)*lunghezza/0.2);}

        public String toString(){return("Lupo ["+lunghezza+", "+peso+", "+getValore()+"]");}
        
} 
class yorkshire extends cane{
        private char tipoNaso;
        
        public yorkshire (pedigree myPed, double myLung, double myPeso,char myTipoNaso){
                        super(myPed,myLung,myPeso);
                        tipoNaso=myTipoNaso;
        }
        public String toString(){return("Yorkshire ["+ped+", "+lunghezza+", "+peso+", "+getValore()+"euro]");}
}

poi implementeremo la classe con una funzione main

public class principale{
        public static void main (String [] args){
                int i;
                quadrupede [] animali = new quadrupede[200];
                //Generazione Casuale
                for( i=0; i<animali.length; i++){
                        switch ((int)(Math.random()*4)){
                                case 0 : animali[i] = new yorkshire(GeneraPed(),Math.random()*50,Math.random()*30,(char)(Math.random()*255));
                                        break;
                                case 1 : animali[i] = new cane(GeneraPed(),Math.random()*50,Math.random()*30);
                                        break;
                                case 2 : animali[i] = new lupo(Math.random()*50,Math.random()*30);
                                        break;
                                case 3 : animali[i] = new cavallo("razza",(Math.random()<.5),Math.random()*300);
                                        break;
                        }
                }
                //Stampa il ToString di oggi oggetto Stampato
                for( i=0; i<animali.length; i++) System.out.println(animali[i]);
                //Ricerca della Casella del Valore Massimo
                double max = animali[0].getValore();
                int maxInd = 0;
                for(i=1; i<animali.length; i++)
                        if (max < animali[i].getValore()){
                                         max = animali[i].getValore();
                                         maxInd = i;
                        }  
                
                System.out.println("Animale + prezioso è "+ animali[maxInd]);
                //ordinamento crescente e e stampa in Ordine
                yorkshire []y = new yorkshire[200];
                int x=0;
                for(i=0; i<animali.length; i++)
                        if(animali[i] instanceof yorkshire )
                                y[x++]=(yorkshire)(animali[i]);
                yorkshire app;
                for(i=0; i<x; i++)
                        for(int z=0; z<x; z++)
                                if (y[i].getPeso()<y[z].getPeso()) {
                                        app = y[z];
                                        y[z]= y[i];
                                        y[i]= app;
                                }
                for( i=0; i<x; i++) System.out.println(y[i]);
                //Stampa gli oggetti creati fino a quel momento
                System.out.println(animali[12].getTotale());
                
        }
        static pedigree GeneraPed (){
                char [] cod = new char [200];
                for(int i=0; i<cod.length; i++) cod[i]=(char)(Math.random()*255);
                return new pedigree(cod,(int)(Math.random()*255),"11111");
        }
}