/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n3_observatorio
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.observatorio.mundo;
import java.util.ArrayList;
/**
* Clase que representa el observatorio.
*/
public class Observatorio
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Cantidad de elementos que tiene el arreglo de planetas.
*/
public static final int CANTIDAD_PLANETAS = 8;
/**
* Constante para el nombre de Mercurio.
*/
public static final String NOMBRE_MERCURIO = "Mercurio";
/**
* Constante para el nombre de Venus.
*/
public static final String NOMBRE_VENUS = "Venus";
/**
* Constante para el nombre de la Tierra.
*/
public static final String NOMBRE_TIERRA = "Tierra";
/**
* Constante para el nombre de Marte.
*/
public static final String NOMBRE_MARTE = "Marte";
/**
* Constante para el nombre de Júpiter.
*/
public static final String NOMBRE_JUPITER = "Júpiter";
/**
* Constante para el nombre de Saturno.
*/
public static final String NOMBRE_SATURNO = "Saturno";
/**
* Constante para el nombre de Urano.
*/
public static final String NOMBRE_URANO = "Urano";
/**
* Constante para el nombre de Neptuno.
*/
public static final String NOMBRE_NEPTUNO = "Neptuno";
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Arreglo fijo de 8 planetas.
*/
private Planeta[] planetas;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Constructor del observatorio. Inicializa el arreglo de planetas, así como cada uno de los planetas en su posición respectiva.
*/
public Observatorio( )
{
planetas = new Planeta[CANTIDAD_PLANETAS];
planetas[ 0 ] = new Planeta( NOMBRE_MERCURIO, 0.466, 0.205, 115.88, 478.725, 7.004 );
planetas[ 1 ] = new Planeta( NOMBRE_VENUS, 0.728, 0.006, 583.92, 35.021, 339.471 );
planetas[ 2 ] = new Planeta( NOMBRE_TIERRA, 1.016, 0.0167, 365.25, 30.28, 23.45 );
planetas[ 3 ] = new Planeta( NOMBRE_MARTE, 1.665, 0.09341233, 779.95, 24.13, 1.850 );
planetas[ 4 ] = new Planeta( NOMBRE_JUPITER, 5.458, 0.09341233, 398.9, 13.069, 1.305 );
planetas[ 5 ] = new Planeta( NOMBRE_SATURNO, 10.115, 0.0541506, 378.1, 9.67, 2.484 );
planetas[ 6 ] = new Planeta( NOMBRE_URANO, 20.096, 0.04716771, 369.7, 6.835, 0.769 );
planetas[ 7 ] = new Planeta( NOMBRE_NEPTUNO, 30.327, 0.00858587, 367.5, 5.47, 1.769 );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Retorna un arreglo con los nombres de los planetas en el sistema.
* @return Un arreglo que contiene los nombres de los planetas.
*/
public String[] darNombresPlanetas( )
{
String[] nombres = new String[CANTIDAD_PLANETAS];
for( int i = 0; i < planetas.length; i++ )
{
nombres[ i ] = planetas[ i ].obtenerNombre( );
}
return nombres;
}
/**
* Método que retorna un satélite natural de un planeta identificado con el nombre.
* @param pNombrePlaneta Nombre del planeta de donde se quiere obtener el satélite natural. pNombrePlaneta != null && pNombrePlaneta != "".
* @param pNombreSatelite Nombre del satélite natural que se quiere obtener. pNombreSatelite != null && pNombreSatelite != "".
* @return El satélite natural del planeta. En caso de no existir se retorna null.
*/
public SateliteNatural darSateliteNatural( String pNombrePlaneta, String pNombreSatelite )
{
SateliteNatural satelite = null;
for( Planeta planeta : planetas )
{
if( planeta.obtenerNombre( ).equals( pNombrePlaneta ) )
{
satelite = planeta.obtenerSateliteNatural( pNombreSatelite );
}
}
return satelite;
}
/**
* Método que retorna la lista de los satélites naturales de un planeta dado.
* @param pNombrePlaneta Nombre del planeta. pNombrePlaneta != null && pNombrePlaneta != "".
* @return Lista de objetos de tipo SateliteNatural.
*/
public ArrayList<SateliteNatural> darSatelitesNaturales( String pNombrePlaneta )
{
ArrayList<SateliteNatural> satelites = new ArrayList<SateliteNatural>( );
boolean encontrado = false;
for( int i = 0; i < planetas.length && !encontrado; i++ )
{
if( planetas[ i ].obtenerNombre( ).equals( pNombrePlaneta ) )
{
satelites = planetas[ i ].obtenerSatelitesNaturales( );
encontrado = true;
}
}
return satelites;
}
/**
* Retorna una lista de los planetas que tienen menor distancia orbital que la que se pasa por parámetro.
* @param pDistancia Distancia por la cual se quiere preguntar. pDistancia > 0.
* @return Lista que contienen los nombres de los planetas que tienen menor distancia orbital que la que se pasa por parámetro.
*/
public ArrayList<String> darPlanetasPorDistancia( double pDistancia )
{
ArrayList<String> listaPlanetas = new ArrayList<String>( );
for( Planeta planeta : planetas )
{
if( planeta.obtenerDistancia( ) <= pDistancia )
{
listaPlanetas.add( planeta.obtenerNombre( ) );
}
}
return listaPlanetas;
}
/**
* Retorna una lista de los planetas que tienen menor inclinación orbital que la del planeta cuyo nombre se para por parámetro.
* @param pNombre Nombre del planeta del cual se quiere obtener su inclinación para comprar. pNombre != null && pNombre != "".
* @return Lista que contienen los nombres de los planetas que tienen menor inclinación orbital que la del planeta cuyo nombre se para por parámetro.
*/
public ArrayList<String> darPlanetasPorInclinacion( String pNombre )
{
ArrayList<String> listaPlanetas = new ArrayList<String>( );
for( int i = 0; i < planetas.length; i++ )
{
Planeta planeta = planetas[ i ];
if( planeta.obtenerNombre( ).equals( pNombre ) )
{
double inclinacion = planeta.obtenerInclinacion( );
for( int j = 0; j < planetas.length; j++ )
{
if( planetas[ j ].obtenerInclinacion( ) < inclinacion )
{
listaPlanetas.add( planetas[ j ].obtenerNombre( ) );
}
}
}
}
return listaPlanetas;
}
/**
* Agrega un satélite natural a un planeta especificado.
* @param pNombrePlaneta Nombre del planeta donde se quiere agregar el satélite natural. pNombrePlaneta != null && pNombrePlaneta != "".
* @param pNombreSatelite Nombre del satélite natural a agregar. pNombreSatellite != null && pNombreSatellite != "".
* @param pExcentricidad Excentricidad del nuevo satélite natural. pExcentricidad > 0.
* @param pInclinacion Inclinación del nuevo satélite natural. pInclinacion >0.
* @return Retorna true en caso que haya agregado el satélite natural al planeta especificado, false en caso contrario.
*/
public boolean agregarSateliteNatural( String pNombrePlaneta, String pNombreSatelite, double pExcentricidad, double pInclinacion )
{
boolean agregado = false;
for( int i = 0; i < planetas.length && !agregado; i++ )
{
if( pNombrePlaneta.equals( planetas[ i ].obtenerNombre( ) ) )
{
agregado = planetas[ i ].agregarSateliteNatural( pNombreSatelite, pExcentricidad, pInclinacion );
}
}
return agregado;
}
/**
* Método que dado el nombre de un planeta, elimina el satélite natural identificado con el nombre.
* @param pNombrePlaneta Nombre del planeta al cual se le quiere eliminar un satélite natural. pNombrePlaneta != null && pNombrePlaneta != "".
* @param pNombreSatelite Nombre del satélite natural que se quiere eliminar. pNombreSatelite != null && pNombreSatelite != "".
*/
public void eliminarSatelite( String pNombrePlaneta, String pNombreSatelite )
{
boolean encontrado = false;
for( int i = 0; i < planetas.length && !encontrado; i++ )
{
Planeta planeta = planetas[ i ];
if( planeta.obtenerNombre( ).equals( pNombrePlaneta ) )
{
planeta.eliminarSateliteNatural( pNombreSatelite );
encontrado = true;
}
}
}
/**
* Método que cambia la excentricidad y la inclinación de un satélite natural dado, de un planeta dado.
* @param pNombrePlaneta Nombre del planeta donde se encuentra el satélite natural. pNombrePlaneta != null && pNombrePlaneta != "".
* @param pNombre Nombre del satélite natural. pNombre != null && pNombre != "".
* @param pExcentricidad Nuevo valor de la excentricidad para el satélite natural. pExcentricidad > 0.
* @param pInclinacion Nuevo valor de la inclinación para el satélite natural. pInclinacion > 0.
*/
public void editarSateliteNatural( String pNombrePlaneta, String pNombre, double pExcentricidad, double pInclinacion )
{
for( int i = 0; i < planetas.length; i++ )
{
if( planetas[ i ].obtenerNombre( ).equals( pNombrePlaneta ) )
{
planetas[ i ].editarSateliteNatural( pNombre, pExcentricidad, pInclinacion );
}
}
}
// -----------------------------------------------------------------
// Puntos de Extensión
// -----------------------------------------------------------------
/**
* Método de extensión 1.
* @return El mensaje resultado de la extensión 1.
*/
public String metodo1( )
{
return "Respuesta 1";
}
/**
* Método de extensión 2
* @return El mensaje resultado de la extensión 2.
*/
public String metodo2( )
{
return "Respuesta 2";
}
}
|
Interfaz
DialogoConsultarPorInclinacion