Pagina 1 di 2 1 2 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 11

Discussione: programmare a oggetti

  1. #1
    Utente di HTML.it
    Registrato dal
    Oct 2014
    Messaggi
    315

    programmare a oggetti

    Poichè fino a poco tempo fa commettevo l'errore di non programmare a oggetti volevo essere certo di aver capito e di non saltare nulla.
    L'esercizio in questione parte da del codice e richiede di riprogettare l'applicazione cercando di rispettare le regole dell'OO, in particolare richiede di individuare le astrazioni chiave, di assegnare loro responsabilità avendo cura dell'astrazione e individuare le relazioni tra esse.
    Il codice da cui parte l'esercizio è questo:
    codice:
    public class TestGeometrico {
        public static void main(String args[]) {
            /* dichiariamo le variabili locali */
            Punto p1 = null, p2 = null;
            /* testiamo se sono stati inseriti il giusto numero
            di parametri */
            if (args.length == 4) {
                //Conversione a tipo int di stringhe
                int p1X = Integer.parseInt(args[0]);
                int p1Y = Integer.parseInt(args[1]);
                int p2X = Integer.parseInt(args[2]);
                int p2Y = Integer.parseInt(args[3]);
                //Istanza dei due punti
                p1 = new Punto(p1X, p1Y);
                p2 = new Punto(p2X, p2Y);
            }
            else if (args.length == 6) {
                //Conversione a tipo int di stringhe
                int p1X = Integer.parseInt(args[0]);
                int p1Y = Integer.parseInt(args[1]);
                int p1Z = Integer.parseInt(args[3]);
                int p2X = Integer.parseInt(args[4]);
                int p2Y = Integer.parseInt(args[5]);
                int p2Z = Integer.parseInt(args[6]);
                //Istanza dei due punti
                p1 = new Punto3D(p1X, p1Y, p1Z);
                p2 = new Punto3D(p2X, p2Y, p2Z);
            }
            else {
                System.out.println(
                "inserisci 4 o 6 parametri");
                System.exit(0); // Termina l’applicazione
            }
            //Stampa della distanza
            System.out.println("i punti distano "
            + p1.dammiDistanza(p2));
        }
    }
    codice:
    public class Punto {
        private int x, y;
        public Punto() {
            //Costruttore senza parametri
        }
        public Punto(int x, int y) {
            this.setXY(x, y); //Il this è facoltativo
            //riutilizziamo codice
        }
        public void setX(int x) {
            this.x = x; //Il this non è facoltativo
        }
        public void setY(int y) {
            this.y = y; //Il this non è facoltativo
        }
        public void setXY(int x, int y) {
            this.setX(x); //Il this è facoltativo
            this.setY(y);
        }
        public int getX() {
            return this.x; //Il this è facoltativo
        }
        public int getY() {
            return this.y; //Il this è facoltativo
        }
        public double dammiDistanza(Punto p) {
            //quadrato della differenza delle x dei due punti
            int tmp1 = (x - p.x)*(x - p.x);
            //quadrato della differenza della y dei due punti
            int tmp2 = (y - p.y)*(y - p.y);
            //radice quadrata della somma dei due quadrati
            return Math.sqrt(tmp1 + tmp2);
        }
    }
    codice:
    public class Punto3D extends Punto {
        private int z;
        public Punto3D() {
            //Costruttore senza parametri
        }
        public Punto3D(int x, int y, int z) {
            this.setXYZ(x, y, z); //Riuso di codice
        }
        public void setZ(int z) {
            this.z = z; //Il this non è facoltativo
        }
        public void setXYZ(int x, int y, int z) {
            this.setXY(x, y); //Riuso del codice
            this.setZ(z); //Il this è facoltativo
        }
        public int getZ() {
            return this.z; //Il this è facoltativo
        }
        public double dammiDistanza(Punto p) {
            if (p instanceof Punto3D) {
                //Chiamata ad un metodo privato tramite casting
                return this.calcolaDistanza((Punto3D)p);
            }
            else {
                return -1; //distanza non valida!
            }
        }
        @Override
        private double calcolaDistanza(Punto3D p1) {
            //quadrato della differenza della x dei due punti
            int tmp1=(getX()-p1.getX())*(getX()-p1.getX());
            //quadrato della differenza della y dei due punti
            int tmp2=(getY()-p1.getY())*(getY()-p1.getY());
            //quadrato della differenza della z dei due punti
            int tmp3=(z-p1.z)*(z-p1.z);
            //radice quadrata della somma dei tre quadrati
            return Math.sqrt(tmp1+tmp2+tmp3);
        }
    }

    Quello che io ho fatto è stato innanzitutto di creare una classe Punto generica, successivamente di creare le classi Punto2D e Punto3D sottoclassi di Punto e suddividere il tutto in package per evitare di avere tutto in un'unico package. Vabbè poi ho riprogettato la classe del main ma quello è più per una questione diciamo estetica/funzionale.
    Questa è la mia soluzione:
    codice:
    package test;
    import java.util.Scanner;
    
    import dati.Punto2D;
    import dati.Punto3D;
    
    public class TestGeometrico {
        public static void main(String args[]) {
            System.out.println("effettuare una scelta");
            System.out.println("1 - distanza tra due punti 2D");
            System.out.println("2 - distanza tra due punti 3D");
            System.out.println("3 - termina programma");
            
            try (Scanner scanner = new Scanner(System.in);) {
            while(scanner.hasNext()) {
                String scelta = scanner.next();
                
                switch (scelta) {
                    case "1":
                        System.out.println("inserisci prima coordinata punto 1");
                        int p1x2d = scanner.nextInt();
                        System.out.println("inserisci seconda coordinata punto 1");
                        int p1y2d = scanner.nextInt();
                        System.out.println("inserisci prima coordinata punto 2");
                        int p2x2d = scanner.nextInt();
                        System.out.println("inserisci seconda coordinata punto 2");
                        int p2y2d = scanner.nextInt();
                        Punto2D punto1_2d = new Punto2D(p1x2d,p1y2d);
                        Punto2D punto2_2d = new Punto2D(p2x2d,p2y2d);
                        double risultato2d = punto1_2d.dammiDistanza(punto2_2d);
                        System.out.println("la distanza tra i due punti è " + risultato2d);
                        System.out.println("\neffettuare una scelta:");
                        System.out.println("1 - distanza tra due punti 2D");
                        System.out.println("2 - distanza tra due punti 3D");
                        System.out.println("3 - termina programma");
                        break;
                    case "2":
                        System.out.println("inserisci prima coordinata punto 1");
                        int p1x3d = scanner.nextInt();
                        System.out.println("inserisci seconda coordinata punto 1");
                        int p1y3d = scanner.nextInt();
                        System.out.println("inserisci terza coordinata punto 1");
                        int p1z3d = scanner.nextInt();
                        System.out.println("inserisci prima coordinata punto 2");
                        int p2x3d = scanner.nextInt();
                        System.out.println("inserisci seconda coordinata punto 2");
                        int p2y3d = scanner.nextInt();
                        System.out.println("inserisci terza coordinata punto 2");
                        int p2z3d = scanner.nextInt();
                        Punto3D punto1_3d = new Punto3D(p1x3d,p1y3d,p1z3d);
                        Punto3D punto2_3d = new Punto3D(p2x3d,p2y3d,p2z3d);
                        double risultato3d = punto1_3d.dammiDistanza(punto2_3d);
                        System.out.println("la distanza tra i due punti è " + risultato3d);
                        System.out.println("\neffettuare una scelta:");
                        System.out.println("1 - distanza tra due punti 2D");
                        System.out.println("2 - distanza tra due punti 3D");
                        System.out.println("3 - termina programma");
                        break;
                    case "3":
                        System.out.println("PROGRAMMA TERMINATO");
                        System.exit(0);
                        break;
                    default:
                        System.out.println("digitare altro valore:");
                        System.out.println("1 - distanza tra due punti 2D");
                        System.out.println("2 - distanza tra due punti 3D");
                        System.out.println("3 - termina programma");
                        break;
                }
             }
          }
        }
    }
    codice:
    package dati;
    
    public class Punto {
        
        protected int x;
        protected int y;
        
        
        public void setX(int x) {
            this.x = x;
        }
        
        public void setY(int y) {
            this.y = y;
        }
        
        public void setXY(int x, int y) {
            setX(x);
            setY(y);
        }
        
        public int getX() {
            return x;
        }
        
        public int getY() {
            return y;
        }
        
    }
    codice:
    package dati;
    
    public class Punto2D extends Punto {
        
         public Punto2D(int x, int y) {
                this.setXY(x, y); 
         }
        
     
         public double dammiDistanza(Punto2D p) {
             int tmp1 = (x - p.x)*(x - p.x);
             int tmp2 = (y - p.y)*(y - p.y);
             return Math.sqrt(tmp1 + tmp2);
         }
    
    }
    codice:
    package dati;
    
    public class Punto3D extends Punto {
        
        private int z;
        
        public Punto3D(int x, int y, int z) {
                this.setXYZ(x, y, z); 
        }
         
        public void setZ(int z) {
                this.z = z; 
        }
    
            
        public void setXYZ(int x, int y, int z) {
                this.setXY(x, y);
                this.setZ(z); 
        }
            
            
        public int getZ() {
                return this.z; 
        }
    
            
        public double dammiDistanza(Punto3D p1) {
             int tmp1=(getX()-p1.getX())*(getX()-p1.getX());
             int tmp2=(getY()-p1.getY())*(getY()-p1.getY());
             int tmp3=(z-p1.z)*(z-p1.z);
             return Math.sqrt(tmp1+tmp2+tmp3);
        }  
            
    }


    Cosa ne pensate? Ci siamo con la programmazione a oggetti?

  2. #2
    Utente di HTML.it
    Registrato dal
    Oct 2014
    Messaggi
    315
    nessuno mi da un parere?

  3. #3
    che se ponevi Z = 0 di default per il 2D, ti bastava un'unica classe Punto.
    IP-PBX management: http://www.easypbx.it

    Old account: 2126 messages
    Oldest account: 3559 messages

  4. #4
    Secondo me giusta la sottoclasse Punto3D ma errata la classe Punto, perchè superflua è un Punto2D e inoltra dichiarando il metodo "dammiDistanza" in punto2D/3D avendo una referenza a Punto non potresti richiamare il metodo (ovviamente senza effettuare un casting).

  5. #5
    Utente di HTML.it
    Registrato dal
    Oct 2014
    Messaggi
    315
    Quote Originariamente inviata da Santino83_02 Visualizza il messaggio
    che se ponevi Z = 0 di default per il 2D, ti bastava un'unica classe Punto.
    giusto, ma in quel modo non avrei violato o comunque non rispettato al 100% alcuni principi della programmazione OO?

    Quote Originariamente inviata da francesco.muia Visualizza il messaggio
    Secondo me giusta la sottoclasse Punto3D ma errata la classe Punto, perchè superflua è un Punto2D
    ma poi avrei dovuto estendere Punto2D attraverso Punto3D e in quel modo sarebbe violata la relazione "is a", o sbaglio?

  6. #6
    Qui piu che di OOP parlerei di geometria:

    Nella geometria cartesiana del piano e dello spazio euclideo un punto è un insieme ordinato di coordinate. Quindi un punto nello spazio tridimensionale è una terna di numeri, ad esempio:

    P = (2, 6, 9).
    Dove, riferendosi al "2D", la coordinata Z è 0 di definizione e il sistema di coordinate parte per definizione da (0,0,0). Quindi le tue classi in realtà sono una sola classe (punto) a 3 coordinate(x,y,z) a valori di default (0,0,0).
    IP-PBX management: http://www.easypbx.it

    Old account: 2126 messages
    Oldest account: 3559 messages

  7. #7
    Utente di HTML.it
    Registrato dal
    Oct 2014
    Messaggi
    315
    Ah ecco, quindi in questo caso specifico sarebbe bastata una sola classe.
    Ma a parte questa cosa, le regole dell'OO vengono rispettate nella mia soluzione?

  8. #8
    Quote Originariamente inviata da newutente Visualizza il messaggio
    Ah ecco, quindi in questo caso specifico sarebbe bastata una sola classe.
    Ma a parte questa cosa, le regole dell'OO vengono rispettate nella mia soluzione?
    Ni, un Punto3D io lo vedo come un sotto tipo di punto 2D e non di punto (come detto prima la classe punto l'avrei levata o al + resa interfaccia)....

  9. #9
    Utente di HTML.it
    Registrato dal
    Oct 2014
    Messaggi
    315
    Quote Originariamente inviata da francesco.muia Visualizza il messaggio
    come detto prima la classe punto l'avrei levata o al + resa interfaccia
    però forse in questo caso specifico sarebbe stato più sensato, tra le due possibilità, eliminare la classe perchè altrimenti rendendola interfaccia avrebbe contenuto solo le versioni astratte dei metodi set e get e, tra l'altro, x e y le avrei dovute dichiarare costanti e non variabili. Insomma non so quanto poteva avere un senso rispetto alla semplice rimozione della classe.

  10. #10
    Infatti ho detto al + l'avrei resa interfaccia....

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.