C # vs Java Enum (per chi non conosce C #)


182

Sto programmando in Java da un po 'e sono appena stato lanciato su un progetto scritto interamente in C #. Sto cercando di accelerare in C #, e ho notato che gli enum sono stati usati in diversi punti del mio nuovo progetto, ma a prima vista, gli enum di C # sembrano essere più semplicistici dell'implementazione di Java 1.5+. Qualcuno può enumerare le differenze tra enumerazioni C # e Java e come superare le differenze? (Non voglio iniziare una guerra di fiamme di lingua, voglio solo sapere come fare alcune cose in C # che facevo in Java). Ad esempio, qualcuno potrebbe pubblicare una controparte C # nel famoso esempio di enum Planet di Sun?

public enum Planet {
  MERCURY (3.303e+23, 2.4397e6),
  VENUS   (4.869e+24, 6.0518e6),
  EARTH   (5.976e+24, 6.37814e6),
  MARS    (6.421e+23, 3.3972e6),
  JUPITER (1.9e+27,   7.1492e7),
  SATURN  (5.688e+26, 6.0268e7),
  URANUS  (8.686e+25, 2.5559e7),
  NEPTUNE (1.024e+26, 2.4746e7),
  PLUTO   (1.27e+22,  1.137e6);

  private final double mass;   // in kilograms
  private final double radius; // in meters
  Planet(double mass, double radius) {
      this.mass = mass;
      this.radius = radius;
  }
  public double mass()   { return mass; }
  public double radius() { return radius; }

  // universal gravitational constant  (m3 kg-1 s-2)
  public static final double G = 6.67300E-11;

  public double surfaceGravity() {
      return G * mass / (radius * radius);
  }
  public double surfaceWeight(double otherMass) {
      return otherMass * surfaceGravity();
  }
}

// Example usage (slight modification of Sun's example):
public static void main(String[] args) {
    Planet pEarth = Planet.EARTH;
    double earthRadius = pEarth.radius(); // Just threw it in to show usage

    // Argument passed in is earth Weight.  Calculate weight on each planet:
    double earthWeight = Double.parseDouble(args[0]);
    double mass = earthWeight/pEarth.surfaceGravity();
    for (Planet p : Planet.values())
       System.out.printf("Your weight on %s is %f%n",
                         p, p.surfaceWeight(mass));
}

// Example output:
$ java Planet 175
Your weight on MERCURY is 66.107583
Your weight on VENUS is 158.374842
[etc ...]

1
@ycomp Non me lo posso prendere. Viene da Sun (ora Oracle): docs.oracle.com/javase/tutorial/java/javaOO/enum.html
Ogre33

Risposte:


210

Le enumerazioni nel CLR sono semplicemente denominate costanti. Il tipo sottostante deve essere integrale. In Java un'enumerazione è più simile a un'istanza denominata di un tipo. Tale tipo può essere piuttosto complesso e - come mostra l'esempio - contiene più campi di vari tipi.

Per portare l'esempio in C #, cambierei semplicemente l'enum in una classe immutabile ed esporre istanze di sola lettura statiche di quella classe:

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Planet planetEarth = Planet.MERCURY;

            double earthRadius = pEarth.Radius; // Just threw it in to show usage
            double earthWeight = double.Parse("123");
            double earthMass   = earthWeight / pEarth.SurfaceGravity();

            foreach (Planet p in Planet.Values)
                Console.WriteLine($"Your weight on {p} is {p.SurfaceWeight(mass)}");

            Console.ReadKey();
        }
    }

    public class Planet
    {
        public static readonly Planet MERCURY = new Planet("Mercury", 3.303e+23, 2.4397e6);
        public static readonly Planet VENUS   = new Planet("Venus", 4.869e+24, 6.0518e6);
        public static readonly Planet EARTH   = new Planet("Earth", 5.976e+24, 6.37814e6);
        public static readonly Planet MARS    = new Planet("Mars", 6.421e+23, 3.3972e6);
        public static readonly Planet JUPITER = new Planet("Jupiter", 1.9e+27, 7.1492e7);
        public static readonly Planet SATURN  = new Planet("Saturn", 5.688e+26, 6.0268e7);
        public static readonly Planet URANUS  = new Planet("Uranus", 8.686e+25, 2.5559e7);
        public static readonly Planet NEPTUNE = new Planet("Neptune", 1.024e+26, 2.4746e7);
        public static readonly Planet PLUTO   = new Planet("Pluto", 1.27e+22, 1.137e6);

        public static IEnumerable<Planet> Values
        {
            get
            {
                yield return MERCURY;
                yield return VENUS;
                yield return EARTH;
                yield return MARS;
                yield return JUPITER;
                yield return SATURN;
                yield return URANUS;
                yield return NEPTUNE;
                yield return PLUTO;
            }
        }

        public string Name   { get; private set; }
        public double Mass   { get; private set; }
        public double Radius { get; private set; }

        Planet(string name, double mass, double radius) => 
            (Name, Mass, Radius) = (name, mass, radius);

        // Wniversal gravitational constant  (m3 kg-1 s-2)
        public const double G = 6.67300E-11;
        public double SurfaceGravity()            => G * mass / (radius * radius);
        public double SurfaceWeight(double other) => other * SurfaceGravity();
        public override string ToString()         => name;
    }
}

4
È questo tipo di enumerazione sicura dei tipi che noi poveri costretti a usare Java 1.4 e versioni successive dobbiamo implementare ... Gli enum di Java 5 sono forse la migliore caratteristica di Java 5+, soprattutto perché possono essere usati nelle istruzioni switch.
MetroidFan2002,

9
@Chris: solo gli enum di bandiera dovrebbero essere pluralizzati. Cioè, le enumerazioni i cui membri sono combinati usando | operatore.
Kent Boogaart,

5
@Mladen: dipende interamente dal contesto. Un elenco di pianeti può essere perfettamente adatto a un gioco che fornisce l'accesso a un numero limitato di pianeti. Le modifiche al codice possono essere esattamente ciò che desideri se un nuovo pianeta viene aggiunto al gioco.
Kent Boogaart,

3
@Richie_W puoi iterare sugli enum usando la proprietà Values.
Jonathan,

23
Wow ... È quasi incredibile vedere qualcosa implementato in modo più dettagliato in C # che in Java
Sune Rasmussen,

218

In C # puoi definire i metodi di estensione su enum e questo compensa alcune delle funzionalità mancanti.

Puoi definire Planet un enum e avere anche metodi di estensione equivalenti a surfaceGravity()e surfaceWeight().

Ho usato attributi personalizzati come suggerito da Mikhail , ma lo stesso potrebbe essere ottenuto usando un dizionario.

using System;
using System.Reflection;

class PlanetAttr: Attribute
{
    internal PlanetAttr(double mass, double radius)
    {
        this.Mass = mass;
        this.Radius = radius;
    }
    public double Mass { get; private set; }
    public double Radius { get; private set; }
}

public static class Planets
{
    public static double GetSurfaceGravity(this Planet p)
    {
        PlanetAttr attr = GetAttr(p);
        return G * attr.Mass / (attr.Radius * attr.Radius);
    }

    public static double GetSurfaceWeight(this Planet p, double otherMass)
    {
        return otherMass * p.GetSurfaceGravity();
    }

    public const double G = 6.67300E-11;

    private static PlanetAttr GetAttr(Planet p)
    {
        return (PlanetAttr)Attribute.GetCustomAttribute(ForValue(p), typeof(PlanetAttr));
    }

    private static MemberInfo ForValue(Planet p)
    {
        return typeof(Planet).GetField(Enum.GetName(typeof(Planet), p));
    }

}

public enum Planet
{
    [PlanetAttr(3.303e+23, 2.4397e6)]  MERCURY,
    [PlanetAttr(4.869e+24, 6.0518e6)]  VENUS,
    [PlanetAttr(5.976e+24, 6.37814e6)] EARTH,
    [PlanetAttr(6.421e+23, 3.3972e6)]  MARS,
    [PlanetAttr(1.9e+27,   7.1492e7)]  JUPITER,
    [PlanetAttr(5.688e+26, 6.0268e7)]  SATURN,
    [PlanetAttr(8.686e+25, 2.5559e7)]  URANUS,
    [PlanetAttr(1.024e+26, 2.4746e7)]  NEPTUNE,
    [PlanetAttr(1.27e+22,  1.137e6)]   PLUTO
}

20
Penso che questo dovrebbe essere votato di più. È più vicino a come funzionano gli enum in Java. Posso fare qualcosa come Planet.MERCURY.GetSurfaceGravity () <- Nota il metodo di estensione su un Enum!
thenonhacker,

2
Decisamente sì. I metodi di estensione su Enum (diamine, metodi di estensione in generale) sono un'ottima aggiunta a C #.
KeithS,

3
@AllonGuralnek Grazie. Tuttavia, non tutti sarebbero d'accordo sui metadati. Vedi il commento di MattDavey su una domanda relativa a codereview.stackexchange .
finnw,

@finnw: non ho mai sentito parlare del sito Code Review SE - grazie per quello! Ho continuato questa discussione lì (anche se potrebbe meritare una sua domanda qui sui programmatori).
Allon Guralnek,

questa è un'ottima soluzione - qualcuno ha testato le prestazioni di questo? ad es. quanto tempo occorre per accedere all'attributo, rispetto all'accesso a una proprietà di una classe.
Simon Meyer,

35

In C # gli attributi possono essere usati con enum. Un buon esempio di questo schema di programmazione con descrizione dettagliata è qui (Codeproject)

public enum Planet
{
   [PlanetAttr(3.303e+23, 2.4397e6)]
   Mercury,
   [PlanetAttr(4.869e+24, 6.0518e6)]
   Venus
} 

Modifica: questa domanda è stata recentemente posta di nuovo e ha risposto Jon Skeet: qual è l'equivalente dell'enum di Java in C #? Classi interne private in C # - perché non vengono utilizzate più spesso?

Modifica 2: vedi la risposta accettata che estende questo approccio in un modo molto brillante!


1
Bello! Questo sembra solo leggermente goffo, ma è altrimenti un metodo molto accettabile per aggiungere dati extra a un enum. Sono sinceramente sorpreso che qualcuno abbia impiegato così tanto tempo per menzionare questa grande soluzione!
Ogre Salmo33,

13

Gli enumerazioni Java sono in realtà classi complete che possono avere un costruttore privato, metodi ecc., Mentre gli enumerazioni C # sono semplicemente denominati numeri interi. L'implementazione di IMO Java è di gran lunga superiore.

Questa pagina dovrebbe aiutarti molto mentre impari c # proveniente da un campo di Java. (Il collegamento indica le differenze relative agli enum (scorrere su / giù per altre cose)


1
Mentre il tuo link offre una panoramica interessante ed estesa delle somiglianze e delle differenze tra C # e Java, ci sono molti errori nel testo (ad esempio afferma erroneamente che Java protetto equivale a C # interno mentre dovrebbe essere protetto internamente). Quindi non dare tutto lì per scontato :)
mafu,

1
Non direi che gli enumerati Java siano superiori anche se sono un fan di Java. C # supporta una semplice dichiarazione di numeri interi, ad esempio FOO = 0più semplice da utilizzare negli strumenti ORM (non è ordinal()necessario alcun uso soggetto a errori ). Inoltre C # supporta le enumerazioni bit per bit che sono spesso molto utili, specialmente in combinazione con EntityFramework. Java dovrebbe estendere i propri enum per consentire anche a loro di essere associati a numeri interi. Quindi sarebbero superiori :)
djmj,

4

Qualcosa del genere penso:

public class Planets 
{
    public static readonly Planet MERCURY = new Planet(3.303e+23, 2.4397e6);
    public static readonly Planet VENUS = new Planet(4.869e+24, 6.0518e6);
    public static readonly Planet EARTH = new Planet(5.976e+24, 6.37814e6);
    public static readonly Planet MARS = new Planet(6.421e+23, 3.3972e6);
    public static readonly Planet JUPITER = new Planet(1.9e+27,   7.1492e7);
    public static readonly Planet SATURN = new Planet(5.688e+26, 6.0268e7);
    public static readonly Planet URANUS = new Planet(8.686e+25, 2.5559e7);
    public static readonly Planet NEPTUNE = new Planet(1.024e+26, 2.4746e7);
    public static readonly Planet PLUTO = new Planet(1.27e+22,  1.137e6);
}

public class Planet
{
    public double Mass {get;private set;}
    public double Radius {get;private set;}

    Planet(double mass, double radius)
    {
        Mass = mass;
        Radius = radius;
    }

    // universal gravitational constant  (m3 kg-1 s-2)
    private static readonly double G = 6.67300E-11;

    public double SurfaceGravity()
    {
        return G * Mass / (Radius * Radius);
    }

    public double SurfaceWeight(double otherMass)
    {
        return otherMass * SurfaceGravity();
    }
}

Oppure combina le costanti nella Planetclasse come sopra


8
Non del tutto: il costruttore Planet dovrebbe essere privato; parte del punto di enum è che sono un insieme fisso di valori. I valori sarebbero quindi definiti anche nella classe Planet.
Jon Skeet,

Non ancora. 1) manca l'enumeratore :) 2) gli enum non dovrebbero mai essere mutabili. Oh e ultimo, il tuo codice richiede una sola classe (specialmente quando hai un costruttore privato)
nawfal

3

Ecco un'altra idea interessante che si rivolge al comportamento personalizzato disponibile in Java. Mi è venuta in mente la seguente Enumerationclasse base:

public abstract class Enumeration<T>
    where T : Enumeration<T>
{   
    protected static int nextOrdinal = 0;

    protected static readonly Dictionary<int, Enumeration<T>> byOrdinal = new Dictionary<int, Enumeration<T>>();
    protected static readonly Dictionary<string, Enumeration<T>> byName = new Dictionary<string, Enumeration<T>>();

    protected readonly string name;
    protected readonly int ordinal;

    protected Enumeration(string name)
        : this (name, nextOrdinal)
    {
    }

    protected Enumeration(string name, int ordinal)
    {
        this.name = name;
        this.ordinal = ordinal;
        nextOrdinal = ordinal + 1;
        byOrdinal.Add(ordinal, this);
        byName.Add(name, this);
    }

    public override string ToString()
    {
        return name;
    }

    public string Name 
    {
        get { return name; }
    }

    public static explicit operator int(Enumeration<T> obj)
    {
        return obj.ordinal;
    }

    public int Ordinal
    {
        get { return ordinal; }
    }
}

In sostanza ha un parametro di tipo solo per cui il conteggio ordinale funzionerà correttamente in diverse enumerazioni derivate. L' Operatoresempio di Jon Skeet dalla sua risposta a un'altra domanda (http://stackoverflow.com/questions/1376312/whats-the-equivalent-of-javas-enum-in-c) diventa quindi:

public class Operator : Enumeration<Operator>
{
    public static readonly Operator Plus = new Operator("Plus", (x, y) => x + y);
    public static readonly Operator Minus =  new Operator("Minus", (x, y) => x - y);
    public static readonly Operator Times =  new Operator("Times", (x, y) => x * y);
    public static readonly Operator Divide = new Operator("Divide", (x, y) => x / y);

    private readonly Func<int, int, int> op;

    // Prevent other top-level types from instantiating
    private Operator(string name, Func<int, int, int> op)
        :base (name)
    {
        this.op = op;
    }

    public int Execute(int left, int right)
    {
        return op(left, right);
    }
}

Questo offre alcuni vantaggi.

  • Supporto ordinale
  • Conversione in stringe intche rende fattibili le istruzioni switch
  • GetType () darà lo stesso risultato per ciascuno dei valori di un tipo di enumerazione derivato.
  • I metodi statici da System.Enumpossono essere aggiunti alla classe Enumeration di base per consentire la stessa funzionalità.

3

abbiamo appena creato un'estensione enum per c # https://github.com/simonmau/enum_ext

È solo un'implementazione per il typesafeenum, ma funziona benissimo, quindi abbiamo creato un pacchetto da condividere: divertiti

public sealed class Weekday : TypeSafeNameEnum<Weekday, int>
{
    public static readonly Weekday Monday = new Weekday(1, "--Monday--");
    public static readonly Weekday Tuesday = new Weekday(2, "--Tuesday--");
    public static readonly Weekday Wednesday = new Weekday(3, "--Wednesday--");
    ....

    private Weekday(int id, string name) : base(id, name)
    {
    }
}

2

Un enum Java è zucchero sintattico per presentare enumerazioni in modo OO. Sono classi astratte che estendono la classe Enum in Java e ogni valore enum è come un'implementazione statica finale di istanza pubblica della classe enum. Guarda le classi generate e per un enum "Foo" con 10 valori, vedrai le classi da "Foo $ 1" a "Foo $ 10".

Non conosco C #, però, posso solo ipotizzare che un enum in quella lingua sia più simile a un enum tradizionale nei linguaggi in stile C. Vedo da una rapida ricerca su Google che possono contenere più valori, quindi sono probabilmente implementati in modo simile, ma con molte più restrizioni rispetto a quanto consentito dal compilatore Java.


3
Beh, tutto in Java e C # non è tutto sullo zucchero sintattico per i bytecode JVM o CLR? :)
Dico solo

2

Le enumerazioni Java consentono facili conversioni dattiloscritte dal nome usando il metodo valueOf generato dal compilatore, ad es

// Java Enum has generics smarts and allows this
Planet p = Planet.valueOf("MERCURY");

L'equivalente per un enum grezzo in C # è più dettagliato:

// C# enum - bit of hoop jumping required
Planet p = (Planet)Enum.Parse(typeof(Planet), "MERCURY");

Tuttavia, se segui il percorso sugegsted di Kent, puoi facilmente implementare un ValueOfmetodo nella tua classe enum.


L'esempio Java sta usando un metodo sintetico generato dal compilatore - niente a che fare con i generici. Enum ha un metodo valueOf generico, ma che utilizza generici di classe e non quelli di Enum.
Tom Hawtin - tackline

2

Ho il sospetto che gli enum in C # siano solo costanti interne al CLR, ma non così familiari. Ho decompilato alcune classi in Java e posso dire che vuoi che Enums sia una volta convertito.

Java fa qualcosa di subdolo. Tratta la classe enum come una classe normale con, per quanto posso immaginare, usando molte macro quando si fa riferimento ai valori enum. Se si dispone di un'istruzione case in una classe Java che utilizza enum, sostituisce i riferimenti enum agli interi. Se hai bisogno di passare alla stringa, crea una matrice di stringhe indicizzate da un ordinale che utilizza in ogni classe. Ho il sospetto di risparmiare sulla boxe.

Se scarichi questo decompilatore, vedrai come crea la sua classe e la integra. Piuttosto affascinante per essere onesto. Non usavo la classe enum perché pensavo che fosse gonfio solo per una serie di costanti. Mi piace meglio del modo limitato in cui puoi usarli in C #.

http://members.fortunecity.com/neshkov/dj.html - Decompilatore Java


0

L'enum in Java è molto più complesso dell'enumerazione C # e quindi più potente. Dal momento che è solo un altro tempo di compilazione zucchero sintattico, mi chiedo se valesse davvero la pena includere il linguaggio dato il suo uso limitato nelle applicazioni della vita reale. A volte è più difficile mantenere le cose fuori dalla lingua che rinunciare alla pressione di includere una funzione minore.


2
Rispetto rispettosamente. Gli enum di Java 1.5 sono una potente funzionalità del linguaggio che ho usato numerose volte per implementare una soluzione più incentrata su OO a un problema relativo al set discreto di elementi con nome costante.
Ogre Salmo33,

1
Forse lo hai fatto. Ma al di là dell'integrazione intelligente del linguaggio "switch", il resto della funzionalità può essere facilmente replicato in C # o Java stesso, come mostrato dagli esempi precedenti.
dmihailescu,

@dmihailescu "Quindi l'enum in Java è molto più complesso di C #. Quindi ho lasciato cadere Java ..."
Mukus,

0
//Review the sample enum below for a template on how to implement a JavaEnum.
//There is also an EnumSet implementation below.

public abstract class JavaEnum : IComparable {
    public static IEnumerable<JavaEnum> Values {
        get {
            throw new NotImplementedException("Enumeration missing");
        }
    }

    public readonly string Name;

    public JavaEnum(string name) {
        this.Name = name;
    }

    public override string ToString() {
        return base.ToString() + "." + Name.ToUpper();
    }

    public int CompareTo(object obj) {
        if(obj is JavaEnum) {
            return string.Compare(this.Name, ((JavaEnum)obj).Name);
        } else {
            throw new ArgumentException();
        }
    }


    //Dictionary values are of type SortedSet<T>
    private static Dictionary<Type, object> enumDictionary;
    public static SortedSet<T> RetrieveEnumValues<T>() where T : JavaEnum {
        if(enumDictionary == null) {
            enumDictionary = new Dictionary<Type, object>();
        }
        object enums;
        if(!enumDictionary.TryGetValue(typeof(T), out enums)) {
            enums = new SortedSet<T>();
            FieldInfo[] myFieldInfo = typeof(T).GetFields(BindingFlags.Static | BindingFlags.DeclaredOnly | BindingFlags.Public);
            foreach(FieldInfo f in myFieldInfo) {
                if(f.FieldType == typeof(T)) {
                    ((SortedSet<T>)enums).Add((T)f.GetValue(null));
                }
            }
            enumDictionary.Add(typeof(T), enums);
        }
        return (SortedSet<T>)enums;
    }
}


//Sample JavaEnum
public class SampleEnum : JavaEnum {
    //Enum values
    public static readonly SampleEnum A = new SampleEnum("A", 1);
    public static readonly SampleEnum B = new SampleEnum("B", 2);
    public static readonly SampleEnum C = new SampleEnum("C", 3);

    //Variables or Properties common to all enums of this type
    public int int1;
    public static int int2 = 4;
    public static readonly int int3 = 9;

    //The Values property must be replaced with a call to JavaEnum.generateEnumValues<MyEnumType>() to generate an IEnumerable set.
    public static new IEnumerable<SampleEnum> Values {
        get {
            foreach(var e in JavaEnum.RetrieveEnumValues<SampleEnum>()) {
                yield return e;
            }
            //If this enum should compose several enums, add them here
            //foreach(var e in ChildSampleEnum.Values) {
            //    yield return e;
            //}
        }
    }

    public SampleEnum(string name, int int1)
        : base(name) {
        this.int1 = int1;
    }
}


public class EnumSet<T> : SortedSet<T> where T : JavaEnum {
    // Creates an enum set containing all of the elements in the specified element type.
    public static EnumSet<T> AllOf(IEnumerable<T> values) {
        EnumSet<T> returnSet = new EnumSet<T>();
        foreach(T item in values) {
            returnSet.Add(item);
        }
        return returnSet;
    }

    // Creates an enum set with the same element type as the specified enum set, initially containing all the elements of this type that are not contained in the specified set.
    public static EnumSet<T> ComplementOf(IEnumerable<T> values, EnumSet<T> set) {
        EnumSet<T> returnSet = new EnumSet<T>();
        foreach(T item in values) {
            if(!set.Contains(item)) {
                returnSet.Add(item);
            }
        }
        return returnSet;
    }

    // Creates an enum set initially containing all of the elements in the range defined by the two specified endpoints.
    public static EnumSet<T> Range(IEnumerable<T> values, T from, T to) {
        EnumSet<T> returnSet = new EnumSet<T>();
        if(from == to) {
            returnSet.Add(from);
            return returnSet;
        }
        bool isFrom = false;
        foreach(T item in values) {
            if(isFrom) {
                returnSet.Add(item);
                if(item == to) {
                    return returnSet;
                }
            } else if(item == from) {
                isFrom = true;
                returnSet.Add(item);
            }
        }
        throw new ArgumentException();
    }

    // Creates an enum set initially containing the specified element(s).
    public static EnumSet<T> Of(params T[] setItems) {
        EnumSet<T> returnSet = new EnumSet<T>();
        foreach(T item in setItems) {
            returnSet.Add(item);
        }
        return returnSet;
    }

    // Creates an empty enum set with the specified element type.
    public static EnumSet<T> NoneOf() {
        return new EnumSet<T>();
    }

    // Returns a copy of the set passed in.
    public static EnumSet<T> CopyOf(EnumSet<T> set) {
        EnumSet<T> returnSet = new EnumSet<T>();
        returnSet.Add(set);
        return returnSet;
    }

    // Adds a set to an existing set.
    public void Add(EnumSet<T> enumSet) {
        foreach(T item in enumSet) {
            this.Add(item);
        }
    }

    // Removes a set from an existing set.
    public void Remove(EnumSet<T> enumSet) {
        foreach(T item in enumSet) {
            this.Remove(item);
        }
    }
}

0

È inoltre possibile utilizzare una classe di utilità per ciascun tipo di enum che contiene un'istanza con dati avanzati per ciascun valore di enum.

public enum Planet
{
    MERCURY,
    VENUS
}

public class PlanetUtil
{
    private static readonly IDictionary<Planet, PlanetUtil> PLANETS = new Dictionary<Planet, PlanetUtil();

    static PlanetUtil()
    {
        PlanetUtil.PLANETS.Add(Planet.MERCURY, new PlanetUtil(3.303e+23, 2.4397e6));
        PlanetUtil.PLANETS.Add(Planet.VENUS, new PlanetUtil(4.869e+24, 6.0518e6));
    }

    public static PlanetUtil GetUtil(Planet planet)
    {
        return PlanetUtil.PLANETS[planet];
    }

    private readonly double radius;
    private readonly double mass;

    public PlanetUtil(double radius, double mass)
    {
        this.radius = radius;
        this.mass = mass;
    }

    // getter
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.