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?