Archivo para 30 abril 2013

30
Abr
13

Redimensionamiento de imagenes en Java

Hace poco un compañero requería una funcionalidad que le entregase las fotos que tiene en el servidor en un tamaño “estándar” para que al momento de mostrarlas no hubiese unas muy grandes y otras pequeñas y así todas tendrían aproximadamente el mismo tamaño. entonces entre varias páginas pude construir una pequeña clase que:

  • Carga una imagen
  • Redimensiona una imagen
  • Guarda una imagen
  • Realiza una copia redimensionada de la imagen
package ingenio.ds.util.image;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

public class ImageResizer {
	//Ancho máximo
    public static int MAX_WIDTH=800;
	//Alto máximo
    public static int MAX_HEIGHT=800;

	/*Este método es el de la magia recibe la ruta al archivo original y la ruta donde vamos a guardar la copia
	copyImage("C:\\Users\\IngenioDS\\Desktop\\test.png","C:\\Users\\IngenioDS\\Desktop\\Copia\\test2.png");*/

    public static void copyImage(String filePath, String copyPath) {
        BufferedImage bimage = loadImage(filePath);
        if(bimage.getHeight()>bimage.getWidth()){
        	int heigt = (bimage.getHeight() * MAX_WIDTH) / bimage.getWidth();
            bimage = resize(bimage, MAX_WIDTH, heigt);
        	int width = (bimage.getWidth() * MAX_HEIGHT) / bimage.getHeight();
            bimage = resize(bimage, width, MAX_HEIGHT);
        }else{
        	int width = (bimage.getWidth() * MAX_HEIGHT) / bimage.getHeight();
            bimage = resize(bimage, width, MAX_HEIGHT);
        	int heigt = (bimage.getHeight() * MAX_WIDTH) / bimage.getWidth();
            bimage = resize(bimage, MAX_WIDTH, heigt);
        }
        saveImage(bimage, copyPath);
    }
	
	/*
	Este método se utiliza para cargar la imagen de disco
	*/
    public static BufferedImage loadImage(String pathName) {
        BufferedImage bimage = null;
        try {
            bimage = ImageIO.read(new File(pathName));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bimage;
    }

    /*
	Este método se utiliza para almacenar la imagen en disco
	*/
	public static void saveImage(BufferedImage bufferedImage, String pathName) {
        try {
            String format = (pathName.endsWith(".png")) ? "png" : "jpg";
            File file =new File(pathName);
            file.getParentFile().mkdirs();
            ImageIO.write(bufferedImage, format, file);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
	
	/*
	Este método se utiliza para redimensionar la imagen
	*/
    public static BufferedImage resize(BufferedImage bufferedImage, int newW, int newH) {
        int w = bufferedImage.getWidth();
        int h = bufferedImage.getHeight();
        BufferedImage bufim = new BufferedImage(newW, newH, bufferedImage.getType());
        Graphics2D g = bufim.createGraphics();
        g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
        g.drawImage(bufferedImage, 0, 0, newW, newH, 0, 0, w, h, null);
        g.dispose();
        return bufim;
    }
}
Anuncios
30
Abr
13

Propiedades de la P.O.O. (Encapsulamiento)

El Encapsulamiento  es una de las características de la programación orientada a objetos, esta trata de reducir el nivel de cohesión entre clases a través de dos principios básicos:

1) ocultar la complejidad del código y

2) ocultar las fuentes de cambios; proporcionando una interfaz pública de la clase más fácil de usar.

El primer punto hace referencia a: que podemos utilizar una funcionalidad de la clase sin necesidad de conocer la naturaleza de la complejidad que se desarrolla al ejecutar dicha funcionalidad o sea que podemos ejecutar un método y esperar una respuesta de este sin conocer la lógica que se desarrolla para entregar dicha respuesta. El segundo punto hace referencia a que dicha complejidad puede cambiar incluso en su implementación, pero a nivel externo seguirá funcionando sin que los llamados a esta funcionalidad se de por advertidos, o sea que usamos un método de una clase e instalamos una nueva versión de dicha clase y puede que el código de dicho método tuviese una actualización pero a nosotros como usuarios de dicho método en realidad lo único que nos interesa es que el método ofrezca la misma respuesta.

En otras palabras el punto uno se refiere a que la clase provea los métodos para usar la lógica interna sin necesidad de  que conozcamos dicha lógica y el segundo punto hace referencia a que dicho código puede cambiar y no nos afecte en la manera que los hayamos usado.

Al momento de encapsular las abstracciones es un proceso de cuidado y debe hacerse de manera adecuada, ya que realizar la descripción de interfaces sin los niveles adecuados de encapsulación terminará causando dificultades a los cambios que se den de manera posterior. Así podemos entender a la encapsulación como un atributo que permite modificación, evolución, crecimiento de nuestro código, siempre y cuando respetemos la interfaz pública de nuestras clases ademas reducir la complejidad de las abstracciones. proporcionando una forma de ocultar los detalles de implementación y también nos ayudan a minimizar la interdependencia y facilitar el modificaciones a su vez brindando la libertad para cambiar lo que queramos del funcionamiento interno encapsulado.  podemos resumir la encapsulación en la siguiente premisa En la maximización de encapsulación, reduciendo al mínimo la exposición de los detalles de implementación.

La encapsulación es mucho más que getters y setters, y la naturaleza de esta va mucho más allá que la de proporcionar una interfaz pública a atributos privados. El sentido de los getters y setters no es para ocultar los datos en sí, en realidad es para ocultar los detalles de la implementación de cómo se manipula la información. Así, una vez más, lo que hacemos es proporcionar una interfaz pública a través del cual podemos acceder a estos datos.

el ejemplo más sencillo que se me puede ocurrir de encapsulamiento es:

package ingenio.ds.examples;

public class Main {

   public static void main(String argumentos[]){
		/*Al momento de acceder a la propiedad nombre del estudiante ya que es públi
		 *ca no tenemos ningún problema en tomar el valor. Y esta se nos mostrará c
		 *omo null.
		 *Al momento de acceder a la propiedad nombre del profesor este encapsula c
		 *ierta lógica que nos impide accesarla de manera directa y apersar que el
		 *valor es null el dato retornado es diferente.
		 */
		 Estudiante estudiante= new Estudiante();
		 Profesor profesor= new Profesor();
		 System.out.println("Nombre estudiante "+estudiante.nombre);
		 System.out.println("Nombre profesor   "+profesor.getNombre());
	}
}

class Estudiante {
	public String nombre;
	public String identificacion;
}

class Profesor{
	private String nombre;
	private String identificacion;

	public String getNombre(){
		if(nombre==null){
			return "NULO";
		}else if(nombre==""){
			return "N/A";
		}
		return nombre;
	}

	public String getIdentificacion(){
		if(identificacion==null || nombre==""){
			return "NO IDENTIFICADO";
		}
		return nombre;
	}

	public void setNombre(String nombre){
		this.nombre=nombre;
	}
	public void setIdentificacion(String identificacion){
		this.identificacion=identificacion;
	}
}

Referencias

http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming)

http://www.javaworld.com/javaworld/jw-05-2001/jw-0518-encapsulation.html?page=9

http://java.about.com/od/workingwithobjects/a/accessormutator.htm

http://java.dzone.com/articles/why-encapsulation-matters

28
Abr
13

Propiedades de la P.O.O. (Polimorfismo parte 2)

Teniendo en cuenta todo lo expuesto en Propiedades de la P.O.O. (Interfaces)Propiedades de la P.O.O. (Clases abstractas) y Propiedades de la P.O.O. (Polimorfismo parte 1), a continuación revisaremos  como podemos realizar polimorfismo con clases abstractas.

Ademas revisamos como funciona la herencia múltiple en java.

Lo anterior es plasmado en el siguiente código:

Interfaces.java
Aquí describimos las interfaces con que vamos a trabajar

package ingenio.ds.examples;

//*definición de la interfaz mostrable*/
interface Mostrable{
	/*definición de una constante, debe ser 'static final' por convención se e
	 *scribre el nombre en mayuscula sostenida*/
	public static final boolean ES_MOSTRABLE=true;
	/*definición del método mostrar*/
	public void mostrar();
}

//*definición de la interfaz acelerable*/
interface Acelerable{
	/*definición de una constante, debe ser 'static final' por convención se e
	 *scribre el nombre en mayuscula sostenida y los espacios con '_' */
	public static final double RELACION_ACELERACION=0.2;
	/*definición del método acelerar*/
	public void acelerar(int segundos);
}

/*dentro de las interfaces también existe la figura de la herencia aunque en e
 *estas puede hacerse de manera multiple*/

interface AcelerableMostrable extends Mostrable,Acelerable{

	/*esta interfaz tiene  por herencia las constantes boolean ES_MOSTRABLE y
	 * double RELACION_ACELERACION */

	/*esta interfaz tiene  por herencia los métodos void mostrar() y void acel
	 *erar(int) */

}

Clases.java
Aquí implementamos las interfaces.

package ingenio.ds.examples;

abstract class Vehiculo implements AcelerableMostrable{
	String nombre;
	String tipoVehiculo;
	String fuenteEnergia;
	Double velocidadMaxima;
	Double velocidadActual;
	Double relacionAceleracion;
	int cantidadTripulacion;

	public Vehiculo(){
	}

	/*
	 *Este será el método general utilizado por todos vehículos que no implemen
	 *ten un método acelelar pópio, está es una implementación del metodo descr
	 *ito en la interfaz Acelerable
	 */
	public void acelerar(int segundos){
		System.out.println(" Acelerar vehículo .");
		for(int i=0;i<segundos;i++){
			velocidadActual=velocidadActual+(velocidadMaxima/2*relacionAceleracion);
			if(velocidadActual>velocidadMaxima){
				velocidadActual=velocidadMaxima;
				break;
			}
		}
	}

	public void mostrar(){
		System.out.println(" Información del vehículo");
		System.out.println(" Nombre ...........: "+nombre);
		System.out.println(" Tipo   ...........: "+tipoVehiculo);
		System.out.println(" Fuente de energía : "+fuenteEnergia);
		System.out.println(" Tripulación ......: "+cantidadTripulacion);
		System.out.println(" Velocidad máxima .: "+velocidadMaxima);
		System.out.println(" Velocidad actual .: "+velocidadActual);
	}
}

class VehiculoTerrestre extends Vehiculo{
	String tipoTerreno;

	public VehiculoTerrestre(){
		tipoVehiculo="Terrestre";
	}

	public void mostrar(){
		super.mostrar();
		System.out.println(" Tipo de terreno ..: "+tipoTerreno);
	}

}

class Bicicleta extends VehiculoTerrestre{
	String tipoBicicleta;
	int cantidadLlantas;
	String material;

	public Bicicleta(){
		nombre="Bicicleta";
		tipoTerreno="Terreno firme";
		fuenteEnergia="Propulsión humana";
		relacionAceleracion=0.04;
	}

	public void acelerar(int segundos){
		System.out.println(" Acelerar bicicleta ");
		System.out.println(" - Tomar aíre (MUCHO AÍRE) ");
		for(int i=0;i<segundos;i++){
			System.out.println(" - Aplicar más fuerza sobre el pedal ");
			System.out.println(" - Aplicar más fuerza sobre el otro pedal");
			velocidadActual=velocidadActual+(1+relacionAceleracion);
			if(velocidadActual>velocidadMaxima){
				velocidadActual=velocidadMaxima;
				break;
			}
		}
	}
}

class VehiculoAcuatico extends Vehiculo{
	String tipoNavegacion;

	public VehiculoAcuatico(){
		tipoVehiculo="Acuatico";
	}
}

class Submarino extends VehiculoAcuatico{
	String tipoSubmarino;

	public Submarino(){
		nombre="Submarino";
		fuenteEnergia="Propulsión mecánica";
		relacionAceleracion=0.15;
		tipoNavegacion="Bajo superficie";
	}

	public void mostrar(){
		super.mostrar();
		System.out.println(" Tipo de submari ..: "+tipoSubmarino);
	}

	public void acelerar(int segundos){
		System.out.println(" Acelerar submarino ");
		System.out.println(" - Inyecta combustible ");
		System.out.println(" - Gases  ");
		System.out.println(" - Chispa ");
		System.out.println(" - Aumentar presión en la combustión ");
		for(int i=0;i<segundos;i++){
			System.out.println(" - Aumentar revoluciones en las aspas ");
			velocidadActual=velocidadActual+relacionAceleracion;
			if(velocidadActual>velocidadMaxima){
				velocidadActual=velocidadMaxima;
				break;
			}
		}
	}
}

class VehiculoAereo extends Vehiculo{
	Double alturaMaxima;
	String tipoCarga;

	public VehiculoAereo(){
		tipoVehiculo="Aereo";
	}

}

class Avion extends VehiculoAereo{
	int cantidadMotores;
	String tipoAvion;

	public Avion(){
		nombre="Avión";
		fuenteEnergia="Motor";
		relacionAceleracion=0.3;
	}

	public void mostrar(){
		super.mostrar();
		System.out.println(" Tipo de avión ....: "+tipoAvion);
		System.out.println(" Cantidad de motore: "+cantidadMotores);
	}

	public void acelerar(int segundos){
		System.out.println(" Acelerar avión ");
		System.out.println(" - Inyecta combustible ");
		System.out.println(" - Gases  ");
		System.out.println(" - Chispa ");
		System.out.println(" - Aumentar presión en la combustión ");
		for(int i=0;i<segundos;i++){
			System.out.println(" - Aumentar revoluciones en el motor");
			velocidadActual=velocidadActual+(velocidadMaxima/2*relacionAceleracion);
			if(velocidadActual>velocidadMaxima){
				velocidadActual=velocidadMaxima;
				break;
			}
		}
	}
}

Main.java
Aquí dejamos que ocurra la maJia

package ingenio.ds.examples;

public class Main {

   	public static void main(String argumentos[]){
		//*Creamos instancias de las sub-clases Bicicleta, Avion, Submarino*/
		Avion v1=new Avion();
		Bicicleta v2=new Bicicleta();
		Submarino v3=new Submarino();

		//*seteamos valores para el Avion*/
		v1.velocidadActual=0.0001;
		v1.velocidadMaxima=850.0;
		v1.cantidadTripulacion=2;
		v1.cantidadMotores=4;
		v1.tipoAvion="Pasajeros";
		v1.alturaMaxima=10400.0;

		//*seteamos valores para la Bicicleta*/
		v2.velocidadActual=1.0;
		v2.velocidadMaxima=60.0;
		v2.cantidadTripulacion=1;
		v2.cantidadLlantas=2;
		v2.material="Aluminio/Fibra";
		v2.tipoBicicleta="Montañera";

		//*seteamos valores para el Submarino*/
		v3.velocidadActual=0.0001;
		v3.velocidadMaxima=460.0;
		v3.cantidadTripulacion=8;
		v3.tipoSubmarino="Militar";

		//*Creamos un arreglo de la super clase y agregamos las instancias de las sub clases*/
		Vehiculo[] vehiculos= new Vehiculo[]{v1,v2,v3};
		acelerar(vehiculos);
	}
	/*
	 *En las implementaciones de Mostrable o Acelerable no nos importa
	 *de que clase son los objetos lo único que tenemos en cuenta es q
	 *ue */
	public static void acelerar(AcelerableMostrable instancias[]){
		for(AcelerableMostrable instancia:instancias){
			instancia.mostrar();
			instancia.acelerar(6);
			/*Si la instancia es de tipo Vehiculo, obtenemos la velocidad actual despues de acelerar
			 *preguntamos en caso de que no sea una instancia de Vehiculo no realizar el casting (en
			 *este ejemplo no es necesario, pero es importante realizar esa verificación en tus códi
			 *gos) */
			if (instancia instanceof Vehiculo){
				System.out.println(" Velocidad final   ."+((Vehiculo)instancia).velocidadActual );
			}
		}
	}
}
28
Abr
13

etask.it: Herramienta en gestión de proyectos

Cada nunca hago promoción a na herramienta en el blog, pero en esta ocasión les hablaré de una que me ha parecido realmente buena. es una herramienta disponible como SaaS y me da la impresión que ha sido programada en Java con Ext-JS. está herramienta es de fácil uso, es ágil, intuitivaa y funcional pero no digo más, aquí les dejo el enlace a ETaskproject-1

28
Abr
13

Propiedades de la P.O.O. (Clases abstractas)

Las clases abstractas en cierta forma son muy parecidas a las interfaces y son muy parecidas a las clases normales.  Una clase abstracta puede tener o no métodos abstractos, no pueden ser instanciadas y son utilizadas como “plantilla” para otras clases ya que si pueden ser heredadas.

Son parecidas a las interfaces ya que podemos declarar métodos abstractos y de estos no especificar la implementación, lo que obliga a las sub-clases (no abstractas) a describir la implementación de dicho método(abstract void metodo();), todos los métodos de una interfaz son abstractos sin necesidad de decirlo de manera explicita.

Tanto las interfaces como las clases abstractas permiten implementar la figura de polimorfismo dentro del código, la diferencia mas notable que hay es que en las interfaces no se puede describir la implementación de un método y la declaración de sus variables deben ser final y estáticas, dejando así una “plantilla” en blanco para ser implementada totalmente por la clase que use dicha interfaz; y por otro lugar en las clases abstractas se comparte una porción de la implementación de los métodos; proveyendo parte de la funcionalidad y dejando la otra parte para ser implementada por la sub-clase. O sea una clase abstracta con todos los métodos abstractos debería ser declarada como interfaz, de igual manera una clase abstracta que no declare ningún método abstracto debe ser declarada como una clase normal.

package ingenio.ds.examples;

public class ClasesAbstractas {

   	public static void main(String argumentos[]){
		//*Creamos instancias de las sub-clases Bicicleta, Avion, Submarino*/
		VehiculoAereo v1=new VehiculoAereo();
		VehiculoTerrestre v2=new VehiculoTerrestre();
		VehiculoAcuatico v3=new VehiculoAcuatico();

		//*seteamos valores para el VehiculoAereo*/
		v1.nombre="Avión";
		v1.velocidadActual=0.0001;
		v1.velocidadMaxima=850.0;
		v1.cantidadTripulacion=2;
		v1.alturaMaxima=10400.0;

		//*seteamos valores para la VehiculoTerrestre*/
		v2.nombre="Automovil";
		v2.tipoTerreno="Desertico";
		v2.velocidadActual=1.0;
		v2.velocidadMaxima=60.0;
		v2.cantidadTripulacion=1;

		//*seteamos valores para el VehiculoAcuatico*/
		v3.nombre="Lancha";
		v3.velocidadActual=0.0001;
		v3.velocidadMaxima=460.0;
		v3.cantidadTripulacion=8;

		//*Creamos un arreglo de la super clase y agregamos
		//las instancias de las sub clases*/
		Vehiculo[] vehiculos= new Vehiculo[]{v1,v2,v3};
		mostrar(vehiculos);
	}

	public static void mostrar(Vehiculo instancias[]){
		for(Vehiculo instancia:instancias){
			instancia.mostrar();
			System.out.println("");
		}
	}
}

abstract class Vehiculo{
	String nombre;
	String tipoVehiculo;
	String fuenteEnergia="Motor";
	Double velocidadMaxima;
	Double velocidadActual;
	Double relacionAceleracion;
	int cantidadTripulacion;

	public void mostrar(){
		System.out.println(" Información del vehículo");
		System.out.println(" Nombre ...........: "+nombre);
		System.out.println(" Tipo   ...........: "+tipoVehiculo);
		System.out.println(" Fuente de energía : "+fuenteEnergia);
		System.out.println(" Tripulación ......: "+cantidadTripulacion);
		System.out.println(" Velocidad máxima .: "+velocidadMaxima);
		System.out.println(" Velocidad actual .: "+velocidadActual);
	}
}

class VehiculoTerrestre extends Vehiculo{
	String tipoTerreno;

	public VehiculoTerrestre(){
		tipoVehiculo="Terrestre";
	}

	public void mostrar(){
		super.mostrar();
		System.out.println(" Tipo de terreno ..: "+tipoTerreno);
	}
}

class VehiculoAcuatico extends Vehiculo{
	String tipoNavegacion;

	public VehiculoAcuatico(){
		tipoVehiculo="Acuatico";
	}
}

class VehiculoAereo extends Vehiculo{
	Double alturaMaxima;
	String tipoCarga;

	public VehiculoAereo(){
		tipoVehiculo="Aereo";
	}
}
28
Abr
13

Propiedades de la P.O.O. (Polimorfismo parte 1)

Uno de los beneficios que se obtiene de la programación orientada a objetos es el Polimorfismo. Usando la definición de la RAE se define como: una “Propiedad de las especies de seres vivos cuyos individuos pueden presentar diferentes formas o aspectos“; este principio también es aplicado a la P.O.O.

El principio funciona de una manera básica y es que: diferentes objetos utilicen el mismo protocolo para funcionar de manera diferente, o dicho de otra manera: que cada Objeto responda de manera diferente al invocar el mismo método; la ventaja de esto, es que la clase donde se invoca el método no debe preocuparse de la implementación (de que manera hace lo que tiene que hacer) o el tipo de objeto que es, lo único que tiene en cuenta es que el objeto permita invocar el método especifico.

Utilizaremos el código anterior (P.O.O. Herencia)  para continuar con la explicación y le prestaremos especial atención al método mostrar y acelerar. más documentación sobre interfaces

Interfaces.java
Aquí describimos las interfaces con que vamos a trabajar

package ingenio.ds.examples;

//*definición de la interfaz acelerable*/
interface Mostrable{
	//*definición del método mostrar*/
	public void mostrar();
}

//*definición de la interfaz acelerable*/
interface Acelerable{
	//*definición del método acelerar*/
	public void acelerar(int segundos);
}

Clases.java
Aquí implementamos las interfaces.

package ingenio.ds.examples;

class Vehiculo implements Acelerable,Mostrable{
	String nombre;
	String tipoVehiculo;
	String fuenteEnergia;
	Double velocidadMaxima;
	Double velocidadActual;
	Double relacionAceleracion;
	int cantidadTripulacion;

	/*
	 *Este será el método general utilizado por todos vehículos que no implemen
	 *ten un método acelelar pópio, está es una implementación del metodo descr
	 *ito en la interfaz Acelerable
	 */
	public void acelerar(int segundos){
		System.out.println(" Acelerar vehículo .");
		for(int i=0;i<segundos;i++){ 			velocidadActual=velocidadActual+(velocidadMaxima/2*relacionAceleracion); 			if(velocidadActual>velocidadMaxima){
				velocidadActual=velocidadMaxima;
				break;
			}
		}
	}

	public void mostrar(){
		System.out.println(" Información del vehículo");
		System.out.println(" Nombre ...........: "+nombre);
		System.out.println(" Tipo   ...........: "+tipoVehiculo);
		System.out.println(" Fuente de energía : "+fuenteEnergia);
		System.out.println(" Tripulación ......: "+cantidadTripulacion);
		System.out.println(" Velocidad máxima .: "+velocidadMaxima);
		System.out.println(" Velocidad actual .: "+velocidadActual);
	}
}

class VehiculoAereo extends Vehiculo{
	Double alturaMaxima;
	String tipoCarga;

	public VehiculoAereo(){
		tipoVehiculo="Aereo";
	}

}

class Avion extends VehiculoAereo{
	int cantidadMotores;
	String tipoAvion;

	public Avion(){
		nombre="Avión";
		fuenteEnergia="Motor";
		relacionAceleracion=0.3;
	}

	public void mostrar(){
		super.mostrar();
		System.out.println(" Tipo de avión ....: "+tipoAvion);
		System.out.println(" Cantidad de motore: "+cantidadMotores);
	}

	public void acelerar(int segundos){
		System.out.println(" Acelerar avión ");
		System.out.println(" - Inyecta combustible ");
		System.out.println(" - Gases  ");
		System.out.println(" - Chispa ");
		System.out.println(" - Aumentar presión en la combustión ");
		for(int i=0;i<segundos;i++){ 			System.out.println(" - Aumentar revoluciones en el motor");	 			velocidadActual=velocidadActual+(velocidadMaxima/2*relacionAceleracion); 			if(velocidadActual>velocidadMaxima){
				velocidadActual=velocidadMaxima;
				break;
			}
		}
	}

}

class VehiculoTerrestre extends Vehiculo{
	String tipoTerreno;

	public VehiculoTerrestre(){
		tipoVehiculo="Terrestre";
	}

	public void mostrar(){
		super.mostrar();
		System.out.println(" Tipo de terreno ..: "+tipoTerreno);
	}
}

class Bicicleta extends VehiculoTerrestre{
	String tipoBicicleta;
	int cantidadLlantas;
	String material;

	public Bicicleta(){
		nombre="Bicicleta";
		tipoTerreno="Terreno firme";
		fuenteEnergia="Propulsión humana";
		relacionAceleracion=0.04;
	}

	public void acelerar(int segundos){
		System.out.println(" Acelerar bicicleta ");
		System.out.println(" - Tomar aíre (MUCHO AÍRE) ");
		for(int i=0;i<segundos;i++){ 			System.out.println(" - Aplicar más fuerza sobre el pedal ");	 			System.out.println(" - Aplicar más fuerza sobre el otro pedal"); 			velocidadActual=velocidadActual+(1+relacionAceleracion); 			if(velocidadActual>velocidadMaxima){
				velocidadActual=velocidadMaxima;
				break;
			}
		}
	}
}

class VehiculoAcuatico extends Vehiculo{
	String tipoNavegacion;

	public VehiculoAcuatico(){
		tipoVehiculo="Acuatico";
	}
}

class Submarino extends VehiculoAcuatico{
	String tipoSubmarino;

	public Submarino(){
		nombre="Submarino";
		fuenteEnergia="Propulsión mecánica";
		relacionAceleracion=0.15;
		tipoNavegacion="Bajo superficie";
	}

	public void mostrar(){
		super.mostrar();
		System.out.println(" Tipo de submari ..: "+tipoSubmarino);
	}

	public void acelerar(int segundos){
		System.out.println(" Acelerar submarino ");
		System.out.println(" - Inyecta combustible ");
		System.out.println(" - Gases  ");
		System.out.println(" - Chispa ");
		System.out.println(" - Aumentar presión en la combustión ");
		for(int i=0;i<segundos;i++){ 			System.out.println(" - Aumentar revoluciones en las aspas ");	 			velocidadActual=velocidadActual+relacionAceleracion; 			if(velocidadActual>velocidadMaxima){
				velocidadActual=velocidadMaxima;
				break;
			}
		}
	}
}

Main.java
Aquí dejamos que ocurra la maJia

package ingenio.ds.examples;

public class Main {

   public static void main(String argumentos[]){
		//*Creamos instancias de las sub-clases Bicicleta, Avion, Submarino*/
		Avion v1=new Avion();
		Bicicleta v2=new Bicicleta();
		Submarino v3=new Submarino();

		/*seteamos valores para el Avion*/
		v1.velocidadActual=0.0001;
		v1.velocidadMaxima=850.0;
		v1.cantidadTripulacion=2;
		v1.cantidadMotores=4;
		v1.tipoAvion="Pasajeros";
		v1.alturaMaxima=10400.0;

		//*seteamos valores para la Bicicleta*/
		v2.velocidadActual=1.0;
		v2.velocidadMaxima=60.0;
		v2.cantidadTripulacion=1;
		v2.cantidadLlantas=2;
		v2.material="Aluminio/Fibra";
		v2.tipoBicicleta="Montañera";

		//*seteamos valores para el Submarino*/
		v3.velocidadActual=0.0001;
		v3.velocidadMaxima=460.0;
		v3.cantidadTripulacion=8;
		v3.tipoSubmarino="Militar";

		//*Creamos un arreglo de la super clase y agregamos las instancias de las sub clases*/
		Vehiculo[] vehiculos= new Vehiculo[]{v1,v2,v3};
		acelerar(vehiculos);
	}

	//*recibimos un arreglo de la super clase
	public static void acelerar(Acelerable acelerables[]){
		//*recorremos este arreglo*/
		for(Acelerable acelerable:acelerables){
			//*he invocamos al método mostrar, definido en la interfaz Mostrable
			((Mostrable)acelerable).mostrar();
			//*aceleramos durante 6 segundos
			acelerable.acelerar(6);
			//*mostramos la velocidad final descrita en la clase Vehiculo
			System.out.println(" Velocidad final ..: "+((Vehiculo)acelerable).velocidadActual);
			System.out.println("");
		}
		/*Al método void acelerar(Acelerable[])
		 *en las líneas 47 y 49, no le consierne cuales son los procesos internos q
		 *ue se deben realizar para acelerar un vehículo, ni para mostrar la inform
		 *ación del mismo; lo único que se toma en cuenta es que esté permita invoc
		 *ar dichos métodos.
		 */
	}
}
27
Abr
13

Ingenio DS en Dopbox

Lamentablemente el escritor de Ingenio DS no ha tenido el tiempo de escribir y la editora no ha tenido tiempo de editar, pero a petición de varios de nuestros lectores pasamos los archivos de ejemplos a DropBox;  si encuentran un enlace roto a alguno de nuestros ejemplos avisen por aquí o por facebook o por twitter 2013-04-27_10h44_10




I+Ds

Dudas consultas
Facebook
Twiter
Google +

Escribe tu dirección de correo electrónico para suscribirte a este blog, y recibir notificaciones de nuevas publicaciones por correo.

Únete a otros 350 seguidores

Redes Sociales y Archivos

Entradas

abril 2013
L M X J V S D
« Feb   May »
1234567
891011121314
15161718192021
22232425262728
2930  

IngenioDS en twiter


A %d blogueros les gusta esto: