Anzahl der während der Überladung der Java-Methode zusammenfallenden Argumente

Question

Ich bin auf eine Frage gestoßen, bei der wir das Volumen einer Kugel, eines Zylinders und eines Kegels mit Methodenüberladung berechnen müssen. Im Folgendes ist mein Code, die absolut in Ordnung ist:

import java.util.*; 
class Vol_Sph_Cyl_Con 
{ 
    void calc_volume(double sp_rd) 
    { 
     double volume=(4*3.14*(Math.pow(sp_rd,3)))/3; 
     System.out.println("Volume of the sphere is "+volume+" cc");  
    } 
    void calc_volume(double cyl_rd, double cyl_he) 
    { 
     double volume=3.14*(Math.pow(cyl_rd,2))*cyl_he; 
     System.out.println("Volume of the cylinder is "+volume+" cc"); 
    } 
    void calc_volume(double con_rd,double con_he,double pie) 
    { 
     double volume=(pie*(Math.pow(con_rd,2))*con_he)/2; 
     System.out.println("Volume of the cone is "+volume+" cc"); 
    } 
    public static void main(String args[]) 
    { 
     Scanner sc=new Scanner(System.in); 
     Vol_Sph_Cyl_Con ob=new Vol_Sph_Cyl_Con(); 
     double sp_rad=0.0; 
     do 
     { 
      System.out.println("Enter radius of sphere to calculate the volume (in centimetres)"); 
      sp_rad=sc.nextDouble(); 
      if (sp_rad<=0) 
      { 
       System.out.println("Error!"); 
      } 
     }while (sp_rad<=0); 
     ob.calc_volume(sp_rad); 
     double cyl_rad=0.0, cyl_hei=0.0; 
     do 
     { 
      System.out.println("Enter the radius and the height of cylinder respectively to calculate volume (in centimetres)"); 
      cyl_rad=sc.nextDouble(); 
      cyl_hei=sc.nextDouble(); 
      if (cyl_rad<=0 || cyl_hei<=0) 
      { 
       System.out.println("Error!"); 
      } 
     }while (cyl_rad<=0 || cyl_hei<=0); 
     ob.calc_volume(cyl_rad,cyl_hei); 
     double con_rad=0.0, con_hei=0.0, pi=3.14; 
     do 
     { 
      System.out.println("Enter radius and height of cone respectively to calculate volume (in centimetres)"); 
      con_rad=sc.nextDouble(); 
      con_hei=sc.nextDouble(); 
      if (con_rad<=0 || con_hei<=0) 
      { 
       System.out.println("Error!"); 
      } 
     }while (con_rad<=0 || con_hei<=0); 
     ob.calc_volume(con_rad,con_hei,pi); 
     } 
    } 

Das Programm ist absolut in Ordnung, aber das Problem ist, wie dies für ein Schulprojekt ist, dass ich nicht das Argument ‚pie‘ in der Methode übergeben kann, die den Wert berechnet von Kegel, da wir nicht explizit etwas passieren dürfen, was nicht erforderlich ist. Aber wenn ich das nicht tue, fällt die Anzahl der Argumente zusammen. Gibt es einen Weg, dies zu lösen, oder ist es nur ein Problem mit der Frage?

Answer 1

Es gibt keine Möglichkeit, drei Methoden auf zwei Arten von Argumenten aufzulösen: Wenn Sie die Höhe und den Radius für einen Kegel und einen Zylinder übergeben möchten, müssten Sie den Namen einer der Methoden ändern.

Sie können jedoch Ihr Problem auf andere Weise verallgemeinern: Anstatt zwei separate Methoden zur Berechnung des Volumens für Konusse und für Zylinder zu haben, haben Sie eine Methode, die das Volumen eines frustum Konus berechnet, der verallgemeinert werden kann sowohl ein Zylinder (oben Radius = Bodenradius) und ein Konus (oben Radius = 0):

Dies läßt dich mit nur zwei Methoden - einem für die Kugel, und einem für Kegel und Zylinder:

void calc_volume(double top, double bottom, double height) { 
    double v = Math.PI * height * (top*top + top*bottom + bottom*bottom)/3; 
    System.out.println("Volume is " + v + " cc"); 
} 

Wenn Sie diese Methode aufrufen, um das Volumen für den Konus zu berechnen, übergeben Sie 0 für top und Basisradius für bottom. Für den Zylinder den Basisradius für beide top und bottom übergeben.

Answer 2

Momentan sind Ihre Argumente die definierenden Werte für die geometrischen Körper, aus denen Sie das Volumen berechnen möchten. Wenn Sie zwei oder mehr geometrische Körper haben, die dieselben Definitionswerttypen gemeinsam haben, werden Sie verlieren, da Sie sie nur anhand der Typen nicht unterscheiden können, da sie gleich sind. Wie es von tobias_k hingewiesen wurde.

Was Sie tun können, um dies zu lösen, ist eine Darstellung für jeden geometrischen Körper, den Sie für Ihren Code benötigen. Diese können dann als einziges Argument für Ihre Volumenberechnungsmethode verwendet werden.

Also für Ihr Beispiel würden Sie benötigen: eine Kugel, ein Zylinder und eine Kegel-Klasse.

Da dies eine Hausaufgabe ist, sollten wir es Ihnen überlassen, darüber nachzudenken, wie Sie diese Klassen entwerfen. Ihre überladene Methode würde aussehen wie so:

void calc_volume(Sphere sphere) {} 
void calc_volume(Cylinder cylinder) {} 
void calc_volume(Cone cone) {} 

Wie Sie sehen, gibt es keine weitere Beschränkung der Anzahl von geometrischen Objekten, die Sie diesen Entwurf umgehen konnte verwenden.

Answer 3

Einige Leute erwähnten in den Kommentaren, dass das Überladen von Methoden in diesem Fall ziemlich hässlich ist. Dem stimme ich persönlich zu.

Wie auch immer, Sie können "Argument" -Klassen erstellen, um Ihre Parameter zu übergeben, so dass Sie immer nur ein Argument benötigen.

Beispiel für eine Kugel:

public class SphereArguments { 
    private double radius; 

    /** 
    * @param radius 
    */ 
    public SphereArguments(double radius) { 
     this.radius = radius; 
    } 

    /** 
    * @return the radius 
    */ 
    public double getRadius() { 
     return radius; 
    } 
} 

und calc_volume würde:

void calc_volume(SphereArguments arg) 
{ 
    double volume=(4*Math.PI *(Math.pow(arg.getRadius(),3)))/3; 
    System.out.println("Volume of the sphere is "+volume+" cc");  
} 

und den Anruf:

ob.calc_volume(new SphereArguments(sp_rad)); 

Sie natürlich haben einige die gleiche Art und Weise zu tun mit CylinderArguments Klasse für den Zylinder und "ConeArguments" -Klasse für den Kegel.

Beachten Sie auch, dass Java-Namen in CamelCase vereinbarungs sind so sollte calc_volumecalcVolume werden ...